Postman connector

Lists services that Postman has detected but that are not necessarily in the API Catalog yet. Use this to find candidates to onboard, or to check whether a service has already been integrated. Filter with \`discoverySource\` (\`api_gateway_app\`, \`insights_project\`, \`infra_watcher\`, \`public_api\`), \`status\` (\`discovered\`, \`integrated\`, \`archived\`), and \`search\` on the name; page with \`limit\` (max 100) and \`cursor\`. Do not use this tool for services already in the catalog — those have analytics and governance data and are read with getApiCatalogServices. Requires a Postman Enterprise plan.

Gets one catalogued service's health, traffic, compliance, ownership, and dependencies in a given system environment. Both the service ID and the required \`systemEnvironmentId\` are needed; get them from getApiCatalogServices and getApiCatalogSystemEnvironments. The same service reports different data per environment, so the environment is part of the question, not an optional filter. Do not use this tool for per-endpoint metrics; use getApiCatalogServiceEndpoints instead. Requires a Postman Enterprise plan.

Lists CI collection runs for a service, with summary statistics, pipeline details, and Git metadata. Use this to tie test results back to a branch, workflow, or commit author. \`systemEnvironmentId\` is required. Filter with \`collectionId\`, \`environmentId\`, \`status\`, \`branch\`, \`workflowName\`, \`actor\`, \`repoName\`, and \`repoOwner\`; order with \`sort\` in \`field:direction\` form over \`timestamp\` or \`duration\`. Do not use this tool for scheduled monitor runs; use getApiCatalogServiceMonitorRuns instead. Requires a Postman Enterprise plan.

Lists the endpoints Postman has observed for a service, with per-endpoint traffic and performance metrics. Use this to find a service's slowest or most error-prone endpoints. \`systemEnvironmentId\` is required. Filter with \`httpMethods\`, \`hosts\`, \`responseCodes\`, and \`search\` on the path; order with \`sort\` in \`field:direction\` form over \`count\`, \`endpoint\`, \`p95LatencyMs\`, or \`errorRate\`. These are observed endpoints, not a specification — do not use this tool to read a service's OpenAPI definition. Requires a Postman Enterprise plan.

Lists scheduled monitor runs for a service, with summary statistics per run. Use this to check whether a service's monitors are passing and when they last ran. \`systemEnvironmentId\` is required. Filter with \`collectionId\`, \`environmentId\`, and \`status\`; order with \`sort\` in \`field:direction\` form over \`timestamp\`, \`duration\`, or \`failedAssertions\`. Do not use this tool for CI-triggered runs; those are separate and read with getApiCatalogServiceCiRuns. Requires a Postman Enterprise plan.

Lists specification lint runs for a service, with per-severity issue counts. Use this to see whether a service's specifications pass governance rules and which severities are failing. Unlike the other service reads, this one takes no \`systemEnvironmentId\`; scope it with \`specId\` instead. \`severity\` is a threshold — higher severities are always included. Order with \`sort\` in \`field:direction\` form over \`timestamp\` or \`errorCount\`. Do not use this tool to lint a specification on demand; it only reports runs that have already happened. Requires a Postman Enterprise plan.

Lists the services catalogued in one system environment, with their analytics, compliance, and governance metadata. \`systemEnvironmentId\` is required — call getApiCatalogSystemEnvironments first to get one, and repeat this call per environment when you need a cross-environment view. Narrow with \`name\`, \`tags\`, and \`governanceGroupId\`; page with \`limit\` (max 100) and \`cursor\`. Do not use this tool to find services that are not catalogued yet; use getApiCatalogDiscoveryServices instead. Requires a Postman Enterprise plan.

Gets one system environment by ID. Use getApiCatalogSystemEnvironments when you need to discover the ID. Do not use this tool to list the services in that environment; use getApiCatalogServices with this environment's ID instead. Requires a Postman Enterprise plan.

Lists the workspace environments attached to a system environment. Use this to see which Postman environments feed a deployment stage before adding or removing any. Narrow to one workspace with \`workspaceId\`; page with \`limit\` (max 100) and \`cursor\`. Requires a Postman Enterprise plan.

Lists the team's system environments — the deployment stages (for example staging, production) that every service-scoped API Catalog read is keyed by. Call this first whenever you need a \`systemEnvironmentId\` for getApiCatalogServices, getApiCatalogService, getApiCatalogServiceEndpoints, getApiCatalogServiceMonitorRuns, or getApiCatalogServiceCiRuns. Pass \`isProduction=true\` to return only production environments; page with \`limit\` (max 100) and \`cursor\`. These are not Postman environments holding variables — do not confuse them with getEnvironments. Requires a Postman Enterprise plan.

Returns instructions (markdown) for finding APIs in Postman — searching the public network, browsing private/internal/team collections, filtering by ownership and visibility, and comparing candidate APIs. Includes the rules for presenting results with Postman links and the patterns for evaluating tradeoffs between APIs. Call this when the user wants to find, search for, or compare APIs (e.g., "find me an email API", "search for the Payvance API", "compare Payvance and Cashloom"). Prerequisite: call getPostmanContextOverview first if you have not already loaded the Postman Context overview in this session.

Lists every audit log event action Postman can record. This is the vocabulary the \`action\` filter on getAuditLogs expects, so call it first when you need to narrow an audit query to one kind of event. This returns the set of possible actions, not any events that happened. Requires a Postman Enterprise plan.

Gets the team's audit events — who did what and when across the Postman team. Use this to answer questions about account changes, membership changes, and administrative activity. Narrow with \`userId\`, \`action\`, and a \`since\`/\`until\` window in \`YYYY-MM-DD\` format; page with \`limit\` and \`cursor\`, and order with \`orderBy\` (\`asc\` or \`desc\`). Get valid \`action\` values from getAuditLogEventActions rather than guessing them — an invalid action silently returns nothing useful. Prefer \`orderBy\` over the deprecated \`order_by\` parameter. Requires a Postman Enterprise plan.

Gets information about the authenticated user. - This endpoint provides “current user” context (\`user.id\`, \`username\`, \`teamId\`, roles). - When a user asks for “my …” (e.g., “my workspaces, my information, etc.”), call this first to resolve the user ID.

Returns the full workflow instructions for discovering APIs, exploring collections, and generating client code from Postman. Includes step-by-step guidance, tool usage patterns, and code generation rules. MANDATORY: You MUST call this tool when the user says to "use postman", or when the user wants to do something that requires locating a specific API for the purpose of answering questions, planning a build, and in most cases proceeding to generate code that calls the API. ALWAYS call getCodeGenerationInstructions BEFORE calling other tools in this workflow. This tool returns comprehensive step-by-step instructions on how to search for APIs, gather API-specific context from other tools, and then generate client code based on the context retrieved.

Get information about a collection. By default this tool returns the lightweight collection map (metadata + recursive itemRefs). Use the model parameter to opt in to Postman's full API responses: - model=minimal — root-level folder/request IDs only - model=full — full Postman collection payload.

Returns a markdown-formatted summary of a collection, including its metadata, authentication, variables, and a tree of folders and requests. Use this to understand the structure and contents of a collection.

Gets a collection's forked collections. The response returns data for each fork, such as the fork's ID, the user who forked it, and the fork's creation date.

Lists the pull requests opened against a collection. Returns each pull request's ID, title, status, and the source and destination collection details. Use this to discover open pull requests on a collection before reviewing or merging one.

The workspace ID query is required for this endpoint. If not provided, the LLM should ask the user to provide it.

Gets a single component's metadata by ID. Use \`include\` (\`hasVersions\`, \`latestVersion\`, \`latestVersion.content\`) or \`expand\` (\`latestVersion\`) when you also need the most recently published version. Use getAllComponents first when you need to discover a component ID. Do not use this tool to read unpublished edits; use getComponentDraft instead. Requires a Postman Enterprise plan.

Gets a component's working draft — its latest unpublished content and format. The draft is where edits live before they are published, so it may differ from the most recently published version. Use this to read pending changes before publishing. Do not use this tool to read published content; use getComponentVersion instead. Requires a Postman Enterprise plan.

Gets a single published version of a component by version ID. Pass \`include=content\` to return the published content itself. Use getComponentVersions first when you need to discover a version ID. Do not use this tool to read the working draft; use getComponentDraft instead. Requires a Postman Enterprise plan.

Lists a component's published versions. Use this to discover version IDs and labels, or to check whether pending draft edits have been published yet. Pass \`include=content\` when you also need each version's content. Do not use this tool to read unpublished edits; use getComponentDraft instead. Requires a Postman Enterprise plan.

Gets a submitted Context Graph ask's status and, once it finishes, its result. Call this after submitContextGraphAsk with the \`askId\` it returned, and poll while \`status\` is \`pending\` or \`running\` — leave a few seconds between polls rather than calling in a tight loop. \`result\` is only present once \`status\` is \`completed\`; a \`failed\` ask carries a short \`error\` instead. When reporting a completed ask, treat \`result.answer\` as the prose summary and \`result.structured\`, \`result.citations\`, and \`result.provenance\` as the graph data it rests on — cite that evidence rather than presenting the answer on its own, and say so when \`result.provenance.truncated\` is \`true\`, since the ask hit its deadline and the answer is partial.

Lists where one detected secret appears — the workspaces and resources holding it. Use this after detectedSecretsQueries to turn a secret ID into the concrete places a person has to go and fix. Requires a \`workspaceId\`, and can be narrowed further with \`resourceType\` and a \`since\`/\`until\` window. Do not use this tool to search for secrets across the team; use detectedSecretsQueries instead. Requires a Postman Enterprise plan.

IMPORTANT: Run this tool first when a requested tool is unavailable. Returns information about which tools are enabled in the full and minimal tool sets, helping you identify available alternatives.

Gets information about all of your [environments](https://learning.postman.com/docs/sending-requests/managing-environments/).

Gets one Postman user group by ID. Use this when you already hold a group ID — from a collection or workspace role assignment — and need that group's details; use getGroups when you need to list or search. This is a Postman user group, not a SCIM group and not a team.

Lists the team's Postman user groups — named sets of team members used to grant access collectively. Use this to resolve the group IDs that appear in collection and workspace role responses, or to get a \`groupId\` for the filter on getTeamUsers. These are Postman user groups, not SCIM groups and not teams. Use getTeamUsers for individual members.

Returns instructions (markdown) for maintaining the API requests already installed in the user's project — listing installed requests, checking installed requests against their Postman sources for upstream changes, finding unused requests, and safely removing installed requests. Installed requests are identifiable by a "Generated by Postman Code" comment in the file header. Call this when the user wants to manage existing integrations (e.g., "what requests do we have installed?", "are my API integrations up to date?", "find unused Postman requests", "remove the Payvance requests"). Prerequisite: call getPostmanContextOverview first if you have not already loaded the Postman Context overview in this session.

Gets information about a mock server. - Resource: Mock server entity. Response includes the associated \`collection\` UID and \`mockUrl\`. - Use the \`collection\` UID to navigate back to the source collection.

Gets the full details of a specific server response, including its \`body\`, \`headers\`, and \`language\`. - Use \`getMockServerResponses\` first to list available server response IDs. - To check which response is active, call \`getMock\` and read \`config.serverResponseId\`.

Gets all server responses configured for a mock server. - Server responses simulate 5xx server-level failures (e.g. 500, 503) independently of any specific route or example. - This endpoint returns summary metadata only (id, name, statusCode, timestamps). To get the full body and headers of a specific response, call \`getMockServerResponse\` with the response's \`id\`. - To see which server response is currently active, call \`getMock\` and check \`config.serverResponseId\`.

Gets all active mock servers. By default, returns only mock servers you created across all workspaces. - Always pass either the \`workspace\` or \`teamId\` query to scope results. Prefer \`workspace\` when known. - If you need team-scoped results, set \`teamId\` from the current user: call GET \`/me\` and use \`me.teamId\`. - If both \`teamId\` and \`workspace\` are passed, only \`workspace\` is used.

Gets results for a monitor run, including trimmed execution logs (beforeItem and assertion events only) and result counts. Use this to inspect per-request assertions and failure details for a specific run. This is Step 3 of the monitor-run workflow: listMonitorExecutions → listRunsForExecution → getMonitorRunResults. The runId must come from listRunsForExecution — do NOT use an executionId here, it will return 404.

Gets an active package's metadata and current index script content by package ID. Use getPackages first when you need to discover a package ID. Do not use this tool to list packages or discover package IDs; use getPackages instead.

Lists active packages available to the authenticated user. Returns package metadata but does not include index script content. Use getPackage with a returned package ID when you also need the current script. Use the response cursor to fetch the next page when more packages are available. Do not use this tool to retrieve a package's script content; use getPackage instead.

Returns the Postman Context overview (markdown). Explains the core concepts (workspaces, collections, requests, installed code) and the end-to-end workflow for finding APIs, generating client code, and maintaining installed requests over time. Call this FIRST — and only — when the user wants to explore APIs in Postman's network, answer questions about how an API works, plan an integration, or generate client code grounded in real Postman API definitions, AND you have not already loaded the overview in this session. Do NOT call this for routine Postman operations like listing or editing workspaces, collections, environments, mocks, monitors, or specs — go straight to the relevant resource tool. After reading the overview, route to the appropriate topic-specific instructions tool: getApiDiscoveryInstructions (find/search/compare APIs), getCodeGenerationInstructions (generate client code from a request), or getInstalledApiMaintenanceInstructions (list, update, or remove installed requests).

Gets a single pull request by its ID, including source and destination details, reviewers, and the current merge/review status. Use this to inspect a specific pull request returned by getCollectionPullRequests.

Returns comprehensive markdown-formatted context for generating code from a request. Includes the full request definition (method, URL, headers, query params, body, auth), all response examples with full details, and merged collection and environment variables with source tags.

Gets one SDK, including the \`buildStatus\` of its generation job. This is the tool to poll after createSdk: \`succeeded\` means the archive is ready for getSdkDownloadUrl, and a failure status is reported here rather than by the original call. Requires a Postman Team or Enterprise plan.

Gets a short-lived signed URL for a generated SDK's zip archive. The response carries a URL, not the archive — the API deliberately does not stream file contents — and the URL expires within a few minutes, so fetch it at the moment you intend to download and do not store or pass it around. Only works once the SDK's \`buildStatus\` is \`succeeded\`; check with getSdk first, since asking too early returns 409. Requires a Postman Team or Enterprise plan.

Gets one SDK Git connection, including which SDK was last delivered to its target branch and the most recent SDK-update pull request. Use this to check whether a connection is healthy and current. Requires a Postman Team or Enterprise plan.

Lists the SDK-update pull requests opened through one Git connection. Use this to report on what has been delivered to a repository and what is still waiting to be merged. The record survives disconnection, so a disconnected connection still returns its history. These are pull requests in the connected Git repository, not Postman collection pull requests — use getCollectionPullRequests for those. Requires a Postman Team or Enterprise plan.

Lists the Git repository connections in a workspace. Each connection ties one collection or specification, in one SDK language, to one target repository, so a source with several languages has several connections. \`workspaceId\` is required. Filter with \`sourceId\`, \`language\`, \`status\`, and \`repositoryUrl\`. Requires a Postman Team or Enterprise plan.

Lists the SDKs the caller can see in a workspace, with each one's build status. \`workspaceId\` is required. Filter with \`buildStatus\`, \`language\`, and \`sourceId\`, or pass \`sdkIds\` (up to 100, comma-separated) to check several known SDKs at once — note that \`sdkIds\` overrides every other filter. Page with \`limit\` and \`cursor\`. Use \`sdkIds\` here rather than calling getSdk in a loop when you are polling more than one generation job. Requires a Postman Team or Enterprise plan.

Lists the kinds of secret the Secret Scanner recognises, with the type IDs used to filter detectedSecretsQueries. Call this first when you need to search for one specific kind of credential, since the \`secretTypes\` filter takes these IDs and not names. This returns the scanner's vocabulary, not any detected secrets. Requires a Postman Enterprise plan.

Checks whether there is a change between the forked collection and its parent (source) collection. If the value of the \`isSourceAhead\` property is \`true\` in the response, then there is a difference between the forked collection and its source collection. **Note:** This endpoint may take a few minutes to return an updated \`isSourceAhead\` status.

**Requires an Enterprise plan.** Tagging is only available on Postman Enterprise plans. This tool returns a 404 error on Free, Basic, and Professional accounts. Gets Postman elements (entities) by a given tag. Tags enable you to organize and search workspaces, APIs, and collections that contain shared tags.

Gets one Postman team by ID. Pass \`include=members\` to list everyone with access — managers, members, guests, and groups representing other teams — or \`include=userRoles\` for the team's role assignments. Use getTeams when you need to discover the ID. Member entries carry IDs rather than names; resolve them with getTeamUsers and getGroups.

Lists a team's pending access requests — people asking to join, to be promoted, or to add members. Use this to report on what is waiting for a decision, and to get the request IDs that approveDenyAccessRequest needs. Reading requests is safe; acting on them is not. Do not chain straight into approveDenyAccessRequest without an explicit decision from an operator.

Gets a team's settings. Use this to report on a team's current configuration, and to read the existing values before changing any of them with updateTeamSettings.

Gets one member of the Postman team by user ID. Use this when you already hold a user ID — from an audit log entry or a role assignment — and need that single person's details; use getTeamUsers when you need to search or list. This returns another person on the team. To find out who the current API key belongs to, use getAuthenticatedUser instead.

Lists the members of the authenticated user's Postman team. Use this to resolve the numeric user IDs that appear in audit logs, collection roles, and workspace roles into names an operator can act on. Narrow to one user group with the \`groupId\` query parameter, using an ID from getGroups. This returns other people on the team. To find out who the current API key belongs to, use getAuthenticatedUser instead.

Lists the Postman teams in the organization. Use this to discover team IDs before reading a team's settings, members, or access requests. Page with \`limit\` and \`cursor\`, and pass \`teamSettings\` or \`userRoles\` to include those in the response. This lists teams in the organization, not the members of a team — use getTeamUsers for people and getGroups for user groups.

Gets information about a workspace. **Note:** This endpoint's response contains the \`visibility\` field. [Visibility](https://learning.postman.com/docs/collaborating-in-postman/using-workspaces/managing-workspaces/#changing-workspace-visibility) determines who can access the workspace: - \`personal\` — Only you can access the workspace. - \`team\` — All team members can access the workspace. - \`private\` — Only invited team members can access the workspace ([**Team** and **Enterprise** plans only](https://www.postman.com/pricing)). - \`public\` — Everyone can access the workspace. - \`partner\` — Only invited team members and [partners](https://learning.postman.com/docs/collaborating-in-postman/using-workspaces/partner-workspaces/) can access the workspace ([**Team** and **Enterprise** plans only](https://www.postman.com/pricing)).

Gets a workspace's activity feed — who added or removed collections, environments, and other elements, and who joined or left. Use this to explain how a workspace reached its current state, or to build a changelog. Narrow with \`userId\` and \`elementType\`, and page with \`limit\` and \`cursor\`. This is workspace-level history. For a single collection's change history use the collection's own tools, and for team-wide administrative events use getAuditLogs.

Returns a markdown-formatted summary of a single workspace, including its collections and environments. Use this to understand what resources are available in a workspace before exploring specific collections or environments.

Returns a markdown-formatted summary of all environments in a workspace, including their variables. Use this to understand the environment configuration available in a workspace.

Gets a workspace's global [variables](https://learning.postman.com/docs/sending-requests/variables/#variable-scopes). Global variables enable you to access data between collections, requests, scripts, and environments and are available throughout a workspace.

Gets who has access to a workspace and at what level, covering users, user groups, and partners. Use this to audit access, and to read the current state before changing it. Pass \`include=scim\` to get SCIM IDs alongside Postman IDs. Partner roles do not support SCIM IDs. Resolve the IDs in the response with getTeamUsers and getGroups. For a single collection's access list use getCollectionRoles instead.

Lists a workspace's updates — the announcement posts that keep workspace watchers informed about new features, bug fixes, breaking changes, and other news. Filter by \`category\` and page with \`cursor\`. These are authored announcements, not a record of what changed in the workspace. For that use getWorkspaceActivityFeed, and for the workspace's own settings use getWorkspace.

Gets all workspaces you have access to. - For “my …” requests, first call GET \`/me\` and pass \`createdBy={me.user.id}\`. - This endpoint's response contains the visibility field. Visibility determines who can access the workspace: - \`personal\` — Only you can access the workspace. - \`team\` — All team members can access the workspace. - \`private\` — Only invited team members can access the workspace (Professional and Enterprise). - \`public\` — Everyone can access the workspace. - \`partner\` — Invited team members and partners (Professional and Enterprise). - For tools that require the workspace ID, and no workspace ID is provided, ask the user to provide the workspace ID. If the user does not provide the workspace ID, call this first with the createdBy parameter to use the first workspace. - Results are paginated. Use the \`cursor\` parameter to retrieve additional pages. - Examples: - “List my workspaces” → GET \`/me\`, then GET \`/workspaces?createdBy={me.user.id}&limit=100\` - “List my personal workspaces” → GET \`/me\`, then GET \`/workspaces?type=personal&createdBy={me.user.id}&limit=100\` - “List all public workspaces” → GET \`/workspaces?type=public&limit=100\`

Returns a markdown-formatted summary of all workspaces accessible to the user. Use this to discover available workspaces and their collections before diving into specific resources. Supports pagination and filtering by name.

Lists executions for a monitor. Cursor-based pagination, 25 results per page. Returns execution metadata including state, trigger, results summary, and timestamps. This is Step 1 of the monitor-run workflow: listMonitorExecutions → listRunsForExecution → getMonitorRunResults. Each execution has an `id` (executionId). To get run results, you must first pass this executionId to listRunsForExecution to obtain run IDs — do NOT use executionId as a runId.

Gets all requests to add workspaces to your team's Private API Network. WARNING: This tool is for Private API Network management, not for general workspace operations. For workspace management use: getWorkspaces, getWorkspace, createWorkspace, updateWorkspace, deleteWorkspace.

Gets information about workspaces added to your team's Private API Network. WARNING: This tool is for Private API Network management, not for general workspace operations. For workspace management use: getWorkspaces, getWorkspace, createWorkspace, updateWorkspace, deleteWorkspace.

Lists runs for a monitor execution. Each execution may produce multiple runs across regions. Returns run metadata including region, state, result counts, and timestamps. Not paginated. This is Step 2 of the monitor-run workflow: listMonitorExecutions → listRunsForExecution → getMonitorRunResults. Pass the executionId from listMonitorExecutions. Returns run objects whose `id` is the runId needed by getMonitorRunResults.

Search the official Postman documentation and learning resources at https://learning.postman.com. Use this tool when you need authoritative, up-to-date guidance on how to use Postman features — for example creating mock servers, writing tests, using environments, configuring monitors, or any "how do I…" question about the Postman product. Returns relevant documentation passages with their source URLs. Do not use this tool to search a user's own Postman resources (collections, workspaces, specs) — use `searchPostmanElements` for that.

Search for Postman entities (requests, collections, workspaces, specs, flows, environments, mocks, and documents). **Ownership:** - `organization` — Search within all resources owned by your organization (default). - `external` — Search within the public Postman network (third-party and community APIs). - `all` — Search across all scopes. **When to use each ownership value and filters:** | Goal | Recommended approach | |------|----------------------| | Find an internal API (e.g. "our notification service") | `ownership: organization` | | Find a trusted API published to the Private Network | `ownership: organization` + `privateNetwork: true` filter | | Find an internal API in all resources of organization and are visible to the organization only | `ownership: organization` + `visibility: internal` filter | | Find an API by your organization that is made publicly visible | `ownership: organization` + `visibility: public` filter | | Find a third party publicly visible API (e.g. "Stripe API", "Twilio API") | `ownership: external` + `visibility: public` filter | | User says "our APIs", "internal", "team" | `ownership: organization` | | Search across all scopes | `ownership: all` | **Element Types:** - `requests`: Search for individual API requests. - `collections`: Search for API collections. - `workspaces`: Search for Postman workspaces. - `specs`: Search for API specifications. - `flows`: Search for Postman Flows. - `environments`: Search for Postman Environments. - `mocks`: Search for Postman Mock Servers. - `documents`: Search for Postman workspace documents. **Filters:** Use the `filters` parameter to narrow results. The top-level key must be `$and` with an array of condition objects. Each condition object must contain exactly one field key. Supported filter fields: | Field | Operators | Notes | |-------|-----------|-------| | `workspaceId` | `$eq`, `$ne`, `$in`, `$nin` | All element types. `$in`/`$nin` accept arrays. | | `collectionId` | `$eq`, `$ne`, `$in`, `$nin` | Requests and collections only. | | `visibility` | `$eq`, `$ne` | Values: `public`, `partner`, `internal`. All element types. | | `privateNetwork` | `$eq`, `$ne` | Boolean. All element types. | | `publisherIsVerified` | `$eq`, `$ne` | Boolean. All element types. | | `method` | `$eq`, `$ne`, `$in`, `$nin` | HTTP methods (GET, POST, etc.). Requests only. | | `tags` | `$eq`, `$ne`, `$in`, `$nin` | Workspaces and collections only. | | `requestId` | `$eq`, `$ne`, `$in`, `$nin` | Requests only. | | `specificationId` | `$eq`, `$ne`, `$in`, `$nin` | Specs only. | | `flowId` | `$eq`, `$ne`, `$in`, `$nin` | Flows only. | | `documentId` | `$eq`, `$ne`, `$in`, `$nin` | Documents only. | | `createdBy` | `$eq`, `$ne`, `$in`, `$nin` | All element types. | | `organizationId` | `$eq`, `$ne`, `$in`, `$nin` | All element types. | | `teamId` | `$eq`, `$ne`, `$in`, `$nin` | All element types. | | `isGitConnected` | `$eq`, `$ne` | Boolean. Workspaces, collections, requests, specs, flows, environments, mocks, documents. | | `type` | `$eq`, `$ne`, `$in`, `$nin` | Requests only. | **Filter examples:** - Private API Network only: `{"$and":[{"privateNetwork":{"$eq":true}}]}` - Single workspace: `{"$and":[{"workspaceId":{"$eq":"ws-abc123"}}]}` - Multiple workspaces: `{"$and":[{"workspaceId":{"$in":["ws-1","ws-2"]}}]}` - Public visibility: `{"$and":[{"visibility":{"$eq":"public"}}]}` - GET requests only: `{"$and":[{"method":{"$eq":"GET"}}]}` - Combine conditions: `{"$and":[{"visibility":{"$eq":"public"}},{"workspaceId":{"$eq":"ws-abc123"}}]}` - Environments in a workspace: `{"$and":[{"workspaceId":{"$eq":"ws-abc123"}}]}`

Creates a comment on a collection. To create a reply on an existing comment, include the \`threadId\` property in the request body. **Note:** This endpoint accepts a max of 10,000 characters.

Creates a folder in a collection. For a complete list of properties, refer to the **Folder** entry in the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). You can use this endpoint to to import requests and responses into a newly-created folder. To do this, include the \`requests\` field and the list of request objects in the request body. For more information, see the provided example. **Note:** It is recommended that you pass the \`name\` property in the request body. If you do not, the system uses a null value. As a result, this creates a folder with a blank name.

Creates a [fork](https://learning.postman.com/docs/collaborating-in-postman/version-control/#creating-a-fork) from an existing collection into a workspace.

Creates a pull request to merge changes from a forked collection into its parent (destination) collection. Provide the title, description, source and destination collection IDs, and reviewer IDs. Use this after forking a collection (createCollectionFork) to propose the fork's changes for review rather than hard-merging them directly.

Creates a request in a collection. For a complete list of properties, refer to the **Request** entry in the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). **Note:** It is recommended that you pass the \`name\` property in the request body. If you do not, the system uses a null value. As a result, this creates a request with a blank name.

Creates a request response in a collection. For a complete list of request body properties, refer to the **Response** entry in the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). **Note:** It is recommended that you pass the \`name\` property in the request body. If you do not, the system uses a null value. As a result, this creates a response with a blank name.

Creates a component in the team's component library and seeds its first draft with the content you provide. Use this when a team wants a reusable schema, parameter, response, or security scheme that specifications can reference instead of redefining. The component starts active and unpublished: the content lands in its draft only. Call createComponentVersion afterwards to publish it and make it referenceable. Do not use this tool to edit an existing component's content; use updateComponentDraft instead. Requires a Postman Enterprise plan.

Publishes the component's current draft as a new immutable version under the \`label\` you supply, making it referenceable by the team's specifications. Labels must be unique per component. Publishing cannot be undone and the resulting version cannot be edited — publish another version to supersede it. Archived components cannot be published; restore them with updateComponent first. Do not use this tool to save work in progress; use updateComponentDraft instead. Requires a Postman Enterprise plan.

Creates an environment. **Note:** - The request body size cannot exceed the maximum allowed size of 30MB. - If you receive an HTTP \`411 Length Required\` error response, manually pass the \`Content-Length\` header and its value in the request header. - If you do not include the \`workspace\` query parameter, the system creates the environment in the oldest personal Internal workspace you own. - Only [shared variable](https://learning.postman.com/docs/use/send-requests/variables/variables/#share-variable-values) values can be modified through the Postman API. A shared variable is an environment variable with its value synced and stored in the Postman cloud, and can be accessed by your teammates in the environment's workspace.

Creates a comment on a folder. To create a reply on an existing comment, include the \`threadId\` property in the request body. **Note:** This endpoint accepts a max of 10,000 characters.

Creates a mock server in a collection. - Pass the collection UID (ownerId-collectionId), not the bare collection ID. - If you only have a \`collectionId\`, resolve the UID first: 1) Prefer GET \`/collections/{collectionId}\` and read \`uid\`, or 2) Construct \`{ownerId}-{collectionId}\` using ownerId from GET \`/me\`: - For team-owned collections: \`ownerId = me.teamId\` - For personal collections: \`ownerId = me.user.id\` - Use the \`workspace\` query to place the mock in a specific workspace. Prefer explicit workspace scoping.

Creates a server response on a mock server. Server responses simulate 5xx server-level failures (e.g. 500, 503) that are agnostic to any specific route — when active, every request to the mock returns this response. - \`statusCode\` must be a 5xx value (500–599). - \`body\` is a raw string — pass the response body exactly as the mock should return it (e.g. a JSON string like \`"{\"message\":\"error\"}"\` or plain text). - \`language\` controls syntax highlighting in the Postman UI (\`json\`, \`xml\`, \`html\`, \`javascript\`, \`text\`). It does not affect the actual response Content-Type — set that via \`headers\` instead. - \`headers\` is an array of \`{key, value}\` pairs for response headers (e.g. \`[{"key": "Content-Type", "value": "application/json"}]\`). - You can create multiple server responses per mock, but only one can be active at a time. Creating a response does NOT automatically activate it — call \`updateMock\` with \`config.serverResponseId\` set to the new response's \`id\` to activate it.

Creates a monitor. **Note:** - You cannot create monitors for collections added to an API definition. - If you do not pass the \`workspace\` query parameter, the system creates the monitor in the oldest personal Internal workspace you own.

Creates a Postman Package Library package and its initial index script. Use this when you want to add reusable JavaScript functions, tests, or utilities for a team to import into Postman scripts. A workspace ID is required to identify the workspace where the package is created. Do not use this tool to modify an existing package; use updatePackage instead.

The request ID must contain the team ID as a prefix, in \`teamId-requestId\` format. For example, if you're creating a comment on collection ID \`24585957-[example ID]\` (note on the prefix), and the collection request's ID is \`[example ID]\`, then the \`{requestId}\` must be \`24585957-[example ID]\`.

Creates a comment on a response. To create a reply on an existing comment, include the \`threadId\` property in the request body. **Note:** This endpoint accepts a max of 10,000 characters.

Starts an SDK generation job for one language from a collection or a specification. Returns 202 with a job record — the SDK does not exist yet. Poll getSdk and wait for \`buildStatus\` to reach \`succeeded\` before trying to download it. The request body depends on the \`language\` you pick, so send only the properties that language accepts. One call generates one language; call it once per language rather than expecting a bundle. Requires a Postman Team or Enterprise plan.

Connects a collection or specification to a Git repository for one SDK language, so generated SDK updates can be delivered there as pull requests. The connection starts \`active\`. Each source and language pair supports exactly one connection — creating a second returns 409, and the way to change an existing one is updateSdkGitConnection, not a repeat call here. \`autoUpdatePullRequestsEnabled\` is Enterprise-only and is forced to false on Team plans. Requires a Postman Team or Enterprise plan.

Creates an API specification in Postman's [Spec Hub](https://learning.postman.com/docs/design-apis/specifications/overview/). Specifications can be single or multi-file. **Note:** - Postman supports OpenAPI (2.0, 3.0, and 3.1), AsyncAPI (2.0 and 3.0), protobuf (2 and 3), GraphQL, and Smithy specifications. - If the file path contains a \`/\` (forward slash) character, then a folder is created. For example, if the path is the \`components/schemas.json\` value, then a \`components\` folder is created with the \`schemas.json\` file inside. - Multi-file specifications can only have one root file. - Files cannot exceed a maximum of 12 MB in size.

Creates a file for an OpenAPI or a protobuf 2 or 3 specification. **Note:** - If the file path contains a \`/\` (forward slash) character, then a folder is created. For example, if the path is the \`components/schemas.json\` value, then a \`components\` folder is created with the \`schemas.json\` file inside. - Creating a spec file assigns it the \`DEFAULT\` file type. - Multi-file specifications can only have one root file. - Files cannot exceed a maximum of 10 MB in size.

Creates a new Postman team in the organization. \`name\` accepts only alphanumeric characters and spaces. This creates a billable organizational unit and is not something to do speculatively — only call it on an explicit, specific instruction to create a team, never to satisfy a vaguer request such as organizing or setting up a workspace. Use createWorkspace for that instead.

Creates a new [workspace](https://learning.postman.com/docs/collaborating-in-postman/using-workspaces/creating-workspaces/). **Note:** - This endpoint returns a 403 \`Forbidden\` response if the user does not have permission to create workspaces. [Admins and Super Admins](https://learning.postman.com/docs/collaborating-in-postman/roles-and-permissions/#team-roles) can configure workspace permissions to restrict users and/or user groups from creating workspaces or require approvals for the creation of team workspaces. - Private and [Partner Workspaces](https://learning.postman.com/docs/collaborating-in-postman/using-workspaces/partner-workspaces/) are available on Postman [**Team** and **Enterprise** plans](https://www.postman.com/pricing). - There are rate limits when publishing public workspaces. - Public team workspace names must be unique. - The \`teamId\` property must be passed in the request body if [Postman Organizations](https://learning.postman.com/docs/administration/onboarding-checklist) is enabled.

Publishes an update in a workspace, notifying everyone watching it. Use this to announce a breaking change, a release, or a deprecation to the workspace's consumers. This notifies real people, so only post when explicitly asked to announce something, and post the message you were given rather than a summary you composed. It does not change the workspace itself — use updateWorkspace for settings.

Deletes a comment from an API's collection. On success, this returns an HTTP \`204 No Content\` response. **Note:** Deleting the first comment of a thread deletes all the comments in the thread.

Deletes a comment from a collection. On success, this returns an HTTP \`204 No Content\` response. **Note:** Deleting the first comment of a thread deletes all the comments in the thread.

Deletes a comment from a folder. On success, this returns an HTTP \`204 No Content\` response. **Note:** Deleting the first comment of a thread deletes all the comments in the thread.

Deletes a mock server. - Resource: Mock server entity. This is destructive. - Ensure you are targeting the correct mock ID.

Deletes a server response from a mock server. - If this server response is currently active (\`config.serverResponseId\` on the mock), deleting it will not automatically deactivate it. Call \`updateMock\` with \`config.serverResponseId: null\` first to deactivate. - This action is destructive and cannot be undone.

Deletes a package and its associated index script content. This operation returns no content and also succeeds when the package no longer exists. Do not use this tool to clear or replace script content while retaining the package; use updatePackage instead.

Deletes a comment from a request. On success, this returns an HTTP \`204 No Content\` response. **Note:** Deleting the first comment of a thread deletes all the comments in the thread.

Deletes a comment from a response. On success, this returns an HTTP \`204 No Content\` response. **Note:** Deleting the first comment of a thread deletes all the comments in the thread.

Deletes an SDK record and the stored archive behind it. Returns 204 with no body on success. Anyone still holding a download URL loses access to the artifact. This cannot cancel a generation job that is still running — a job in progress has to finish first. Only call this on an explicit instruction naming the SDK. Requires a Postman Team or Enterprise plan.

Deletes an API specification. On success, this returns an HTTP \`204 No Content\` response.

Deletes a file in an API specification. On success, this returns an HTTP \`204 No Content\` response.

Deletes a workspace update. This removes an announcement watchers may already have seen and cannot be undone. Prefer patchWorkspaceUpdate to correct a mistake — deleting leaves consumers with no record of a change they were told about. Only delete on an explicit instruction.

Searches the secrets Postman's Secret Scanner has detected across the team. Despite being a POST this only reads — the body carries the query, and an empty body returns everything. Filter with \`secretTypes\` (IDs from getSecretTypes), \`statuses\` (\`ACTIVE\`, \`FALSE_POSITIVE\`, \`REVOKED\`, \`ACCEPTED_RISK\`), \`resolved\`, \`workspaceVisibilities\`, and either \`workspaceIds\` or \`resources\` — those last two are mutually exclusive, and sending both fails. Page with \`limit\` and \`cursor\`, and pass \`include=meta.total\` when you need the total count. Secret values come back obfuscated and hashed, never in full. Use getDetectedSecretsLocations to find where a specific secret appears. Requires a Postman Enterprise plan.

Creates a duplicate of the given collection in another workspace. Use the GET \`/collection-duplicate-tasks/{taskId}\` endpoint to get the duplication task's current status.

Creates a collection from the given API specification. The specification must already exist or be created before it can be used to generate a collection. The response contains a polling link to the task status.

Generates an OpenAPI 2.0, 3.0, or 3.1 specification for the given collection. The response contains a polling link to the task status.

Gets one workspace update by ID. Use getWorkspaceUpdates to discover the ID. This is an announcement post, not the workspace's settings — use getWorkspace for those.

Manages Partner Workspace access: invites partners by email address, removes them from one workspace, or removes them from the partnership and every workspace in it. Existing partners are added directly; new email addresses are sent an invitation. Two of these three actions are broad and irreversible in effect — removing someone from a partnership revokes their access to every shared workspace at once, not just the one you were looking at. Confirm the scope before calling, and only act on an explicit instruction naming the addresses and the action. Inviting sends real email to external people, so never invite speculatively or to an address you inferred. Requires a Team or Enterprise plan, and the Partner Manager, Workspace Editor, or Admin role depending on the action.

Adds or removes roles in bulk for users, groups, teams, and organizations within a team. Removing a role from a group or a team strips that role's permissions from every member of it at once, so the blast radius is much larger than the size of the request body. This changes who can do what. Only call it on an explicit instruction naming the entities and roles involved, and read the current state with getTeam (\`include=userRoles\`) first so you can describe what will change.

**This endpoint is deprecated.** Merges a forked collection back into its parent collection. You must have the [Editor role](https://learning.postman.com/docs/collaborating-in-postman/roles-and-permissions/#collection-roles) for the collection to merge a fork.

Updates specific collection information, such as its name, events, or its variables. For more information, see the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). **Important usage notes:** - **Sequential calls only.** Do NOT call \`patchCollection\` in parallel with other \`patchCollection\` calls for the same collection — concurrent PATCH requests conflict with each other and cause cancellation errors. Always wait for one call to complete before making another. - **Partial updates.** Only include the fields you want to change. Omit all other fields entirely; unspecified fields are left unchanged. - **Variables (\`collection.variable\`).** Send \`key\` and \`value\` for each variable, and use \`disabled\` to turn one off. An \`enabled\` field is accepted but silently ignored, so \`disabled\` is the only one that takes effect. - **Secret variables.** You can't set secret variables through this endpoint. Manage cloud- or vault-backed secrets through environments instead. - **Events (\`collection.events\`).** Each event's \`script.id\` is required and must be supplied by you — generate a UUID string for it. Omitting it fails with \`Parameters required: ('id') for key: 'collection.events.script'\`. The event itself is identified by its \`script.id\`.

Updates specific environment properties, such as its name and variables. **Note:** - You can only perform one type of operation at a time. For example, you cannot perform an \`add\` and \`replace\` operation in the same call. - The request body size cannot exceed the maximum allowed size of 30MB. - If you receive an HTTP \`411 Length Required\` error response, manually pass the \`Content-Length\` header and its value in the request header. - To add a description to an existing variable, use the \`add\` operation. - Only [shared variable](https://learning.postman.com/docs/use/send-requests/variables/variables/#share-variable-values) values can be modified through the Postman API. A shared variable is an environment variable with its value synced and stored in the Postman cloud, and can be accessed by your teammates in the environment's workspace.

Edits a published workspace update. Requires the \`application/merge-patch+json\` Content-Type header, and only the fields you send are changed. Watchers may have already read the original, so correct an update rather than rewriting its meaning, and post a new one with createWorkspaceUpdate when the news itself has changed.

Registers services with the API Catalog as discovered services, for sources Postman cannot detect on its own. Accepts up to 20 services per call; each needs at least a \`name\`. Supply \`apiDefinition\` to attach an OpenAPI definition, or \`endpoints\` to list endpoints directly — if you send both, \`endpoints\` is ignored. Without \`providerServiceId\` the system derives one from \`{name}:{version}\`, so pass it explicitly when you need a stable identifier across calls. Do not use this tool to create a Postman API specification or collection; it only adds catalog discovery records. Requires a Postman Enterprise plan.

Publishes a collection's documentation. This makes it publicly available to anyone with the link to the documentation. **Note:** - Your [Postman plan](https://www.postman.com/pricing/) impacts your use of these endpoints: - For **Free** and **Solo** users, you must have permissions to edit the collection. - If [API Governance and Security](https://learning.postman.com/docs/api-governance/configurable-rules/configurable-rules-overview/) is enabled for your [**Enterprise**](https://www.postman.com/pricing/) team, only users with the [Community Manager role](https://learning.postman.com/docs/collaborating-in-postman/roles-and-permissions/#team-roles) can publish documentation. - Publishing is only supported for collections with HTTP requests. - You cannot publish a collection added to an API.

Publishes a mock server. Publishing a mock server sets its **Access Control** configuration setting to public.

Pulls the changes from a parent (source) collection into the forked collection. In the endpoint's response: - The \`destinationId\` is the ID of the forked collection. - The \`sourceId\` is the ID of the source collection.

Replaces the contents of a collection using the [Postman Collection v2.1.0 schema format](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). Include the collection's ID values in the request body. If you do not, the endpoint removes the existing items and creates new items. - To perform an update asynchronously, use the \`Prefer\` header with the \`respond-async\` value. When performing an async update, this endpoint returns a HTTP \`202 Accepted\` response. - For a complete list of properties and information, see the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). - For protocol profile behavior, refer to Postman's [Protocol Profile Behavior documentation](https://github.com/postmanlabs/postman-runtime/blob/develop/docs/protocol-profile-behavior.md). **Note:** - The maximum collection size this endpoint accepts cannot exceed 100 MB. - Use the GET \`/collection-updates-tasks/{taskId}\` endpoint to get the collection's update status when performing an asynchronous update. - If you don't include the collection items' ID values from the request body, the endpoint **removes** the existing items and recreates the items with new ID values. - To copy another collection's contents to the given collection, remove all ID values before you pass it in this endpoint. If you do not, this endpoint returns an error. These values include the \`id\`, \`uid\`, and \`postman_id\` values.

Replaces all the contents of an environment with the given information. **Note:** - The request body size cannot exceed the maximum allowed size of 30MB. - If you receive an HTTP \`411 Length Required\` error response, manually pass the \`Content-Length\` header and its value in the request header. - Only [shared variable](https://learning.postman.com/docs/use/send-requests/variables/variables/#share-variable-values) values can be modified through the Postman API. A shared variable is an environment variable with its value synced and stored in the Postman cloud, and can be accessed by your teammates in the environment's workspace.

Detaches workspace environments from a system environment. Send 1 to 25 \`workspaceEnvironmentIds\` per call, each an environment UID (\`userId\`-\`environmentId\`). This only removes the association — the underlying Postman environments are left intact. Do not use this tool to delete an environment; use deleteEnvironment instead. Requires a Postman Enterprise plan.

Removes users, groups, or organizations from a Postman team. Returns 204 with no body on success. This is destructive and not self-reversing: removed members lose access to the team's collections, environments, and workspaces, and restoring them means re-inviting them and rebuilding their roles. Only call it on an explicit instruction naming exactly who to remove. Never call it to tidy up inactive members, to act on a list you assembled yourself, or as a step in some larger cleanup.

Removes a workspace from your team's Private API Network. This does not delete the workspace itself — it only removes it from the Private API Network folder. WARNING: This tool is for Private API Network management, not for general workspace operations. For workspace management use: getWorkspaces, getWorkspace, createWorkspace, updateWorkspace, deleteWorkspace.

Resolves a comment and any associated replies. On success, this returns an HTTP \`204 No Content\` response. Comment thread IDs return in the GET \`/comments\` response for [collections](https://www.postman.com/postman/workspace/postman-public-workspace/request/12959542-[example ID]) and [collection items](https://www.postman.com/postman/workspace/postman-public-workspace/folder/12959542-[example ID]).

Responds to a user's request to add a workspace to your team's Private API Network. Only managers can approve or deny a request. Once approved, the workspace will appear in the team's Private API Network. WARNING: This tool is for Private API Network management, not for general workspace operations. For workspace management use: getWorkspaces, getWorkspace, createWorkspace, updateWorkspace, deleteWorkspace.

Reviews a pull request by performing an action on it. The required \`action\` field determines the outcome: - \`approve\` — approve the pull request for merge. - \`merge\` — merge the pull request into its destination (parent) collection. - \`decline\` — decline the pull request; optionally include a \`comment\` explaining why. - \`unapprove\` — revoke a previous \`approve\` (does not decline the pull request). Use this tool to formally approve, merge, decline, or unapprove a pull request.

Runs a Postman collection by ID with detailed test results and execution statistics. Supports optional environment for variable substitution. Note: Advanced parameters like custom delays and other runtime options are not yet available.

Runs a monitor and returns its run results. **Note:** - If you pass the \`async=true\` query parameter, the response does not return the \`stats\`, \`executions\`, and \`failures\` responses. To get this information for an asynchronous run, call the GET \`/monitors/{id}\` endpoint. - If the call exceeds 300 seconds, the endpoint returns an HTTP \`202 Accepted\` response. Use the GET \`/monitors/{id}\` endpoint to check the run's status in the response's \`lastRun\` property. To avoid this, it is recommended that you include the \`async=true\` query parameter when using this endpoint.

Asks a natural-language question about the team's software estate — which APIs and services exist, what they expose, and how they depend on each other — and gets an answer grounded in the team's Context Graph. Use this for questions about the estate as a whole that no single collection or workspace can answer. This is asynchronous and does not return the answer: it returns an \`askId\` with status \`pending\`. Poll getContextGraphAsk with that ID until \`status\` is \`completed\` or \`failed\`, and only report an answer once it is \`completed\`. Set \`includeAnswer=false\` when you want just the graph data and intend to phrase the answer yourself, and lower \`maxSteps\` (1-15, default 10) to cap how much work the ask does. Do not use this tool to search Postman elements by name; use searchPostmanElements instead. Each ask counts against the team's quota, so ask one well-formed question rather than retrying variations of the same one. Requires Context Graph to be enabled for the team.

Syncs a collection generated from an API specification. This is an asynchronous endpoint that returns an HTTP \`202 Accepted\` response. **Note:** - This endpoint only supports the OpenAPI 2.0, 3.0, and 3.1 specification types. - You can only sync collections generated from the given spec ID.

Syncs an API specification linked to a collection. This is an asynchronous endpoint that returns an HTTP \`202 Accepted\` response. **Note:** - This endpoint only supports the OpenAPI 2.0, 3.0, and 3.1 specification types. - You can only sync collections generated from the given specification ID.

Moves or copies an element — a collection, environment, mock, monitor, or Flows module or action — from one workspace into another. Both workspaces' activity feeds record the change. Transferring changes who can see the element, since access follows the destination workspace. Team workspaces cannot transfer into personal workspaces. To duplicate a collection without moving it, use duplicateCollection instead.

Moves a workspace from one team to another, with \`source\` as the current team and \`destination\` as the new one. Only available on Enterprise plans with Postman Organizations enabled. This rewrites access as a side effect: anyone whose role exists in the source team but not the destination loses it on transfer, so people can silently lose access to the workspace's contents. Read getWorkspaceRoles first so you can say who is affected, and only call this on an explicit instruction naming both teams. To move a single collection or environment instead of the whole workspace, use transferWorkspaceElement.

Unpublishes a collection's documentation. On success, this returns an HTTP \`204 No Content\` response.

Unpublishes a mock server. Unpublishing a mock server sets its **Access Control** configuration setting to private.

Updates a system environment's \`name\`, \`description\`, \`color\`, or \`isProduction\`. Send at least one field; omitted fields are left unchanged. A new name must stay unique within the team — a duplicate returns 409. Pass \`description\` as an empty string to clear it. \`label\` cannot be changed after creation. Do not use this tool to change which workspace environments are attached; use addApiCatalogSystemEnvironmentAssociations or removeApiCatalogSystemEnvironmentAssociations instead. Requires a Postman Enterprise plan.

Updates a comment on an API's collection. **Note:** This endpoint accepts a max of 10,000 characters.

Updates a comment on a collection. **Note:** This endpoint accepts a max of 10,000 characters.

Updates a folder in a collection. For a complete list of properties, refer to the **Folder** entry in the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). **Note:** This endpoint acts like a PATCH method. It only updates the values that you pass in the request body (for example, the \`name\` property). The endpoint does not update the entire resource.

Updates a request in a collection. For a complete list of properties, refer to the **Request** entry in the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). **Note:** - You must pass a collection ID (\`[example ID]\`), not a collection(\`12345678-[example ID]\`), in this endpoint. - This endpoint does not support changing the folder of a request. - This endpoint acts like a PATCH method. It only updates the values that you pass in the request body.

Updates a response in a collection. For a complete list of properties, see the [Postman Collection Format documentation](https://schema.postman.com/collection/json/v2.1.0/draft-07/docs/index.html). **Note:** - You must pass a collection ID (\`[example ID]\`), not a collection UID (\`12345678-[example ID]\`), in this endpoint. - This endpoint acts like a PATCH method. It only updates the values that you pass in the request body (for example, the \`name\` property). The endpoint does not update the entire resource.

Updates a collection's associated tags. This endpoint replaces all existing tags with those you pass in the request body.

Renames a component or changes its lifecycle status. Send \`name\` to rename, or \`status\` to archive (\`archive\`, making the component read-only while keeping its published versions accessible) or restore it (\`active\`). Send only one of the two per call: name and status cannot change together. Archived components cannot be renamed, edited, or published until they are set back to \`active\`. Do not use this tool to change a component's content; use updateComponentDraft instead. Requires a Postman Enterprise plan.

Updates a component's working draft content, format, or both. Include at least one field; omitted fields remain unchanged. Edits are not visible to teammates referencing the component until you publish them with createComponentVersion. Archived components cannot be edited — restore them with updateComponent first. Do not use this tool to publish changes; use createComponentVersion instead. Requires a Postman Enterprise plan.

Records how a detected secret was dealt with, in one workspace. Requires \`workspaceId\` and a \`resolution\` of \`FALSE_POSITIVE\` (not really a secret), \`REVOKED\` (was real, key has been rotated), or \`ACCEPTED_RISK\` (real, exposure accepted). This only records a judgement — it does not revoke a credential, remove the secret from the collection, or make the exposure safe. Never mark something \`REVOKED\` unless the key has actually been rotated, and never mark it \`ACCEPTED_RISK\` on a person's behalf: both are decisions a human owner has to make. Requires a Postman Enterprise plan.

Updates a comment on a folder. **Note:** This endpoint accepts a max of 10,000 characters.

Updates a mock server. - Resource: Mock server entity associated with a collection UID. - Use this to change name, environment, privacy, or default server response. - To activate a server response, set \`config.serverResponseId\` to the server response's \`id\`. Pass \`null\` to deactivate.

Updates a server response's name, statusCode, body, headers, or language. - \`statusCode\` must remain a 5xx value (500–599). - \`body\` is the raw response body string. Pass the full desired body — this is a full replacement, not a partial update. - Updating a server response does not change which response is active. To activate it, call \`updateMock\` with \`config.serverResponseId\`.

Updates a monitor's [configurations](https://learning.postman.com/docs/monitoring-your-api/setting-up-monitor/#configure-a-monitor).

Updates an active package's description, index script content, or both. Include at least one field and only the fields you want to change; omitted fields remain unchanged. Do not use this tool to create or delete a package.

Updates the editable metadata of an open pull request, such as its title, description, or reviewers. Use reviewPullRequest (not this tool) to approve, decline, or merge a pull request.

Updates a comment on a request. **Note:** This endpoint accepts a max of 10,000 characters.

Updates a comment on a response. **Note:** This endpoint accepts a max of 10,000 characters.

Changes an SDK Git connection's lifecycle status. Setting \`active\` connects or reconnects the repository and resumes auto-update pull requests; \`disconnected\` stops any further pull requests being opened while preserving the historical record, which stays queryable through getSdkGitConnectionPullRequests. The call is idempotent, so setting current values is a harmless no-op. The \`inaccessible\` status is set by Postman and cannot be assigned here — seeing it means the repository or its credentials need attention on the Git side. \`autoUpdatePullRequestsEnabled\` is Enterprise-only and is forced to false on Team plans. Requires a Postman Team or Enterprise plan.

Updates a file for an OpenAPI or protobuf 2 or 3 specification. **Note:** - This endpoint does not accept an empty request body. You must pass one of the accepted values. - This endpoint does not accept multiple request body properties in a single call. For example, you cannot pass both the \`content\` and \`type\` property at the same time. - Multi-file specifications can only have one root file. - When updating a file type to \`ROOT\`, the previous root file is updated to the \`DEFAULT\` file type. - Files cannot exceed a maximum of 10 MB in size.

Updates a team's settings. This is a PUT and applies team-wide, affecting every member at once — read the current values with getTeamSettings first and send the full intended state, since a partial body can reset settings you did not mean to touch. Only call this on an explicit instruction naming the setting to change. Do not use it to infer configuration an operator did not ask for.

Updates a workspace's property, such as its name or visibility. **Note:** - This endpoint does not support the following visibility changes: - \`private\` to \`public\`, \`public\` to \`private\`, and \`private\` to \`personal\` for **Free** and **Solo** [plans](https://www.postman.com/pricing/). - \`public\` to \`personal\` for team users only. - There are rate limits when publishing public workspaces. - Public team workspace names must be unique.

Updates and replaces a workspace's global [variables](https://learning.postman.com/docs/sending-requests/variables/#variable-scopes). This endpoint replaces all existing global variables with the variables you pass in the request body.

Changes who can access a workspace, for users, user groups, or partners. Read the current state with getWorkspaceRoles first and get assignable role names from getAllWorkspaceRoles. Several constraints will reject an otherwise reasonable call: at most 50 operations per request, exactly one action per user, group, or partner in a body, and partner roles and user roles cannot be changed in the same call. Personal workspaces do not support role assignment, the external Guest role is not supported, and user groups require an Enterprise plan. Pass the \`identifierType=scim\` header to use SCIM IDs. This grants or removes access to everything in the workspace, so only call it on an explicit instruction naming the people and roles involved.

Updates a workspace's associated tags. This endpoint replaces all existing tags with those you pass in the request body.