API monitoring

Reachable is not the same as correct

Checkly sends a real request to your API and checks the answer: the status code, the latency, the headers, and the JSON that came back. Defined as TypeScript in your repo, tested in CI, and running from 22 global locations every ten seconds if you want it.

__checks__/payments-api.check.ts
1// __checks__/payments-api.check.ts
2import { ApiCheck, AssertionBuilder, Frequency } from 'checkly/constructs'
3
4new ApiCheck('payments-charge', {
5 name: 'POST /v1/charges',
6 frequency: Frequency.EVERY_1M,
7 locations: ['us-east-1', 'eu-west-1', 'ap-southeast-1'],
8
9 degradedResponseTime: 800, // over budget, still working
10 maxResponseTime: 3000, // now it is an outage
11
12 request: {
13 method: 'POST',
14 url: 'https://api.acme.com/v1/charges',
15 body: JSON.stringify({ amount: 4200, currency: 'eur' }),
16 assertions: [
17 AssertionBuilder.statusCode().equals(201),
18 AssertionBuilder.jsonBody('$.status').equals('succeeded'),
19 AssertionBuilder.jsonBody('$.amount').equals(4200),
20 AssertionBuilder.headers('cache-control').notEmpty(),
21 ],
22 },
23})

Trusted by teams whose APIs other people build on

Vercel
Carhartt
CrowdStrike
Airbus
Fanatics
Mistral
ServiceNow
GoFundMe
Hopper
1Password
Fastly
Total Wine
A real advantage that Checkly gives us is that we’re not waiting for our users to report an issue with a product, or waiting on a staff member to file a ticket. Checkly gives us real-time feedback on what is and isn’t working.
Thomas Reither·Associate Consultant · Solutia

Three things a ping will never tell you

Most tools sold as API monitoring send a request and look at one number. The interesting failures are all in what comes back.

200 OK

A status code only proves the server answered

The endpoint returning an empty array instead of an order, or the search that quietly stopped indexing, answers 200 all day. Reachability is the cheapest property of an API and the least interesting one to watch.

1.4s

Slow and down are different failures

A single timeout treats a 1.4 second checkout call as healthy right up until it crosses the line and becomes an outage. Degraded and failed are two thresholds because they deserve two responses.

{ }

The payload is the contract

Consumers do not build against your uptime, they build against your response shape. A renamed field, a null where an object used to be, a total that stopped adding up: none of that moves a status code.

The ease of integration in our pipeline was remarkable. We have everything defined in a CI/CD pipeline using GitHub Actions using the CLI. Everything scaffolds out based on a configuration, so we just update a configuration file which specifies the environments, what services are there, what the URLs are, and from that, we just generate all the groups and their checks.

Tobias Deekens

Principal Frontend Engineer · commercetools

OPENAPI IMPORT

Your spec already describes half the monitor

Paths, methods, headers, and query parameters are already written down. Import a Swagger 2.0 or OpenAPI spec in the check creator and pick the paths worth monitoring, or read the same JSON in a check file and generate a monitor per route so a new endpoint arrives already covered. A cURL command works too.

ChecklyNew API check
Changelog7
SupportDocs
D
API Check #1
+ Add tags+ Add description
Make an HTTP request
Create an HTTP request manually or import one. Use global environment variables to store secrets and reuse them in other checks.
IP Family *
IPv4
Method *
GET
URL *
https://api.checklyhq.com
_
:// import cURL🌐 import OpenAPI/Swagger
Body
Headers
Query params
Authentication
Selecting the data type will automatically set the correct Content-Type header. You can override this by setting your own Content-Type header in the "add headers" section.

The API check creator: build the request, run it against production infrastructure with Run request, or import a spec.

__checks__/from-spec.check.ts
1// __checks__/from-spec.check.ts
2import { ApiCheck, AssertionBuilder, CheckGroupV2, Frequency } from 'checkly/constructs'
3import spec from '../openapi.json'
4
5const api = new CheckGroupV2('public-api', {
6 name: 'Public API',
7 locations: ['us-east-1', 'eu-west-1'],
8 tags: ['api', 'prod'],
9})
10
11// One monitor per GET path in the spec. Add a route, get a monitor.
12for (const [route, methods] of Object.entries(spec.paths)) {
13 if (!('get' in methods)) continue
14
15 new ApiCheck(`spec${route.replace(/\W+/g, '-')}`, {
16 name: `GET ${route}`,
17 group: api,
18 frequency: Frequency.EVERY_5M,
19 request: {
20 method: 'GET',
21 url: `https://api.acme.com${route}`,
22 assertions: [AssertionBuilder.statusCode().equals(200)],
23 },
24 })
25}

The same idea as code. Add a route to the spec, get a monitor on the next checkly deploy.

Guide: monitoring an OpenAPI spec →

Write it, test it, then deploy it

API monitors are TypeScript in the same repository as the API they watch. Run them locally against a branch, run them in CI before the deploy, and ship them with the same command that ships everything else.

01

Write the check next to the endpoint

A check file lives in the service it monitors. The pull request that changes the response shape changes the assertion in the same diff.

02

Run it in CI before you ship

npx checkly test runs the monitors as tests against a preview or staging environment, so a broken monitor never reaches production and neither does a broken endpoint.

03

Deploy monitors with the release

npx checkly deploy applies the whole project: checks, groups, alert channels, and thresholds. Monitoring never drifts from what is running.

acme-api · terminal
$ npx checkly test --record
 
Running 4 checks in eu-west-1.
 
__checks__/payments-api.check.ts
  ✓ POST /v1/charges (412ms)
  ✓ POST /v1/refunds (388ms)
__checks__/search.check.ts
  ✓ GET /v1/search (196ms)
__checks__/order-lifecycle.spec.ts
  ✓ order lifecycle (3.1s)
 
4 passed, 4 total
 
$ npx checkly deploy
 
Deploying project "acme-api" to account "Acme"...
4 checks, 2 alert channels deployed
Now running from 3 locations, every minute.

It plugs into the stack you already run

API checks are one capability on a platform that also handles browser journeys, alerting, status pages, and root cause analysis. Results flow out through native integrations and raw webhooks.

Covering a whole backend estate rather than a single endpoint, with chained flows, rotating credentials, and third party dependencies? That is the job this capability does on API and backend monitoring.

API teams, on Checkly

Checkly is a fabulous developer tool! The flexible features and developer-friendly API made the integration super easy. Bonus: their support is super friendly and knowledgeable!

Connor Hicks

Lead Developer · 1Password

Checkly was incredibly easy to integrate. Even our initial traces setup was quick, and the documentation was better than OTel’s own.

Brian Stack

Infrastructure Engineer · Render

We love Heartbeat Checks! They help us ensure that critical operations run to completion and on time. We had previously evaluated other platforms just for their heartbeat checks, so we are happy to see these within Checkly along with the API and browser checks.

Johannes Gilger

CEO & Founder · urlscan.io

Checkly has helped us save engineering resources and expenses. The number of our customer support tickets are then reduced because the customer is already proactively informed about problems without having to report the issues themselves.

Aliasger Kiranawala

Lead SDET · Locus

Checkly CLI has enhanced our engineering team’s ability to quickly build, validate and deploy an entire suite of checks from their local development environment.

Tavares Chambless

Manager, Quality Assurance · Loyal Health

Checkly Traces helped us resolve issues faster by showing exactly how long database calls are taking. This insight was crucial in pinpointing N+1 issues and optimizing caching.

James Hall

AWS Hero & Founder · Parallax

Key facts

API monitoring, in facts

What one API check can assert, how authenticated and multi-step flows are handled, and where the boundary of the product sits.

What it asserts

Status, headers, latency, and response body

Assertions cover status codes, response headers, response time, and JSON or text payloads addressed with JSONPath, so a renamed field fails the check.

Checkly API check docs (opens in a new tab)

Authenticated endpoints

Setup and teardown scripts

Mint a token, sign a request, or seed a record before the call, and clean up after it. Secrets come from encrypted environment variables.

Checkly API check docs (opens in a new tab)

Multi-step flows

Multistep checks for sequences

Chain requests that depend on each other, such as create, read, and delete, and assert at every step rather than only the last one.

Checkly API check docs (opens in a new tab)

Where checks run

22 public locations, plus private locations

Public locations show what third-party consumers experience. Private locations reach internal APIs behind a firewall.

Checkly locations docs (opens in a new tab)

How checks are managed

TypeScript, Terraform, or Pulumi in Git

API checks are code: reviewed in pull requests, run locally before merge, and deployed from CI alongside the service they cover.

Checkly monitoring as code docs (opens in a new tab)Checkly CLI docs (opens in a new tab)

What it is not

Not APM and not contract testing in CI

API monitoring runs continuously against a deployed environment. It complements code-level tracing and pre-merge contract tests rather than replacing them.

Checkly traces docs (opens in a new tab)

Facts checked . Vendor pricing and feature pages change without notice, so verify anything decision-critical against the linked source.

Fit check

Is API monitoring the right check for this?

Checkly is a strong fit when

  • A status code is not enough and you need the response body, headers, and latency asserted on every run.
  • The endpoints that matter are authenticated, or only make sense as a sequence of calls.
  • You want API checks to live beside the service code and deploy through the same pipeline.

Checkly may not be the best fit when

  • The failure you are chasing is inside your own code path. Distributed tracing and APM answer that better than an outside-in check.
  • You only need to know whether the host is reachable. A URL or TCP monitor is the cheaper answer.
  • The behaviour you want to verify only exists in a browser, such as a rendered checkout. Use a Playwright browser check.

Monitor the answer, not the pulse

Write one API check, run it from 22 locations, and find out the moment the response stops being the one your consumers build against.