Sign in
Start free
API · GraphQL · Rate limiting

Test your API and GraphQL
without writing code

REST endpoints, GraphQL queries and rate-limit behaviour, all from plain JSON scenarios. Cookies carry over from the browser session automatically, so authenticated endpoints need no extra setup.

Start free See the scenarios

API and GraphQL run inside web tests and are not metered separately.

api-checkout.json passed 
{
  "action": "api_test",
  "data": {
    "apiEndpoint": "/api/orders/1024",
    "apiMethod": "GET",
    "expectedStatus": 200
  }
}
200 OK · 184 ms content-type ok schema valid cookies reused

REST API

GET, POST, PUT, DELETE, PATCH

GraphQL

Queries, mutations, subscriptions

Rate limit

Proof your throttling actually throttles

Auto cookies

Carried over from web_login, no setup

MCP connector

Let your coding agent write the API tests

Claude Code reads your route handlers and writes the scenario. The validator catches the trap first: an api_test step records findings and still reports passed, so a 500 response leaves the test green unless a real assertion follows it.

The agent pulls the real action catalogue before writing a step
Validation runs in milliseconds, before any request is sent
/harden sweeps your suite for checks that cannot fail
See the MCP connector
claude — retibe mcp 
> cover POST /api/orders with a test

retibe_actions · retibe_env
wrote 3 steps: login, post, assert

warn: api_test cannot fail on its own
added web_assert on order id

passed · 3/3 steps · 2.4s
saved as scenario 218
Capabilities

Everything an API suite needs

REST testing

Every HTTP method, with status, header and schema validation.

Status code checks
Header value validation
JSON schema validation
Query parameters and bodies

A mismatch is recorded as a finding, not a failed step. Follow the call with web_assert when it has to block a release.

GraphQL testing

Queries, mutations and subscriptions with data and error validation.

Variables and operation names
GraphQL error validation
Response structure checks
Subscriptions over WebSocket

Rate limiting

Fire a burst and prove the throttle holds, with the numbers to show it.

Request count and interval you set
Expected 429 after the limit
X-RateLimit header validation
Allowed vs throttled statistics

Authentication

Bearer token, Basic auth and an API key in a header name you choose. An OAuth access token goes in as a Bearer token.

Bearer Basic API key Session cookie

Smart retry

Opt a step into retries and it comes back from timeouts, network errors and missing elements. Backoff is exponential, starting at one second and doubling to a thirty-second ceiling. Every attempt is logged.

Conditional steps

Branch on an API response, a cookie, a variable or whether the previous step passed. Custom JavaScript when the built-in conditions are not enough.

Scheduled runs

Once, daily, weekly, monthly or by cron, in a visual calendar with email notifications and a success trend per scenario.

One scenario, both layers

Open a page, call the API, feed the response into a form with {{variable}}, then verify through the UI. One report covers all of it.

Detailed reports

HTML reports with the full request and response, timings, validation errors and rate-limiting statistics.

History and analytics

Find the endpoint that is quietly unstable

Full run history for every API scenario, with charts, failure analysis and automatic detection of flaky endpoints.

Timeline chart

Every API run on one timeline, with duration trend.

Stability heatmap

Which endpoint fails most often, at a glance.

Flakiness detection

Unstable tests found automatically, scored 0 to 100.

Failure analysis

Where it broke, how often, and a side-by-side run comparison.

Key metrics

Success rateshare of passing runs Avg durationaverage length Min / maxfastest and slowest run Flakiness score0 to 100, recency weighted Trendduration over the period ExportPDF report, scenario JSON
retibe.com / analytics
Run history dashboard with totals, trend by day, distribution by type and duration charts
Examples

The whole scenario is this short

Copy one, change the endpoint, run it.

REST API 
{
  "action": "api_test",
  "data": {
    "apiEndpoint":
      "https://api.example.com/users/me",
    "apiMethod": "GET",
    "expectedStatus": 200,
    "validateHeaders": {
      "content-type": "application/json"
    }
  }
}

Cookies carry over automatically after web_login

GraphQL 
{
  "action": "graphql_test",
  "data": {
    "graphqlEndpoint":
      "https://api.example.com/graphql",
    "graphqlQuery":
      "query { user(id: 1) { name email } }",
    "graphqlVariables": {},
    "graphqlValidateErrors": false
  }
}

Queries, mutations and subscriptions

Rate limiting 
{
  "action": "rate_limit_test",
  "data": {
    "rateLimitEndpoint":
      "https://api.example.com/endpoint",
    "rateLimitMethod": "GET",
    "rateLimitRequests": 20,
    "rateLimitInterval": 50,
    "rateLimitExpectedStatus": 429
  }
}

20 requests, 50 ms apart, expecting a 429

Who uses it

Three jobs it does every day

Backend developer

Checking the API after a change

Before

Every endpoint, status, header and response shape checked by hand after each change.

With ReTibe
One JSON scenario covering every endpoint
Status, header and schema assertions
Cookies reused from the login step
Result

Every endpoint verified in five minutes instead of an afternoon.

Test an API
DevOps

Proving the throttle works

Before

Rate limiting is configured, but nobody has actually confirmed it protects the API.

With ReTibe
20 requests, 50 ms apart
429 expected once the limit is hit
X-RateLimit-Remaining validated
Result

Throttling confirmed in two minutes, with allowed and blocked counts.

Check rate limiting
Platform team

Catching it right after deploy

Before

Every deploy should trigger a full API pass, but nobody has time to press run.

With ReTibe
Daily 08:00 run in the calendar
Email on failure, Jira bug filed
Success trend visible per endpoint
Result

Problems surface the morning after the deploy, not the week after.

Open the calendar

Not sure what to test first?

Send a scenario request and the AI will write one for your API within two days. Available on every plan, including Free.

Request a scenario Start free