# Did Our Public API Examples Break Overnight? An API Company's Postman Monitor Review

An API company's agent reads last night's Postman monitor runs, groups failing requests and assertions, and tells developer support which documented examples broke.

[Run this on Rush](https://cloud.getrush.ai/run/review-overnight-api-monitor-failures/postman/). Opens the console with this prompt ready to send. Connect Postman there first.

## What the agent does

This is for a company that sells an API, say shipping rates and labels for online stores, and publishes its getting-started guide as a Postman collection that developers fork. Postman monitors run that collection against the sandbox on a schedule, so a broken example is caught before a new developer hits it. Each morning someone on the developer-support team has to open each monitor, find the failed runs and work out whether a failure is new, which example it is, and whether it is the API or the collection that is wrong. The agent does that reading. Someone connects Postman once with `POST /me/connections {"type": "mcp", "name": "postman", "url": "https://mcp.postman.com/mcp", "auth": {"mode": "oauth"}}`, the full server, whose tools include the monitor ones.

The run calls `getMonitors` with the workspace id and `active` set to true. For each monitor it pages through `listMonitorExecutions` (25 a page, following the cursor) back to the start of the night, then follows Postman's own three steps: `listRunsForExecution` for each execution's runs, one per region the monitor runs from, and `getMonitorRunResults` for each run, which returns the result counts and the assertion events with their failure details.

It collects every failed assertion and every request that errored, with the monitor, the request's name, the assertion text or the error, the response status and the time, and folds identical failures into one line. For each group it checks the newest execution before the window: a request that also failed yesterday is a known problem, and one that passed yesterday and fails tonight is news. A failure in one region and not the others is reported as such, since it points away from the example itself. It calls `getCollection` on the monitor's collection to give each failing request the folder and name a reader of the docs would recognise.

It runs nothing. `runCollection` sends every request in the collection, which against an API that creates labels or charges cards is a real action, and `runMonitor` does the same through the monitor; the prompt forbids both, along with every tool that creates, updates or deletes.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Review Postman monitor results since 2026-11-13T18:00:00Z in workspace <workspace id>. Call getMonitors with that workspace and active true. For each monitor, page through listMonitorExecutions until executions are older than that time; for each execution call listRunsForExecution, then getMonitorRunResults for each run. Collect every failed assertion and errored request: monitor, region, request name, assertion text or error, response status, time. Group identical failures, and note when a failure happened in some regions only. For each group say whether the same request failed in the newest execution before that time. For each failing request call getCollection on the monitor's collection and give the request's folder and name. Write failures.md, new failures first, and return a two-line summary. Do not call runMonitor, runCollection, or any tool that creates, updates or deletes.",
  "connections": [
    "postman"
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

`failures.md` comes back as an artifact on the session: a short table of failure groups, new ones first, and below it each group with the requests, the regions, the assertion that failed and the folder in the collection. The `result` is a two-line summary for the team's channel. A night with no failures produces a one-line file saying so.

The developer-support lead reads the new failures first and decides which side is wrong. An assertion that expects a field the API renamed in last night's release means the docs need updating; a 5xx from the sandbox means an engineer needs to look; a timeout in a single region is often the network, worth watching rather than acting on. The agent's grouping is a starting point for that decision, not the decision.

Every tool call and its answer are in the session's transcript, so when the summary names a run, anyone can find the same run in Postman by its id.

## Run it on every morning before support opens

In the console, a Project automation with a `schedule` trigger (`0 7 * * 1-5` in the team's timezone) can run a saved agent that names the Postman connection and holds the workspace id and the rules above, with a prompt that asks for everything since the previous evening. Its `notify_each_run` setting decides whether each morning's summary reaches the person who set it up on its own or in one daily Slack message.

A team that releases the API several times a day can also start the same request from its deploy pipeline after each release, with a window that starts at the deploy time, so a broken example is linked to the release that broke it.

## Why run it on Rush?

Postman already alerts when a monitor fails, one message per failing run. What the team needs each morning is the grouped view: which examples, since when, in which regions, and which of them are new. The agent reads every run and writes that view in the team's words. Postman's sign-in stays in Rush's connection, not a team member's API key in a script that keeps working after they leave.

Each run has its own computer and a record of every call it made and its cost. Because the instructions forbid running anything and the transcript would show any such call, the team can let the agent read production monitor results without worrying it will create a shipment or a charge.

## Frequently asked questions

### Our Postman workspace is in the EU region. Does this work?

Postman's EU server, `https://mcp.eu.postman.com/mcp`, takes only an API key, not a sign-in. Connect it as an MCP server with `{"mode": "bearer", "token": "<Postman API key>"}` as its `auth`, and name that connection on the request instead of `postman`.

### Will the agent fix the collection when an example is out of date?

Not in this setup. Postman's full server has tools that change collections, but the prompt forbids them. A person updates the example after deciding whether the API or the docs are wrong, since changing the docs to match a bug would hide it.

### Why not let it run the collection to double-check a failure?

Running the collection sends real requests to the API. Against a sandbox that is usually harmless, but the same collection may be pointed at production by an environment, and the agent cannot tell a test label from a real one. Reading the monitor's own runs gives the same evidence without that risk.

## More jobs like this: Produce a report or file, no repo

- [Audit Row-Level Security in a Supabase Project](https://getrush.ai/run/row-level-security-audit/supabase/)
- [Schedule a Week of Social Posts in Buffer](https://getrush.ai/run/schedule-a-week-of-posts/buffer/)
- [Run a Security Audit on an Angular App](https://getrush.ai/run/security-audit/angular/)
- [Run a Security Audit on an ASP.NET Core App](https://getrush.ai/run/security-audit/aspnet-core/)
- [Security Audit of a Chrome Extension](https://getrush.ai/run/security-audit/chrome-extension/)
- [Run a Security Audit on an Electron App](https://getrush.ai/run/security-audit/electron/)

## Keep reading

- [Connect Postman to Rush once, then name it on any run](https://getrush.ai/integrations/postman/)
- [Start your first run from the developer API quickstart](https://getrush.ai/docs/quickstart/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
