Rocky AI

AI-powered root cause analysis for engineering teams and agents

Learn More

Detect. Communicate. Resolve.
And get back to shipping.

Checkly unifies testing, monitoring, & observability with an AI-native workflow.
Application reliability for modern engineering.

npm create checkly@latest

Trusted to keep test, staging, and prod continuously Available

Vercel
Carhartt
CrowdStrike
Airbus
Fanatics
Mistral
ServiceNow
GoFundMe
Hopper
1Password
Fastly
Total Wine

Monitoring reimagined for developers and agents

From prompt to production monitoring in seconds. Write test and monitors with AI, deploy as code, and monitor from 20+ global locations.

Prompt to monitor.

Add Checkly Skills to your agents to monitor with a single prompt.

Create a browser check that monitors our checkout flow for our top selling item, from

PressEnterto send

Code-first by default.

Write, test, and version monitors as JS/TS, Terraform, or Pulumi.

1import { test, expect } from "@playwright/test"
2import { BrowserCheck, Frequency } from "checkly/constructs"
3
4const check = new BrowserCheck("checkout-flow", {
5 name: "Checkout Flow Monitor",
6 activated: true,
7 frequency: Frequency.EVERY_10M,
8 locations: [
9 "us-east-1",
10 "eu-west-1",
11 "ap-southeast-1",
12 ],
13 alertChannels: [slackChannel, pagerDuty],
14})
15
16test("user completes checkout", async ({ page }) => {
17 await page.goto("https://app.acme.com")
18
19 // Add item to cart
20 await page.getByRole("button", {
21 name: "Add to cart"
22 }).click()
23
24 // Navigate to checkout
25 await page.getByRole("link", {
26 name: "Checkout"
27 }).click()
28
29 // Fill payment details
30 await page.getByLabel("Email")
31 .fill("user@acme.com")
32 await page.getByLabel("Card number")
33 .fill("4242424242424242")
34
35 // Submit order
36 await page.getByRole("button", {
37 name: "Pay now"
38 }).click()
39
40 // Verify confirmation
41 await expect(
42 page.getByText("Order confirmed")
43 ).toBeVisible()
44
45 // Check response time
46 const timing = await page.evaluate(
47 () => performance.now()
48 )
49 expect(timing).toBeLessThan(5000)
50})
1import { test, expect } from "@playwright/test"
2import { BrowserCheck, Frequency } from "checkly/constructs"
3
4const check = new BrowserCheck("checkout-flow", {
5 name: "Checkout Flow Monitor",
6 activated: true,
7 frequency: Frequency.EVERY_10M,
8 locations: [
9 "us-east-1",
10 "eu-west-1",
11 "ap-southeast-1",
12 ],
13 alertChannels: [slackChannel, pagerDuty],
14})
15
16test("user completes checkout", async ({ page }) => {
17 await page.goto("https://app.acme.com")
18
19 // Add item to cart
20 await page.getByRole("button", {
21 name: "Add to cart"
22 }).click()
23
24 // Navigate to checkout
25 await page.getByRole("link", {
26 name: "Checkout"
27 }).click()
28
29 // Fill payment details
30 await page.getByLabel("Email")
31 .fill("user@acme.com")
32 await page.getByLabel("Card number")
33 .fill("4242424242424242")
34
35 // Submit order
36 await page.getByRole("button", {
37 name: "Pay now"
38 }).click()
39
40 // Verify confirmation
41 await expect(
42 page.getByText("Order confirmed")
43 ).toBeVisible()
44
45 // Check response time
46 const timing = await page.evaluate(
47 () => performance.now()
48 )
49 expect(timing).toBeLessThan(5000)
50})

Global in seconds.

Deploy monitors to 20+ locations worldwide with a single command.

All passing
VirginiaN. CaliforniaIrelandFrankfurtMumbaiSingaporeTokyoSão PauloCape TownSydney

Get proactive about reliability.
Catch issues before they impact your customers.

Checkly is everything you need to give your engineering team full control over application reliability. Proactively detect, communicate, and resolve issues before they impact your customers.

Detect

Uptime Monitoring

Your First Line of Defense

Your First Line of Defense
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import { ApiCheck, AssertionBuilder, Frequency } from 'checkly/constructs'

new ApiCheck('homepage-uptime', {
  name: 'Homepage Uptime',
  activated: true,
  frequency: Frequency.EVERY_5M,
  locations: ['us-east-1', 'eu-west-1', 'ap-south-1'],
  request: {
    url: 'https://api.acme.com/health',
    method: 'GET',
    assertions: [
      AssertionBuilder.statusCode().equals(200),
      AssertionBuilder.responseTime().lessThan(2000),
    ],
  },
})

Monitor URLs, TCP ports, DNS, database backups, and more 24/7 from multiple global locations. Know exactly when a service is down, or a critical web page is unreachable - before your customers do.

Learn more
Synthetic Monitoring

Monitor Real User Flows

Monitor Real User Flows
1
2
3
4
5
6
7
8
9
10
11
12
13
import { test, expect } from '@playwright/test'

test('user can complete checkout', async ({ page }) => {
  await page.goto('https://app.acme.com')

  await page.getByRole('button', { name: 'Add to cart' }).click()
  await page.getByRole('link', { name: 'Checkout' }).click()

  await page.getByLabel('Email').fill('user@acme.com')
  await page.getByRole('button', { name: 'Pay now' }).click()

  await expect(page.getByText('Order confirmed')).toBeVisible()
})

Use Playwright to simulate real user interactions across your web application and APIs to proactively identify functional errors or performance issues, like a broken user flow, before they impact customers.

Learn more

Communicate

Alerts

Smart Alerting

Smart Alerting
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import { SlackAlertChannel, EmailAlertChannel } from 'checkly/constructs'

const slack = new SlackAlertChannel('slack-oncall', {
  url: 'https://hooks.slack.com/services/T00/B00/XXX',
  channel: '#oncall-alerts',
  sendFailure: true,
  sendRecovery: true,
  sendDegraded: true,
})

const email = new EmailAlertChannel('email-ops', {
  address: 'ops-team@acme.com',
  sendFailure: true,
  sendDegraded: true,
})

Get notified instantly via Slack, PagerDuty, email, and more. Intelligent alert routing ensures the right team members are informed.

Learn more
Status Pages

Communicate with your customers in real-time

Communicate with your customers in real-time

Keep your customers informed with beautiful, branded status pages. Automated updates based on your monitoring results.

Learn more

Resolve

Traces

Follow failures through your entire stack

Follow failures through your entire stack
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import { NodeSDK } from '@opentelemetry/sdk-node'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node'

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'https://otel.eu-west-1.checklyhq.com',
    headers: {
      Authorization: `Bearer ${process.env.CHECKLY_OTEL_KEY}`,
    },
  }),
  instrumentations: [getNodeAutoInstrumentations()],
})

sdk.start()

Follow requests through your entire stack with Checkly and OpenTelemetry. Identify bottlenecks and understand the full context of errors with detailed trace data.

Learn more
Root Cause Analysis

Get fast, actionable insights & get it fixed faster

Get fast, actionable insights & get it fixed faster

Quickly identify and fix errors with detailed summaries and analysis of your check runs from Rocky AI.

“Checkly is super easy to use and fits perfectly in our toolchain. We monitor our Vercel projects on preview and production to catch issues earlier and we can trust that we are the first ones to know about problems in production.”

Andreas Wixler

Andreas Wixler

CTO & Founder - Finn.auto

Read Case Study

Your entire monitoring stack, delivered as code.

Checkly enables scalable, automated, and programmable creation and configuration of tests, monitors, alerts, and more. Perfect for developers and AI agents alike.

API Checks

Monitor APIs

HTTP requests + assertions. Configure URL, method, headers, authentication, request body, and validations for status code, JSON properties, etc. You can also script multi-step flows and run them from multiple regions on a schedule or on demand.

1
2
3
4
5
6
7
8
9
10
11
new ApiCheck('ListBooks', {
  name: 'List Books',
  frequency: 5,
  request: {
    url: 'https://api.example.com/books',
    method: 'GET',
    assertions: [
      { source: 'STATUS_CODE', comparison: 'EQUALS', target: '200' }
    ]
  }
})
Setup & Teardown Scripts

Run setup code before and after checks

Run Node.js code before and after an API check. Useful for fetching tokens, seeding data, or cleaning up resources. Each retry attempt re-runs these scripts.

1
2
3
4
5
6
7
8
9
new ApiCheck('SetupTeardown', {
  setupScript: `
    const token = await fetchToken()
    request.headers.Authorization = \`Bearer \${token}\`
  `,
  teardownScript: `
    await cleanupData()
  `
})
Check-Level Settings

Customize each monitor

Enable SSL checks, follow redirects, or set concurrency limits. Adjust response time thresholds for degraded vs. down states. Configure advanced request parameters for each check.

1
2
3
4
5
6
new ApiCheck('CustomSettings', {
  doubleCheck: true,
  sslCheck: true,
  degradedResponseTime: 3000,
  maxResponseTime: 6000
})
Retry Strategy

Reduce False Positives

Configure how many times to retry a failing check and the intervals (fixed, linear, or exponential). Control if retries stay in the same region or move to different ones. Helps reduce false positives.

1
2
3
4
5
6
7
new ApiCheck('RetryCheck', {
  retryStrategy: {
    type: 'EXPONENTIAL',
    maxRetries: 3,
    baseBackoffSeconds: 5
  }
})
Alerting & Channels

Notify the right teams

Set up how you want to be alerted on failures, degraded performance, or recovery. Connect channels like Slack, Email, SMS, Webhooks, PagerDuty, etc. Fine-tune which alerts go where.

1
2
3
4
5
6
7
8
9
10
11
const slackChannel = new AlertChannel('Slack', {
  slack: { url: 'https://hooks.slack.com/...' }
})

new ApiCheck('AlertDemo', {
  alertChannels: [slackChannel],
  alertSettings: {
    escalationType: 'RUN_BASED',
    runBasedEscalation: { failedRunThreshold: 2 }
  }
})
Alert Muting / Maintenance

Mute alerts or entire groups

Mute checks or entire groups to temporarily suppress alerts (for known downtime). Programmatically manage maintenance windows via code without using the UI.

1
2
3
4
new ApiCheck('MutedCheck', {
  name: 'Maintenance',
  muted: true
})
Browser Checks

Monitor Apps & Frontends

Automated end-to-end flows using Playwright. Simulate user actions like logins, form submissions, checkout flows, etc., all in real browsers. Great for testing user journeys in production.

1
2
3
4
5
6
7
8
9
10
11
12
13
new BrowserCheck('LoginFlow', {
  frequency: 10,
  code: `
    import { test, expect } from '@playwright/test'
    test('login flow', async ({ page }) => {
      await page.goto('https://example.com/login')
      await page.fill('#user', 'admin')
      await page.fill('#pass', 'secret')
      await page.click('#submit')
      await expect(page.locator('text=Welcome')).toBeVisible()
    })
  `
})
Scheduling & Locations

Configure schedules and locations of monitors

Configure checks to run on a fixed frequency or on demand. Choose from multiple data center locations globally (or private locations). Optionally run checks in parallel or round-robin.

1
2
3
4
5
new ApiCheck('GlobalCheck', {
  frequency: 5,
  locations: ['us-east-1', 'eu-west-1'],
  runLocation: 'PARALLEL'
})
TCP Checks

TCP Checks

Monitor the availability of a TCP-based service (like SSH, SMTP, or custom ports). Specify host, port, and frequency. Get alerted if the TCP connection fails.

1
2
3
4
5
6
7
8
9
10
import { Check, CheckType } from '@checkly/cli/constructs'

new Check('TcpCheck', {
  name: 'SSH Availability',
  type: CheckType.TCP,
  host: 'myserver.example.com',
  port: 22,
  frequency: 5,
  activated: true
})

Checkly integrates with the open source & developer tools you use on a daily basis. From CI, to alerting, to reporting.

Image

GitHub

Run your checks right after a deploy in GitHub actions and get a detailed report directly in your GitHub pull request.

GitHub Integration

Image

Vercel

Create and run checks automatically against production and preview environments for all your Vercel projects.

Vercel Integration

Image

Coralogix

Integrate your Checkly data with Coralogix and monitor your incidents from your Coralogix dashboard.

Coralogix Integration

Prometheus logo

Prometheus

Export your monitoring data to Prometheus and integrate it into your Grafana dashboards.

Prometheus Integration

Slack logo

Slack

Get detailed alerts and logs in Slack when a check fails, degrades or recovers.

Slack Integration

Image

Rootly

Coordinate, learn from, and resolve incidents faster, directly in Slack and Teams using Rootly

Rootly Integration

Pagerduty logo

Pagerduty

Open and close incidents automatically in Pagerduty for as many teams as you need.

Pagerduty Integration

OpsGenie logo

OpsGenie

Open and close incidents automatically in OpsGenie for as many teams as you need.

OpsGenie Integration

GitLab logo

GitLab CI

Create and run checks automatically against production and preview environments in your Gitlab CI/CD pipeline.

GitLab Integration

Jenkins logo

Jenkins

Create and run checks automatically against production and preview environments in your Jenkins CI/CD pipeline.

Jenkins Integration

Image

Incident.io

Kick off and resolve incidents in Incident.io.

Incident.io Integration

Microsoft Teams logo

Microsoft Teams

Get detailed alerts and logs in Teams when a check fails, degrades or recovers.

Teams Integration

Telegram logo

Telegram

Get alerts in your Telegram chats when a check fails, degrades or recovers.

Telegram Integration

Confidence in what your ship, unified in a single platform

Testing

Monitoring

Observability

Incident Management

Get started with the entire Checkly platform today for free.

https://app.checklyhq.com
Image
Image
Image
Image