Menu
Mattering Automations connector

A Postman MCP for the workspaces, collections, mocks, and monitors you already run

Connect one Postman API key and workspaces, collections, environments, mock servers, monitors, and the API Builder become workflow steps. An AI agent can fork a collection and merge it back after review, a deploy can spin up a mock server for a branch, and a failing monitor run can open a task, all next to the rest of your work instead of in a terminal.

40 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Postman MCP connector does

The Postman connector for Mattering Automations is 40 nodes on the Postman API: workspaces from listing through create, update, and delete; collections with full CRUD plus forking, an asynchronous fork merge, and the merge task-status reader that goes with it; environments and their variable sets; mock servers with publish, unpublish, and date-windowed call logs; monitors with a run you can fire outside the schedule; and the API Builder's APIs and versions. One Postman API key, sent in the X-API-Key header to api.postman.com, authenticates all of it.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can walk a team's workspaces, read what is inside them, fork a collection, apply an edit, and open the merge for review, without anyone opening the Postman app.

One design decision shows up on almost every node. Postman gives most objects two identifiers: a bare id, and a uid that combines the owner id with it. The API reference types the collection, environment, mock, and monitor path parameters as the unique id, and every cross-object reference is a unique id too, so every field in this build asks for the uid and every picker returns it. Workspaces and API Builder APIs are the exception, because Postman gives those no uid. The field names carry the difference, collection_uid and monitor_uid against workspace_id and api_id, so the canvas tells you which kind of identifier you are holding.

The safety modeling is stated on the nodes rather than buried. Of the 40 nodes, 16 read and 24 act, and seven are flagged destructive: the six deletes for workspaces, collections, environments, mock servers, monitors, and API definitions, plus the fork merge. The API has no undelete endpoint, and the objects do not all recover the same way: a deleted collection sits in the Postman app's trash for a period that depends on your plan, while a deleted workspace is not recoverable at all and takes its collections, environments, mock servers, and monitors with it, which makes the workspace delete the heaviest node in the set. Two more nodes carry the warning in their own descriptions instead of a flag. Postman: Run Monitor starts a real run, which sends every request in the monitored collection to its live targets and draws down the account's monitor usage allowance. Postman: Replace Collection removes items whose ids you omit and recreates them with new ids, which breaks anything referencing the old ones.

One connection, three surfaces

  • Visual automations. Drag Postman nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Postman node, ready to drop on the canvas

40 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 16

Postman: Get API

Fetch one API definition's metadata, and optionally the ids of the collections, schemas and versions linked to it. Note that this endpoint returns the API at the ROOT of the response (data.name, data.id), not wrapped in an api object. Git-connected APIs return only their versions and git repository information.

Postman: Get Authenticated User

Fetch the Postman user the API key belongs to: username, email, team, assigned roles, and the account's operation usage counters (API calls, mock calls, monitor request runs). Takes no parameters, so this is the credential health check to run first in any Postman automation, and the usage guard to run before a large batch.

Postman: Get Collection

Fetch a whole collection in Postman Collection Format v2.1.0: its info block, every folder and request, saved example responses, variables, auth and scripts. Set the model field to minimal when you only need the root-level request and folder ids rather than the full document.

Postman: Get Environment

Fetch one environment with all of its variables: each variable's key, value, type and whether it is enabled. Variables marked secret return their metadata rather than their value.

Postman: Get Merge Task Status

Check whether a collection merge or pull finished: returns successful, in-progress, or failed with the error message. Postman keeps a finished task's status for 24 hours and then returns 404, so poll shortly after the merge rather than the next day.

Postman: Get Mock Call Logs

Read a mock server's call logs: who called which path with which method, which saved response was served, and the status code that came back. One call returns at most 100 logs or 6.5 MB, whichever comes first, so page with the cursor. Log retention depends on your Postman plan.

Postman: Get Mock Server

Fetch one mock server: its mock URL, the collection and environment behind it, whether it is public, whether it has deactivated, and its request-matching and simulated-delay settings.

Postman: Get Monitor

Fetch one monitor with its schedule (cron and timezone), the regions it runs from, its notification and retry settings, and its last run: status, start and finish times, and the test and request pass and fail counts. This is how an automation checks whether the latest run passed.

Postman: Get Workspace

Fetch one workspace with its full contents index: the collections, environments, mock servers, monitors and API specifications it holds, each with its id, name and unique id. The cheapest way to see everything inside a workspace in one call.

Postman: List API Versions

List an API's published versions with their ids, names, release notes and timestamps, newest first. Use it to find the version id a release automation should publish against, or to check what shipped last.

Postman: List APIs

List the APIs in a workspace with their ids, names, summaries and who last changed them. The workspace is required, which is why the other API nodes ask you to paste an API id rather than offering a picker.

Postman: List Collections

List collections you own or are subscribed to, optionally narrowed to one workspace. Each row carries the collection's id, uid, name, owner and, for forks, the fork label and parent. Postman recommends paging this endpoint; unpaginated calls are treated as deprecated. Passing an unknown workspace id returns 200 with an empty list rather than an error.

Postman: List Environments

List your environments, optionally narrowed to one workspace. Each row carries the environment's id, uid, name and owner. This is the lister behind the environment picker on the mock and monitor nodes.

Postman: List Mock Servers

List active mock servers with their public mock URLs, the collection and environment each is built on, and their matching configuration. By default this returns mock servers you created across all workspaces. If both filters are filled, Postman honours the workspace one.

Postman: List Monitors

List monitors with their ids, names, active flag and the collection and environment each runs. Filter by workspace, by the collection or environment they use, or to active monitors only. This is the lister behind the monitor picker on the other monitor nodes.

Postman: List Workspaces

List every workspace you can see: your own plus any shared with you. Each row carries the workspace id, name, type and visibility. This is the lister behind the workspace picker on every other Postman node, and the starting point for any automation that walks a team's collections.

Action nodes 24

Postman: Create API

Create an API definition in a workspace. Returns the new API's id at the root of the response, ready to attach schemas, collections and versions to.

Postman: Create Collection

Create a collection in a workspace using the Postman Collection Format v2.1.0. Fill just the name for an empty collection, or pass a JSON array of items to create folders and requests in one call. Returns the new collection's id and uid.

Postman: Create Environment

Create an environment in a workspace with its starting set of variables. Useful for standing up a per-branch or per-tenant environment from an automation. The request body cannot exceed 30 MB.

Postman: Create Mock Server

Create a mock server from a collection's saved example responses and get back its mock URL, ready to point a frontend or a test suite at. Mock servers are public by default; set private to true to require a Postman API key. Collections that belong to an API definition cannot be mocked.

Postman: Create Monitor

Create a monitor that runs a collection on a schedule and emails you when it fails. Give it a collection, a cron pattern and a timezone. Monitor runs draw down your account's monitor usage allowance, so pick a frequency you actually need. Collections that belong to an API definition cannot be monitored.

Postman: Create Workspace

Create a workspace. Returns the new workspace's id, which every other Postman node can be pointed at. Postman returns 403 if your team's admins have restricted workspace creation or require approval for team workspaces, and public team workspace names must be unique.

Postman: Delete API

Permanently delete an API definition and its versions and schemas. DESTRUCTIVE: there is no undelete endpoint. Returns 204 No Content with an empty body on success.

Postman: Delete Collection

Permanently delete a collection. DESTRUCTIVE: there is no undelete endpoint, and any mock server or monitor built on the collection deactivates. Fetch the collection with Postman: Get Collection first if you want a copy.

Postman: Delete Environment

Permanently delete an environment. DESTRUCTIVE: there is no undelete endpoint, and any mock server or monitor linked to the environment deactivates.

Postman: Delete Mock Server

Permanently delete a mock server. DESTRUCTIVE: there is no undelete endpoint, and the mock URL stops answering immediately, so anything pointed at it starts failing. The underlying collection is not affected.

Postman: Delete Monitor

Permanently delete a monitor and its run history. DESTRUCTIVE: there is no undelete endpoint. To stop a monitor temporarily, use Postman: Update Monitor with active set to false instead.

Postman: Delete Workspace

Permanently delete a workspace. DESTRUCTIVE: Postman has no undelete endpoint, and the workspace's collections, environments, mock servers and monitors go with it. Export anything worth keeping first.

Postman: Fork Collection

Fork a collection into a workspace, so changes can be made and reviewed without touching the parent. Returns the fork's own id and uid plus the parent it came from. Deleting a fork never affects the parent, which is what makes this the safe way to let an automation edit someone else's collection.

Postman: Merge Collection Fork

Merge a forked collection into its parent, asynchronously. Returns a task id to poll with Postman: Get Merge Task Status. To PULL changes the other way, pass the fork as the destination and the parent as the source. DESTRUCTIVE: the merge rewrites the destination collection and there is no revert endpoint, and the deleteSource strategy additionally deletes the fork. Requires the Editor role on the collections involved.

Postman: Publish Mock Server

Publish a mock server, which sets its access control to public so anyone with the mock URL can call it without a Postman API key. Reversible with Postman: Unpublish Mock Server.

Postman: Replace Collection

Replace a collection's entire contents with the document you pass, in Postman Collection Format v2.1.0. Read the collection first, change what you need, and send the whole thing back. WARNING: items whose id values you omit are REMOVED and recreated with new ids, which breaks anything referencing the old ids. The body cannot exceed 100 MB. To change only a name, description, variables, auth or scripts, use Postman: Update Collection instead.

Postman: Replace Environment

Replace an environment's contents. The values array you send REPLACES the whole variable list, so read the environment first and send back the full set with your change applied, or variables you leave out disappear. Only shared variable values (those synced to the Postman cloud) can be changed through the API.

Postman: Run Monitor

Run a monitor now, outside its schedule, and return the run results: per-request status codes and response times, plus assertion and request totals and failures. This is a REAL run: every request in the monitored collection is sent to its live targets, and the run draws down your account's monitor usage allowance, so never point it at a collection that writes to production. Set run_async to true for long collections; a synchronous run over 300 seconds returns 202 and you read the outcome from Postman: Get Monitor.

Postman: Unpublish Mock Server

Unpublish a mock server, which sets its access control back to private so calls must carry a Postman API key. The mock server itself is not deleted, and Postman: Publish Mock Server puts it back.

Postman: Update API

Update an API definition's name, summary or description. The name is required by Postman on this endpoint even when you are only changing the description, so send the current name if you are not renaming it.

Postman: Update Collection

Update parts of a collection in place: its name and description (info), its variables, its default auth, or its scripts (events). Requests and folders are untouched, which makes this the safe way to rename a collection or rotate a variable. Postman rejects any property outside info, variable, auth and events.

Postman: Update Mock Server

Change a mock server's name, description, linked collection or environment, its private flag, or the single saved response every request should return. Only the fields you fill are sent.

Postman: Update Monitor

Change a monitor's name, schedule, regions, notification list or run options, or pause it by setting active to false. Only the fields you fill are sent, so pausing a monitor needs nothing but the monitor and active.

Postman: Update Workspace

Rename a workspace, rewrite its description, or change its visibility. Only the fields you fill are sent, so this never blanks a property you left empty. Some visibility changes are not permitted by the API (for example private to public), and publishing a public workspace is separately rate limited.

Connecting Postman takes one credential

Postman authenticates every API request with an API key sent in the X-API-Key header. That header is the form to use: the current reference documents no query parameter alternative, and no OAuth flow for the REST API this connector calls. Postman does offer OAuth, but on its own MCP server, which is a separate surface from this API. Keys are created in Postman under Settings, then Account settings, then API keys, and a key carries exactly the permissions of the user who created it. Keys can be given an expiry date, and on Enterprise teams admins can manage them centrally, which means a working connection can stop working because the key expired or was revoked rather than because anything changed in Mattering.

1

In Postman, open Settings, then Account settings, then API keys, generate a key, and copy it. It carries your own permissions, so generate it from an account whose access matches what you want the workflows to be able to do.

2

In Mattering Automations, open Connectors, click Add Connector, choose Postman, and create a credential with the API key.

3

Click Test Connection. Mattering calls Postman's authenticated-user endpoint on api.postman.com, which every valid key can call with no parameters: a successful response proves the credential, and a 401 means the key is wrong, expired, or revoked.

4

All 40 Postman nodes appear in the canvas palette. Run Postman: List Workspaces first, because the workspace id is the value most other nodes start from, then Postman: List Collections for the collection uids the collection, mock, and monitor nodes ask for.

Common uses for the Postman MCP

Mock servers that keep pace with the collection behind them

Postman: Create Mock Server builds a mock from a collection's saved example responses and returns the mock URL a frontend or a test suite can point at, and Postman: Update Mock Server repoints it at a different collection or environment later. Postman: Publish Mock Server and Postman: Unpublish Mock Server flip its access control between public and key-required, which turns a mock into a switch a workflow can throw for the length of a demo and throw back afterwards. Postman: Get Mock Call Logs then answers who actually called it, with the path, the method, the response served, and the status code. One boundary the nodes state rather than hide: collections that belong to an API definition cannot be mocked.

Monitors as a health check that reports where the work lives

Postman: List Monitors and Postman: Get Monitor read a monitor's schedule, its regions, and its last run, including the test and request pass and fail counts, so a scheduled workflow can notice a failing contract check and open a task about it rather than waiting for someone to read an email. Postman: Run Monitor fires a run outside the schedule when you want an answer now, and Postman: Update Monitor pauses one by setting active to false instead of deleting it. Handle the run node deliberately: it sends every request in the monitored collection to its live targets and draws down your account's monitor usage allowance.

Fork, edit, and merge without touching the parent

Postman: Fork Collection copies a collection into a workspace where an automation or an agent can change it safely, because deleting a fork never affects the parent. Postman: Update Collection makes the edit in place, and Postman: Merge Collection Fork sends it back asynchronously, returning a task id that Postman: Get Merge Task Status polls until the merge reports successful or failed. That is the pattern for letting an agent work on a collection someone else owns: the review happens on the fork, before the merge, not on a collection that has already changed underneath its team.

Stand up a project's Postman footprint in one run

Postman: Create Workspace, Postman: Create Collection, and Postman: Create Environment provision a new project's workspace, its starting collection, and a per-branch or per-tenant environment in a single workflow, and Postman: Create Mock Server can hang a mock off the result so the frontend has something to call on day one. Two vendor rules the nodes surface up front: Postman returns 403 if your team's admins have restricted workspace creation or require approval for team workspaces, and public team workspace names have to be unique.

An inventory of the API estate that lives next to everything else

Postman: List Workspaces walks every workspace you can see, and Postman: Get Workspace returns that workspace's whole contents index in one call: the collections, environments, mock servers, monitors, and API specifications it holds, each with its id and unique id. A scheduled sweep can write that into a Mattering database, so questions like which collections have no monitor, or which mock servers are public, get answered from a table instead of by clicking through the app. Pace that sweep, though. Those two listers and the workspace reader sit behind a limit of 10 calls in 10 seconds, much tighter than the API's 300 requests per minute, so put a short wait between workspaces rather than sizing the run against the per-minute figure. Postman: List APIs and Postman: List API Versions add the API Builder side for teams that use it.

Rotate an environment variable from a workflow

Postman: Get Environment reads an environment's full variable set and Postman: Replace Environment writes it back, which is how a scheduled rotation puts a fresh value into a shared environment. Reading first is not politeness here, it is how the endpoint works: the values array you send replaces the whole variable list, so any variable you leave out disappears. Two honest limits come with it. Only shared variable values, the ones synced to the Postman cloud, can be changed through the API. And an environment variable can be typed as secret, and can take its value from a Postman vault rather than carrying it inline, so check what actually comes back before writing a workflow that depends on the value.

Example: A nightly contract check that files its own ticket

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a schedule fires at 06:00 before the team starts.

2

Postman: Run Monitor executes the monitored collection now and returns the run: per-request status codes and response times, plus assertion and request totals and failures.

3

A condition checks the failed-assertion count, and stops the run when it is zero.

4

Postman: Get Monitor reads the monitor's last run detail, which is also how you pick up the outcome when a long collection returned 202 and finished asynchronously.

5

The workflow opens a task in Mattering Productivity listing the failing requests and their status codes, assigned to whoever owns that service.

6

Postman: Update Monitor sets active to false when the same check has failed on several consecutive nights, so a known-broken monitor stops filling the on-call inbox until someone clears it.

Postman MCP questions, answered

What Postman operations are supported?

40 nodes: 16 query nodes and 24 action nodes. Workspaces (list, get, create, update, delete), collections (list, get, create, replace, update, delete, fork, merge a fork, and read the merge task status), environments (list, get, create, replace, delete), mock servers (list, get, create, update, delete, publish, unpublish, and call logs over a date window), monitors (list, get, create, update, delete, and run now), the authenticated user with the account's usage counters, and the API Builder's APIs and versions (list, get, create, update, delete, list versions). Deliberately not included: collection items such as folders, requests, and saved responses; comments; pull requests; collection access keys; roles; tags; Spec Hub specifications; teams, users, and groups; SCIM; audit logs; billing; analytics; the API Catalog; the Private API Network; the secret scanner; service accounts; OAuth token management; and API Builder schemas and schema files.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively.

Postman ships its own MCP server. When would you use these nodes instead?

They answer different questions. Postman offers an official MCP server, remote over streamable HTTP at mcp.postman.com and mcp.eu.postman.com in full, minimal, and code variants, with OAuth on the remote US server, plus npm, Docker, and local STDIO options. If what you want is an assistant that manages Postman, connect that: it is built for the job and Postman maintains it. These nodes are for the other case, where Postman is one step in a workflow that spans other tools. A deploy webhook creates a mock server and posts the URL into a channel, a nightly schedule runs a monitor and opens a task when assertions fail, a weekly sweep writes the API estate into a database. Those runs happen on a schedule with no assistant in the loop, next to the other systems the workflow touches. Plenty of teams will use both.

What are Postman's API rate limits?

There are two, and the second one is the one that catches people. Postman documents 300 requests per minute per user for its API, and separately a limit of 10 calls in 10 seconds on monitors and on the endpoints behind Postman: List Collections, Postman: List Workspaces, and Postman: Get Workspace. A sweep that walks a workspace list into a workspace read is exactly that pair, so pace it with a short wait between calls rather than sizing it against the per-minute figure; otherwise it returns 429 well under 300 requests per minute and the per-minute headers make it look like there was budget left. Every response carries the budget back in headers: a RateLimit header with the limit, what is remaining, and when it resets, the X-RateLimit family alongside it, and a RateLimit-Remaining-Month header for the account's monthly API call allowance. A burst 429 returns X-RateLimit-RetryAfter in seconds, and the nodes report the error on their output rather than retrying silently, so a workflow can wait that many seconds and continue. The second kind of 429 is serviceLimitExhausted, meaning the account's monthly API call allowance is spent rather than a burst being too fast, and no wait step clears that one. Before a large batch, Postman: Get Authenticated User is worth a step of its own: it returns the account's operation usage counters, including API calls, mock calls, and monitor request runs.

Do I need a particular Postman plan?

A Postman account of any kind can generate an API key and call the API, with two caveats. Team admins can turn off the setting that lets members generate keys, so that is true of the plan rather than always of the team, and every plan has a monthly Postman API call allowance published on Postman's pricing page, after which the API answers with a service limit error rather than a rate limit error; the free tier's published allowance is 10,000 calls per month. The key carries exactly the permissions of the user who created it, so what you can reach here is governed by your role on the team as much as by anything else. Object availability varies by plan too, rather than through a single API paywall. Postman's pricing page lists private workspaces and external partner workspaces as Enterprise, and Postman: Create Workspace accepts private and partner as type values, so a key on a Team plan runs straight into that. How long mock server call logs are retained is plan-dependent as well, and the API Builder is worth checking against your own account before you build on it. This page does not print plan or price claims it cannot cite.

Why do the nodes ask for a uid rather than an id?

Because that is what Postman's reference documents and the only identifier that is unambiguous across teams. Most Postman objects have both a bare id and a uid that combines the owner id with it, and while the bare id resolves on some read endpoints, the unique id is the documented form and the one every cross-object reference uses, including a monitor's collection and environment, a mock's collection and environment, and a merge's source and destination. So collections, environments, mock servers, and monitors are addressed by uid throughout, and the pickers return uids. Workspaces and API Builder APIs have no uid, so those fields ask for the id, and the field names say which is which.

Does this work with EU-hosted Postman teams?

Not yet. Postman's reference lists two hosts for the API, the default api.postman.com and a separate api.eu.postman.com for EU-hosted Enterprise teams, and this connector sends every request to the default host. A key that belongs to an EU-hosted team will fail against it. Supporting both means carrying the host per connection, which is a known gap on the roadmap rather than a decision that it does not matter.

Is it safe to let an AI agent run a monitor?

It is safe for Postman, and it is a real event for whatever the collection points at. Postman: Run Monitor destroys nothing and can be repeated, which is why it is classed as a reversible write rather than a destructive one, but the run sends every request in the monitored collection to its live targets and draws down the account's monitor usage allowance. So the rule is about the collection, not the node: never point it at a collection that writes to production, and give an agent monitors that exercise read-only or staging endpoints. For long collections, set run_async to true; a synchronous run over 300 seconds returns 202 and you read the outcome from Postman: Get Monitor.

Which nodes are flagged destructive, and what do they take with them?

Seven. The six deletes cover workspaces, collections, environments, mock servers, monitors, and API definitions, and the API has no undelete for any of them. What differs is what the Postman app can still do afterwards: a deleted collection goes to the trash there and can be restored for a period that depends on your plan, while a deleted workspace is not recoverable at all, which makes the workspace delete the heaviest node in the set. It also takes the workspace's collections, environments, mock servers, and monitors with it. Postman's own guidance is to review a collection's monitors and mock servers before deleting it, and Postman surfaces a deactivated flag on mock servers and monitors, so a workflow can read that state rather than assume it. Deleting a mock server removes the mock, so anything pointed at its URL needs repointing. Postman: Delete API returns 204 No Content on success. The seventh is Postman: Merge Collection Fork, which deletes nothing by default but permanently applies one collection's contents onto another with no revert endpoint, and additionally deletes the fork when the deleteSource strategy is used. The pattern for all seven is the same: read or export the object first, and put the call behind a condition, an approval task, or a manual run rather than a bare trigger. To stop a monitor without deleting it, use Postman: Update Monitor with active set to false.

40 nodes waiting on the canvas

Put Postman to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Postman is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products