Skip to content
Agentic FabriqGet a demo
All integrations

UptimeRobot

DEVELOPER · DEVELOPER

Monitors, incidents, alert contacts, maintenance windows, and status pages in the account they connected.

Connect UptimeRobot with Fabriq Developer

Your user pastes their UptimeRobot credential on a page Agentic Fabriq hosts, so it never reaches your backend and never becomes one shared key across all of your users. Same call as OAuth, one more argument.

from af_sdk import AgenticFabriq

af = AgenticFabriq()                      # reads AF_APP_ID / AF_APP_SECRET

url = await af.initiate_connection(request, provider="uptime_robot", method="api_key")
return redirect(url)                      # an AF-hosted page, not yours

async with await af.for_user(request) as session:
    tools = await session.get_tools()     # only what this user granted

Provider names are surfaces, not vendors, and the authoritative list is the capabilities endpoint rather than any page including this one — an unknown name returns 400 with the valid list. Fabriq Developer is free to start and needs no provider paperwork. Start free or read the quickstart.

Connecting UptimeRobot in practice

UptimeRobot derives the rate limit from how much monitoring you bought: Free is 10 requests a minute, and a paid account gets its monitor limit times two per minute, capped at 5,000. A small paid account therefore has a small API, and the way to raise it is to buy monitors rather than to ask.

Scopes that draw scrutiny

  • account-specific api_key "Allows using all the API methods on all the monitors of an account" — creation, edits and deletes included, which is the key an agent will be handed by default.
  • read-only api_key "Allows fetching data with all the get* API endpoints." The right choice for a status-reporting agent and the one to ask for.
  • monitor-specific api_key "Allows using only the getMonitors method for the given monitor" — the narrowest grant UptimeRobot has, and enough for a single-service watcher.

Rate limits

  • Free: 10 requests/minute.
  • Paid: monitor limit × 2 requests/minute, with a maximum of 5,000 requests/minute.
  • Over the limit returns 429, with X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset and Retry-After headers.

Worth knowing

  • Authentication is HTTP Basic access authentication rather than a Bearer token, so a standard bearer client will not work unchanged.
  • Most endpoints expect the api_key in the request body; only getMonitors accepts it as a URL parameter, so a read-only polling agent and a write agent send credentials differently.
  • Because the limit scales with the monitor count, the same code is comfortable on one customer’s account and throttled on another’s with no change in behaviour.
  • Responses can be JSON, JSON-P or XML, so a parser has to pin the format explicitly rather than trusting the default.

Checked against UptimeRobot API (2026-09-29), UptimeRobot API v3 (2026-09-29)

Acts as the person, not as itself

Each user connects their own account. Every call carries both identities — the agent and the person it is acting for — so the agent can never reach past what that individual can already do.

Credentials never touch the agent

Tokens live in the vault and attach server-side at call time. The agent holds a session, not a secret, and revoking access does not mean rotating a key.

Every call on the record

Who asked, which agent acted, which action ran, and the verdict that let it through — one audit trail across every integration, not one per vendor.

What an agent can do

Each action is granted on its own. An agent allowed to read is not thereby allowed to write, and the scope beside each row is what the acting user must have connected for it to run at all.

uptime_robot_delete_alert_contacts_by_idWRITE

Delete / alert-contacts / {id}

api
uptime_robot_delete_incidents_by_id_comments_by_commentidWRITE

Delete / incidents / {id} / comments / {commentId}

api
uptime_robot_delete_integrations_by_idWRITE

Delete / integrations / {id}

api
uptime_robot_delete_maintenance_windows_by_idWRITE

Delete / maintenance-windows / {id}

api
uptime_robot_delete_monitor_groups_by_idWRITE

Delete / monitor-groups / {id}

api
uptime_robot_delete_monitors_by_idWRITE

Delete / monitors / {id}

api
uptime_robot_delete_psps_by_idWRITE

Delete / psps / {id}

api
uptime_robot_delete_tags_by_idWRITE

Delete / tags / {id}

api
uptime_robot_get_alert_contactsREAD

Retrieve / alert-contacts

api
uptime_robot_get_alert_contacts_by_idREAD

Retrieve / alert-contacts / {id}

api
uptime_robot_get_incidentsREAD

Retrieve / incidents

api
uptime_robot_get_incidents_by_idREAD

Retrieve / incidents / {id}

api
uptime_robot_get_incidents_by_id_activity_logREAD

Retrieve / incidents / {id} / activity-log

api
uptime_robot_get_incidents_by_id_alertsREAD

Retrieve / incidents / {id} / alerts

api
uptime_robot_get_incidents_by_id_commentsREAD

Retrieve / incidents / {id} / comments

api
uptime_robot_get_integrationsREAD

Retrieve / integrations

api
uptime_robot_get_integrations_by_idREAD

Retrieve / integrations / {id}

api
uptime_robot_get_maintenance_windowsREAD

Retrieve / maintenance-windows

api
uptime_robot_get_maintenance_windows_by_idREAD

Retrieve / maintenance-windows / {id}

api
uptime_robot_get_monitor_groupsREAD

Retrieve / monitor-groups

api
uptime_robot_get_monitor_groups_by_idREAD

Retrieve / monitor-groups / {id}

api
uptime_robot_get_monitorsREAD

Retrieve / monitors

api
uptime_robot_get_monitors_by_idREAD

Retrieve / monitors / {id}

api
uptime_robot_get_monitors_by_id_dependency_incidentsREAD

Retrieve / monitors / {id} / dependency / incidents

api
uptime_robot_get_monitors_by_id_dependency_statusREAD

Retrieve / monitors / {id} / dependency / status

api
uptime_robot_get_monitors_by_id_stats_response_timeREAD

Retrieve / monitors / {id} / stats / response-time

api
uptime_robot_get_monitors_by_id_stats_response_time_allREAD

Retrieve / monitors / {id} / stats / response-time / all

api
uptime_robot_get_monitors_by_id_stats_uptimeREAD

Retrieve / monitors / {id} / stats / uptime

api
uptime_robot_get_monitors_storm_protectionREAD

Retrieve / monitors / storm-protection

api
uptime_robot_get_monitors_uptime_statsREAD

Retrieve / monitors / uptime-stats

api
uptime_robot_get_pspsREAD

Retrieve / psps

api
uptime_robot_get_psps_by_idREAD

Retrieve / psps / {id}

api
uptime_robot_get_psps_by_pspid_announcementsREAD

Retrieve / psps / {pspId} / announcements

api
uptime_robot_get_psps_by_pspid_announcements_by_idREAD

Retrieve / psps / {pspId} / announcements / {id}

api
uptime_robot_get_tagsREAD

Retrieve / tags

api
uptime_robot_get_user_alert_contactsREAD

Retrieve / user / alert-contacts

api
uptime_robot_get_user_all_alert_contactsREAD

Retrieve / user / all-alert-contacts

api
uptime_robot_get_user_meREAD

Retrieve / user / me

api
uptime_robot_patch_alert_contacts_by_idWRITE

Update / alert-contacts / {id}

api
uptime_robot_patch_incidents_by_id_comments_by_commentidWRITE

Update / incidents / {id} / comments / {commentId}

api
uptime_robot_patch_integrations_by_idWRITE

Update / integrations / {id}

api
uptime_robot_patch_maintenance_windows_by_idWRITE

Update / maintenance-windows / {id}

api
uptime_robot_patch_monitor_groups_by_idWRITE

Update / monitor-groups / {id}

api
uptime_robot_patch_monitors_by_idWRITE

Update / monitors / {id}

api
uptime_robot_patch_monitors_storm_protectionWRITE

Update / monitors / storm-protection

api
uptime_robot_patch_psps_by_pspid_announcements_by_idWRITE

Update / psps / {pspId} / announcements / {id}

api
uptime_robot_post_alert_contactsWRITE

Create / alert-contacts

api
uptime_robot_post_incidents_by_id_commentsWRITE

Create / incidents / {id} / comments

api
uptime_robot_post_integrationsWRITE

Create / integrations

api
uptime_robot_post_maintenance_windowsWRITE

Create / maintenance-windows

api
uptime_robot_post_monitor_groupsWRITE

Create / monitor-groups

api
uptime_robot_post_monitorsWRITE

Create / monitors

api
uptime_robot_post_monitors_bulk_pauseWRITE

Create / monitors / bulk / pause

api
uptime_robot_post_monitors_bulk_startWRITE

Create / monitors / bulk / start

api
uptime_robot_post_monitors_bulk_updateWRITE

Create / monitors / bulk / update

api
uptime_robot_post_monitors_by_id_pauseWRITE

Create / monitors / {id} / pause

api
uptime_robot_post_monitors_by_id_resetWRITE

Create / monitors / {id} / reset

api
uptime_robot_post_monitors_by_id_startWRITE

Create / monitors / {id} / start

api
uptime_robot_post_psps_by_pspid_announcementsWRITE

Create / psps / {pspId} / announcements

api
uptime_robot_post_psps_by_pspid_announcements_by_id_pinWRITE

Create / psps / {pspId} / announcements / {id} / pin

api
uptime_robot_post_psps_by_pspid_announcements_by_id_unpinWRITE

Create / psps / {pspId} / announcements / {id} / unpin

api

Put UptimeRobot behind one governed endpoint.

Same permissions, same audit trail, whatever else you connect next.