A GraphQL API for monitoring workflows
Manage your monitoring programmatically over GraphQL: 25+ queries and 20+ mutations, API keys over Basic auth, and event-driven webhooks. REST access to WebPixie’s diagnostic tools can be enabled through custom sales arrangements when your workflow needs it.
See the API shape before you wire it in
Real GraphQL fields, site-management mutations, and custom REST tools endpoints, so you can see exactly what each API surface looks like.
GraphQL uptime query
Read active uptime monitors with only the fields your workflow needs.
query {
findUptimeLink(limit: 10) {
items {
id
name
target
status
checkInterval
lastRecord {
accessibilityStatus
spendTime
}
}
}
}Create site mutation
Add a monitored site with the product areas your workflow needs.
mutation {
createSite(
domain: "acme.io"
features: [
MONITOR_WHOIS
MONITOR_SSL
MONITOR_DNS
LINK_CRAWLER
]
notification: { all: true }
) {
id
domain
features
notification {
all
}
}
}Custom REST tools request
Sales-enabled access for domain and DNS intelligence endpoints.
GET /api/tools/v1/dns/lookup?domain=acme.io&type=A,MX,SPF
Authorization: Basic api_key:api_secret
X-Daily-Limit: 500
X-Daily-Remaining: 482Examples are based on the current GraphQL schema and REST Tools OpenAPI contract. Standard API access is available on paid plans as authenticated GraphQL access; REST tool access is enabled through custom sales arrangements.
How the WebPixie API works
WebPixie exposes a GraphQL API with full queries and mutations, so you can manage your monitoring programmatically: 25+ queries and 20+ mutations across monitors, uptime data, incidents, and workspaces.
REST access to WebPixie’s Tools infrastructure is separate from standard plan API access and is enabled only through custom sales arrangements. When enabled, it exposes diagnostic tools WebPixie runs inside the product, such as DNS and domain lookups, so you can call them from your own code.
Authentication uses API keys over HTTP Basic auth. Each key inherits the workspace role of the user who created it and can then be narrowed to specific resources, so an automation scoped to one site cannot reach the rest of the workspace.
For event-driven workflows, webhooks deliver incident creation and closure, SSL check and expiration events, and domain expiration and suspension events to your own endpoints after WebPixie generates them, so you can wire WebPixie into the tools your team already runs.
Manage your monitoring over GraphQL
25+ queries and 20+ mutations
Create and update monitors, pull uptime history, read incident state, and manage workspaces from your own code. The GraphQL API offers queries and mutations across monitoring management, so many dashboard workflows can be scripted.
Scope every key to the resources it needs
Inherited role, then narrowed to specific resources
A broad credential shared across scripts is a risk. A WebPixie key authenticates over HTTP Basic auth, inherits the role of the user who created it, and can then be narrowed to specific resources, so a key for one integration reaches only the sites and monitors it needs and nothing else in the workspace.
Drive workflows with webhooks
Incident, SSL, and domain events
Webhooks deliver generated events to your own endpoints: incident creation and closure, SSL check failures, SSL expiration, domain expiration, and domain suspension. Connect them to Slack, PagerDuty, Opsgenie, or your deployment automation, so monitoring fits the response flow you already use.
Build monitoring into your pipeline
Create monitors at deploy time, sync data out
Because GraphQL covers monitoring management workflows, you can register new environments during a deploy, pull uptime and incident data into internal dashboards, and remove monitors when a service is retired, all without opening the WebPixie UI.
Build monitoring into your workflow
GraphQL API access is available on paid plans. Compare plans to find the right fit.
Everything you need to monitor a website. In one workspace.
A quick look at other WebPixie features.
Why teams choose the WebPixie API
Automate setup and teardown
Create and remove monitors from your pipeline, so monitoring tracks your infrastructure instead of drifting from it.
Scoped access by default
Resource-scoped keys over Basic auth keep automation credentials limited to what each integration needs.
Event-driven, not polling
Webhooks deliver incident, SSL check, and SSL expiration events to your tools after WebPixie generates them, so you do not poll the API on a timer.
Frequently Asked Questions
Common questions about the WebPixie API.
Yes, WebPixie provides an API for teams that want to manage monitoring programmatically. The API integration includes queries and mutations for working with monitors, uptime data, incidents, workspaces, and related monitoring resources. Authentication uses resource-scoped API keys with Basic auth, so you can limit access by resource instead of sharing a broad workspace credential. WebPixie API access is available on Starter, Pro, Enterprise plans, and you can compare plan availability on the pricing page. Developers can use the API to create monitors during deployments, pull uptime history into internal dashboards, sync incident data, or connect WebPixie with automation tools. For alert-driven workflows, API usage pairs well with incident management and webhook notifications.
Yes, but REST API access is separate from standard plan API access and is enabled through custom sales arrangements. The GraphQL API in the API integration is how you manage monitoring programmatically, with queries and mutations for monitors, uptime data, incidents, and workspaces. The REST API is built on WebPixie's Tools infrastructure and exposes diagnostic tools WebPixie runs inside the product, such as DNS lookup and domain or WHOIS lookup, as services you can call from your own code. It is not a second way to manage your account; monitoring management stays in GraphQL. Both API surfaces use API keys over Basic auth, where a key inherits the workspace role of the user who created it and can then be narrowed to specific resources. GraphQL API access is available on Starter, Pro, Enterprise plans; REST tools API access is handled through sales-led arrangements.
Yes, you can integrate WebPixie with CI/CD pipelines using our API and webhook notifications. After a deployment, your pipeline can create or update monitors, register new environments, query uptime or incident state, and feed monitoring results into release checks or internal dashboards. The API integration uses API keys with Basic auth and resource-scoped access, which helps keep automation credentials limited to the resources they need. Webhooks can send incident creation and closure events, plus SSL expiration, domain expiration, and domain suspension events, to tools such as Slack, PagerDuty, Opsgenie, or your own deployment automation. This works well when paired with incident management, because confirmed monitoring failures can trigger the same response flow your team already uses. API and webhook availability depends on plan, so compare access on the pricing page.
WebPixie supports custom webhooks that send monitoring events to any HTTPS endpoint you configure. Webhooks are useful for tools such as PagerDuty, Opsgenie, incident management platforms, CI/CD automation, internal dashboards, and custom notification systems. Supported event flows include incident creation and closure for uptime checks, SSL check failures, SSL expiration, domain expiration, and domain suspension. The API integration works alongside webhooks, so teams can receive event-driven callbacks and then query or update resources programmatically. Slack is available as a native notification channel on eligible plans, while webhooks let you connect to systems beyond built-in integrations. Webhook availability depends on plan, so compare notification channels on the pricing page. For alert routing and incident lifecycle details, see incident management.
Yes, WebPixie can integrate with PagerDuty through custom webhooks on Pro and higher plans. Webhooks send monitoring events to an HTTPS endpoint you configure, so PagerDuty can receive alert-routing events from WebPixie and route them through the policy your team already uses. WebPixie posts the same incident and SSL/domain events used across its webhook integrations to your endpoint. This works best when paired with incident management, because confirmed failures become tracked incidents before they are routed externally. Webhook availability depends on plan, so compare notification channels on the pricing page. For programmatic workflows around the same resources, see the API integration.
WebPixie does not currently provide a dedicated mobile app for iOS or Android. For mobile incident awareness, teams usually rely on email alerts, Slack notifications, or the same webhook-to-PagerDuty/Opsgenie routing used for SMS delivery, so your team can still receive mobile push notifications through the tools already used for mobile response. Alerts can be driven by confirmed incidents from incident management, and webhook or API-based workflows can be planned around the API integration. For plan availability, review the pricing page.
Ready to automate your monitoring?
A GraphQL API, scoped keys, and event webhooks.