A GraphQL API for monitoring, and a REST API for WebPixie’s tools
Manage your monitoring programmatically over GraphQL: 25+ queries and 20+ mutations, API keys over Basic auth, and event-driven webhooks. A REST API, built on WebPixie’s Tools infrastructure, exposes the tools WebPixie runs inside the product, such as DNS and domain lookups, to call from your own code.
See the API shape before you wire it in
Real GraphQL fields, site-management mutations, and REST tools endpoints, so you can see exactly what you will be calling.
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
}
}
}REST tools request
Use Basic auth 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. API access is available on Pro and above, with authenticated GraphQL requests and plan-based REST tool quotas.
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. Alongside it, a REST API built on WebPixie’s Tools infrastructure exposes the same 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 resolution, SSL check and expiration events, and domain expiration 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 full queries and mutations across your monitoring, so anything you do in the dashboard you can script. For calling the tools WebPixie runs inside the product, such as DNS and domain lookups, there is a separate REST tools API.
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 resolution, SSL check failures, SSL expiration, and domain expiration. Connect them to Slack, an on-call tool, 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 the API covers the full monitoring lifecycle, 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
API access is available on Pro and above. 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 and certificate 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 a GraphQL 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. API access is available on 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, alongside the GraphQL API there is a REST API, and the two serve different purposes. 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 the 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 authenticate with 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. API access is available on Pro, Enterprise plans, it pairs well with webhook notifications and incident management, and you can compare availability on the pricing page.
Yes, you can integrate WebPixie with CI/CD pipelines using the GraphQL 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, incident resolution, SSL expiration, and domain expiration 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 resolution for uptime checks, SSL check failures, SSL expiration, and domain expiration. 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 trigger the escalation policy your team already uses. Supported webhook event flows include incident creation and resolution for uptime checks, SSL check failures, SSL expiration, and domain expiration. 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 use email alerts, Slack notifications, or webhook-triggered notifications through tools such as PagerDuty, Opsgenie, or internal mobile workflows. Slack notifications are available on Starter and higher plans, while webhooks are available on Pro and higher plans. This means your team can still receive mobile push notifications through the tools already used for on-call 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, a REST tools API, scoped keys, and event webhooks.