addApiCatalogSystemEnvironmentAssociations
ChatGPTAttaches workspace environments to a system environment. Send 1 to 25 \workspaceEnvironmentIds\ per call, each an environment UID (\userId\-\environmentId\). \allowPartial=false\ rejects the whole call if any single association is ineligible, while \allowPartial=true\ adds the eligible ones and skips the rest — prefer \false\ unless you intend to accept a partial result, and read the response to see which were skipped. Do not use this tool to create the environments themselves; use createEnvironment first. Requires a Postman Enterprise plan.
addWorkspaceToPrivateNetwork
ChatGPTPublishes a workspace 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.
approveDenyAccessRequest
ChatGPTApproves or denies a pending team access request. Get the request ID from getTeamAccessRequests. Approving grants someone access to the team and its contents, and that is an authorization decision, not a piece of bookkeeping. Only call this when an operator has explicitly told you which request to approve or deny — never to clear a backlog of pending requests, and never by inferring intent from the request itself.
asyncMergePullCollectionFork
ChatGPTMerges a collection fork into its parent, or pulls the parent's changes into the fork, as a background task. Direction is decided entirely by the IDs: pass the fork as \source\ and the parent as \destination\ to merge, and swap them to pull. Both take collection unique IDs (\userId\-\collectionId\), not plain collection IDs. \strategy\ acts on whichever collection is \source\, so it is only safe when merging, where \source\ is the fork: \default\ leaves the fork alone, \updateSourceWithDestination\ also copies the parent's differences back into it, and \deleteSource\ deletes it — the last two require Editor access on both collections. When pulling, \source\ is the parent, so always use \default\; the other strategies would write back into or delete the parent. The response returns a task \id\; poll asyncMergePullCollectionTaskStatus with it, because a 200 here means the task was accepted, not that the merge finished. Prefer this tool over mergeCollectionFork and pullCollectionChanges for large collections, since those run synchronously and can time out.
asyncMergePullCollectionTaskStatus
ChatGPTGets the status of an asynchronous collection merge or pull started by asyncMergePullCollectionFork, using the task \id\ that call returned. Poll this until the task reports a terminal state — do not assume the merge landed just because the original request returned 200. Task status is kept for only 24 hours after the task finishes; after that this returns 404, which means the record expired and not that the merge failed.
createAccessRequest
ChatGPTCreates an access request against a team — to join it, to raise a user's role, to add members, or to request team role access to another team. This asks for a privilege change on someone's behalf, and if team discovery is enabled the request is approved automatically, which means it can grant access with no human in the loop. Only call it on an explicit request from the person the access is for.
createApiCatalogSystemEnvironment
ChatGPTCreates a system environment for the team. \name\ and \color\ (a six-digit hex code such as \#00FF00\) are both required, and the name must be unique within the team — a duplicate returns 409. Optionally set \label\ (lowercase alphanumerics, hyphens, and underscores only), \description\, and \isProduction\. Do not use this tool to create a Postman environment with variables; use createEnvironment instead. Requires a Postman Enterprise plan.
createCollection
ChatGPTCreates a collection using the Postman Collection v2.1.0 schema format. Note: If you do not include the \workspace\ query parameter, the system creates the collection in the oldest personal Internal workspace you own. createCollectionFolder
ChatGPTCreates a folder in a collection. For a complete list of properties, refer to the Folder entry in the Postman Collection Format documentation. 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. createCollectionFork
ChatGPTCreates a fork from an existing collection into a workspace. createCollectionPullRequest
ChatGPTCreates 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.
createCollectionRequest
ChatGPTCreates a request in a collection. For a complete list of properties, refer to the Request entry in the Postman Collection Format documentation. 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. createCollectionResponse
ChatGPTCreates 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. 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. createComponent
ChatGPTCreates 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.
createComponentVersion
ChatGPTPublishes 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.
createCustomFunction
ChatGPTCreates a custom Spectral function that rulesets can call. \path\ must be \functions/<name>.js\, where the name is at least two characters and starts with a letter, underscore, or dollar sign; nested paths aren't supported. \content\ is the function's JavaScript source, up to 500 KB.
createEnvironment
ChatGPTCreates 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 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. createGovernanceGroup
ChatGPTCreates an empty custom governance group. \name\ must be unique within the team. Add workspaces with updateGovernanceGroupWorkspaces and apply rules with createRulesetAssignment.
createMock
ChatGPTCreates 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.
createMockServerResponse
ChatGPTCreates 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.
createMonitor
ChatGPTCreates 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.
createPackage
ChatGPTCreates 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.
createRuleset
ChatGPTCreates a custom governance ruleset for the team. \content\ is the full ruleset definition (for the \spectral\ engine, a Spectral ruleset document as a string, up to 500 KB). \name\ must be unique within the team and may only contain letters, numbers, hyphens, underscores, and periods. A new ruleset governs nothing until it is assigned to a governance group with createRulesetAssignment. If the ruleset calls custom functions, create them first with createCustomFunction.
createRulesetAssignment
ChatGPTAssigns a ruleset to a governance group so its rules apply to every workspace in that group. Set \targetType\ to \governance_group\ and \targetId\ to the group's ID from getAllGovernanceGroups. This is the only way to apply a ruleset; rulesets can't be assigned to a workspace directly.
createSdk
ChatGPTStarts 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.
createSdkGitConnection
ChatGPTConnects 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.
createSpec
ChatGPTCreates an API specification in Postman's Spec Hub. 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. createSpecFile
ChatGPTCreates 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.
createSpecVersionTag
ChatGPTTags the specification's current state as a new version snapshot under the \name\ you supply. Use this to mark a release or a reviewed state before making further edits. A tag attaches to the specification's current changelog group, so tagging twice without any intervening change conflicts with a 409 — edit the specification first to open a new changelog group, then tag again. Do not use this tool to save specification content; use updateSpecFile for that and tag afterwards.
createTeam
ChatGPTCreates 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.
createWorkspace
ChatGPTCreates a new workspace. Note: - This endpoint returns a 403 \Forbidden\ response if the user does not have permission to create workspaces. Admins and Super Admins 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 are available on Postman **Team** and **Enterprise** plans. - 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 is enabled. createWorkspaceUpdate
ChatGPTPublishes 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.
deleteCollection
ChatGPTDeletes a collection.
deleteCollectionFolder
ChatGPTDeletes a folder in a collection.
deleteCollectionRequest
ChatGPTDeletes a request in a collection.
deleteCollectionResponse
ChatGPTDeletes a response in a collection.
deleteCustomFunction
ChatGPTPermanently deletes a custom function. A ruleset that still calls it may fail to run that rule, so check the team's rulesets with getAllRulesets and getRuleset first.
deleteEnvironment
ChatGPTDeletes an environment.
deleteGovernanceGroup
ChatGPTDeletes a custom governance group. This also removes all of its workspace assignments and every ruleset assignment targeting it, so those workspaces stop being governed by the group's rulesets. The workspaces and rulesets themselves are not deleted. Postman-managed groups (\type: system\) can't be deleted and return 403.
deleteMock
ChatGPTDeletes a mock server. - Resource: Mock server entity. This is destructive. - Ensure you are targeting the correct mock ID.
deleteMockServerResponse
ChatGPTDeletes 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.
deleteMonitor
ChatGPTDeletes a monitor.
deletePackage
ChatGPTDeletes 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.
deleteRuleset
ChatGPTPermanently deletes a custom ruleset, which stops its rules from applying to every governance group it was assigned to. To stop applying it to one group only, use deleteRulesetAssignment instead. Postman-managed rulesets (\type: system\) can't be deleted and return 403.
deleteRulesetAssignment
ChatGPTUnassigns a ruleset from one governance group, so its rules stop applying to that group's workspaces. Pass \targetType=governance_group\ and the group's ID as \targetId\. The ruleset and the group both remain.
deleteSdk
ChatGPTDeletes 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.
deleteSpec
ChatGPTDeletes an API specification. On success, this returns an HTTP \204 No Content\ response.
deleteSpecFile
ChatGPTDeletes a file in an API specification. On success, this returns an HTTP \204 No Content\ response.
deleteWorkspace
ChatGPTDeletes an existing workspace.
deleteWorkspaceUpdate
ChatGPTDeletes 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.
detectedSecretsQueries
ChatGPTSearches 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.
duplicateCollection
ChatGPTCreates 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.
forkEnvironment
ChatGPTForks an environment into a workspace, giving that workspace an editable copy that stays linked to the original. Requires the destination \workspaceId\ as a query parameter and a \forkName\ label in the body. Use this when a team needs to change variable values without touching a shared environment. Do not use this tool to copy an environment into a workspace with no ongoing link; create a new environment with createEnvironment and set its values instead.
generateCollection
ChatGPTCreates 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.
generateSpecFromCollection
ChatGPTGenerates an OpenAPI 2.0, 3.0, or 3.1 specification for the given collection. The response contains a polling link to the task status.
getAllComponents
ChatGPTLists the components in the team's component library. Use this to discover component IDs before reading or editing a component. Narrow the results with \type\, \status\, and \hasVersions\, and request extra fields with \include\ (\hasVersions\, \latestVersion\, \latestVersion.content\) or \expand\ (\latestVersion\). Do not use this tool to read a component's draft content; use getComponentDraft instead. Requires a Postman Enterprise plan.
getAllCustomFunctions
ChatGPTLists the team's custom Spectral functions, which rulesets can call for checks the built-in rule types don't cover. Returns metadata only; call getCustomFunction with \include=content\ to read a function's code. Page with \limit\ (max 100) and \cursor\ from \meta.nextCursor\.
getAllGovernanceGroups
ChatGPTLists the team's governance groups. A governance group is a set of workspaces that share the same assigned rulesets. Postman-managed groups (\type: system\), such as the default group covering all workspaces, are read-only. Page with \limit\ (max 100) and \cursor\ from \meta.nextCursor\.
getAllRulesets
ChatGPTLists the team's governance rulesets, both team-owned (\type: custom\) and Postman-managed (\type: system\). Returns metadata only, without rule content; call getRuleset with \include=content\ to read a ruleset's rules. Page with \limit\ (max 100) and \cursor\ from \meta.nextCursor\.
getAllSpecs
ChatGPTGets all API specifications in a workspace.
getAllWorkspaceRoles
ChatGPTLists the workspace role types available to the team, which depend on the team's plan. Call this before updateWorkspaceRoles to learn which roles you are allowed to assign. This returns the catalogue of possible roles, not anyone's actual assignments — use getWorkspaceRoles for those.
getAnalyticsData
ChatGPTGets analytics data based on the specified resource, metrics, and given filters for team, internal, and public workspaces, as well as Partner Workspaces. Note: This endpoint only accepts the following resource:metric query parameter combinations: - \user\ — \workspace_active_users\, \active_users\ - \workspace\ — \elements_in_workspace\, \active_workspaces\, \api_calls\, \active_collections\, \response_status\, \pending_invites\, \needs_attention\, \success_rate\, \user_requests\, \collection_error_aggregate\ - \team\ — \user_api_journey\, \workspace_distribution\, \internal_workspace_distribution\, \license_consumption\, \members\, \last_autoflex_cycle\, \partner_engagement_funnel\ \members_overtime\ , \member_invites\, \invites_sent\ , \invites_accepted\ - \ai\ — \top_agent_models_by_usage\, \activity_distribution\, \peak_activity\, \usage_leaderboard\, \credit_usage_by_model\, \messages_sent\, \credit_usage\, \agent_mode_sessions\, \new_vs_returning_users\, \agent_mode_users\ - \api_development\ — \active_workspaces\, \entity_activity\, \top_entities\ - \api_testing\ — \runs\, \functional_test_runs\, \performance_test_runs\ - \api_production\ — \monitor_runs\, \flow_executions\ - \api_distribution\ — \active_workspaces\, \pvt_network\, \partner\, \public\ - \api_management\ — \workspace_activity\ The \view\ query parameter only accepts the following values when called with the following resource:metric pairs: \detailed\ or \summary\ — \user:active_users\, \workspace:active_workspaces\, \workspace:pending_invites\, \workspace:needs_attention\, \workspace:success_rate\, \team:partner_engagement_funnel\, \api_distribution:pvt_network\, \api_distribution:partner\, \api_distribution:public\ - \detailed\, \summary\, or \trends\ — \api_development:entity_activity\, \api_testing:functional_test_runs\ , \api_testing:performance_test_runs\, \api_production:monitor_runs\, \api_production:flow_executions\ - \summary\ or \trend\ — \api_development:active_workspaces\, \api_testing:runs\, \api_distribution:active_workspaces\, \api_management:workspace_activity\ - \summary\ only — \workspace:elements_in_workspace\, \workspace:workspace_active_users\, \workspace:api_calls\, \workspace:response_status\, \team:user_api_journey\, \team:workspace_distribution\, \team:internal_workspace_distribution\, \team:license_consumption\ - \detailed\ only — \workspace:active_collections\, \workspace:user_requests\, \api_development:top_entities\, \api_management:popular_workspaces\ , \team:invites_sent\ , \team:invites_accepted\ - \trend\ only — \team:members_overtime\, \team:member_invites\
getAnalyticsMetadata
ChatGPTReturns a catalog of analytics resources and their corresponding metrics for use with the GET /analytics endpoint. These metrics provide insights on API usage, success, workspace, and team trends in Postman.
getApiCatalogDiscoveryService
ChatGPTGets one discovered service in detail, including its endpoint list and its OpenAPI definition as a base64-encoded string — decode that value before reading it. Use getApiCatalogDiscoveryServices first to find the service ID. Do not use this tool for a catalogued service's health, traffic, or ownership data; use getApiCatalogService instead. Requires a Postman Enterprise plan.
getApiCatalogDiscoveryServices
ChatGPTLists 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.
getApiCatalogService
ChatGPTGets 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.
getApiCatalogServiceCiRuns
ChatGPTLists 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.
getApiCatalogServiceEndpoints
ChatGPTLists 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.
getApiCatalogServiceMonitorRuns
ChatGPTLists 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.
getApiCatalogServiceSpecificationLints
ChatGPTLists 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.
getApiCatalogServices
ChatGPTLists 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.
getApiCatalogSystemEnvironment
ChatGPTGets 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.
getApiCatalogSystemEnvironmentAssociations
ChatGPTLists 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.
getApiCatalogSystemEnvironments
ChatGPTLists 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.
getApiDiscoveryInstructions
ChatGPTReturns 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.
getAsyncSpecTaskStatus
ChatGPTGets the status of an asynchronous API specification creation task.
getAuditLogEventActions
ChatGPTLists 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.
getAuditLogs
ChatGPTGets 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.
getAuthenticatedUser
ChatGPTGets 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.
getCodeGenerationInstructions
ChatGPTReturns 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.
getCollection
ChatGPTGet 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.
getCollectionFolder
ChatGPTGets information about a folder in a collection.
getCollectionForks
ChatGPTGets 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.
getCollectionPullRequests
ChatGPTLists 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.
getCollectionRequest
ChatGPTGets information about a request in a collection.
getCollectionResponse
ChatGPTGets information about a response in a collection.
getCollectionRoles
ChatGPTGets who can view or edit a collection, as the IDs of the users, groups, and teams holding each role. Use this to audit access before changing it. The response returns numeric IDs rather than names — resolve user IDs with getTeamUsers, group IDs with getGroups, and team IDs with getTeams or getTeam when you need to report on them. Do not use this tool to read workspace-level access; a collection can be reachable through its workspace without appearing here.
getCollectionTags
ChatGPTGets all the tags associated with a collection.
getCollectionUpdatesTasks
ChatGPTGets the status of an asynchronous collection update task.
getCollections
ChatGPTThe workspace ID query is required for this endpoint. If not provided, the LLM should ask the user to provide it.
getCollectionsForkedByUser
ChatGPTGets a list of all the authenticated user's forked collections.
getComponent
ChatGPTGets 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.
getComponentDraft
ChatGPTGets 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.
getComponentVersion
ChatGPTGets 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.
getComponentVersions
ChatGPTLists 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.
getContextGraphAsk
ChatGPTGets 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.
getCustomFunction
ChatGPTGets a custom function's metadata by ID. Pass \include=content\ to also return its JavaScript source, which is required before editing it with updateCustomFunction.
getDetectedSecretsLocations
ChatGPTLists 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.
getDuplicateCollectionTaskStatus
ChatGPTGets the status of a collection duplication task.
getEnabledTools
ChatGPTIMPORTANT: 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.
getEnvironment
ChatGPTGets information about an environment.
getEnvironmentForks
ChatGPTLists the forks of an environment. Use this to find fork IDs before merging or pulling, or to see who has diverged from a shared environment. Page with \limit\ and \cursor\, and order with \sort\ and \direction\. This returns forks of one environment, not every environment in a workspace — use getEnvironments for that.
getEnvironments
ChatGPTGets information about all of your environments. getGeneratedCollectionSpecs
ChatGPTGets the API specification generated for the given collection.
getGovernanceGroupAssignments
ChatGPTLists the rulesets assigned to a governance group. Each assignment's \rulesetId\ can be passed to getRuleset. To go the other way, from a ruleset to its groups, use getRulesetAssignments.
getGovernanceGroupWorkspaces
ChatGPTLists the IDs of the workspaces assigned to a custom governance group. Page with \limit\ (max 100) and \cursor\ from \meta.nextCursor\. Postman-managed groups (\type: system\) return 403.
getGroup
ChatGPTGets 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.
getGroups
ChatGPTLists 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.
getInstalledApiMaintenanceInstructions
ChatGPTReturns 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.
getMock
ChatGPTGets 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.
getMockServerResponse
ChatGPTGets 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\.
getMockServerResponses
ChatGPTGets 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\.
getMocks
ChatGPTGets 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.
getMonitor
ChatGPTGets information about a monitor.
getMonitorRunResults
ChatGPTGets 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.
getMonitors
ChatGPTGets all monitors.
getPackage
ChatGPTGets 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.
getPackages
ChatGPTLists 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.
getPostmanContextOverview
ChatGPTReturns 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).
getPullRequest
ChatGPTGets 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.
getRuleset
ChatGPTGets a governance ruleset's metadata by ID. Pass \include=content\ to also return the ruleset's rule content, which is required before editing it with updateRuleset.
getRulesetAssignments
ChatGPTLists the governance groups a ruleset is assigned to. Each assignment's \targetId\ is a governance group ID. To go the other way, from a group to its rulesets, use getGovernanceGroupAssignments.
getSdk
ChatGPTGets 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.
getSdkDownloadUrl
ChatGPTGets 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.
getSdkGitConnection
ChatGPTGets 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.
getSdkGitConnectionPullRequests
ChatGPTLists 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.
getSdkGitConnections
ChatGPTLists 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.
getSdks
ChatGPTLists 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.
getSecretTypes
ChatGPTLists 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.
getSourceCollectionStatus
ChatGPTChecks 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.
getSpec
ChatGPTGets information about an API specification.
getSpecCollections
ChatGPTGets all of an API specification's generated collections.
getSpecDefinition
ChatGPTGets the complete contents of an OpenAPI or AsyncAPI specification's definition.
getSpecFile
ChatGPTGets the contents of an API specification's file.
getSpecFiles
ChatGPTGets all the files in an API specification.
getSpecVersionTag
ChatGPTGets one version tag and the specification files captured in that snapshot, letting you read a specification as it stood when the tag was created. Use getSpecVersionTags first to find the tag ID. Do not use this tool to read the specification's current content; use getSpecFiles or getSpecDefinition instead.
getSpecVersionTags
ChatGPTLists a specification's version tags — the point-in-time snapshots used to track how a specification changed over time. Use this to discover tag IDs and names, or to see whether the current state of a specification has been tagged yet. Page with \limit\ and \cursor\. Do not use this tool to read a tag's contents; use getSpecVersionTag with a tag ID from this response instead.
getStatusOfAnAsyncApiTask
ChatGPTGets the status of an asynchronous task.
getTaggedEntities
ChatGPTRequires 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.
getTeam
ChatGPTGets 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.
getTeamAccessRequests
ChatGPTLists 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.
getTeamSettings
ChatGPTGets 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.
getTeamUser
ChatGPTGets 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.
getTeamUsers
ChatGPTLists 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.
getTeams
ChatGPTLists 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.
getWorkspace
ChatGPTGets information about a workspace. Note: 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 (**Team** and **Enterprise** plans only). - \public\ — Everyone can access the workspace. - \partner\ — Only invited team members and partners can access the workspace (**Team** and **Enterprise** plans only). getWorkspaceActivityFeed
ChatGPTGets 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.
getWorkspaceGlobalVariables
ChatGPTGets a workspace's global variables. Global variables enable you to access data between collections, requests, scripts, and environments and are available throughout a workspace. getWorkspaceRoles
ChatGPTGets 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.
getWorkspaceTags
ChatGPTGets all the tags associated with a workspace.
getWorkspaceUpdate
ChatGPTGets 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.
getWorkspaceUpdates
ChatGPTLists 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.
getWorkspaces
ChatGPTGets 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\
listMonitorExecutions
ChatGPTLists 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.
listPrivateNetworkAddRequests
ChatGPTGets 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.
listPrivateNetworkWorkspaces
ChatGPTGets 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.
listRunsForExecution
ChatGPTLists 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.
managePartnerWorkspaceInvites
ChatGPTManages 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.
manageTeamMemberRoles
ChatGPTAdds 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.
mergeCollectionFork
ChatGPTThis endpoint is deprecated. Merges a forked collection back into its parent collection. You must have the Editor role for the collection to merge a fork. mergeEnvironmentFork
ChatGPTMerges a forked environment's changes up into its parent. The path holds the parent environment and \source\ holds the fork's unique ID — this direction sends the fork's values to the parent, so anyone using the parent sees them. Set \deleteSource\ to true to delete the fork after a successful merge; it defaults to false. To move changes the other way, from parent down into a fork, use pullEnvironment instead.
patchCollection
ChatGPTUpdates specific collection information, such as its name, events, or its variables. For more information, see the Postman Collection Format documentation. 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\. patchEnvironment
ChatGPTUpdates 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 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. patchWorkspaceUpdate
ChatGPTEdits 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.
postApiCatalogDiscoveryServices
ChatGPTRegisters 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.
publishDocumentation
ChatGPTPublishes a collection's documentation. This makes it publicly available to anyone with the link to the documentation. Note: - Your Postman plan impacts your use of these endpoints: - For Free and Solo users, you must have permissions to edit the collection. - If API Governance and Security is enabled for your **Enterprise** team, only users with the Community Manager role can publish documentation. - Publishing is only supported for collections with HTTP requests. - You cannot publish a collection added to an API. publishMock
ChatGPTPublishes a mock server. Publishing a mock server sets its Access Control configuration setting to public.
pullCollectionChanges
ChatGPTPulls 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.
pullEnvironment
ChatGPTPulls a parent environment's changes down into a fork. The path holds the fork being updated and \source\ holds the parent environment's unique ID — this direction leaves the parent untouched. Use it to bring a fork back up to date before merging, which keeps the merge from overwriting newer parent values. To send a fork's changes up to the parent, use mergeEnvironmentFork instead.
putCollection
ChatGPTReplaces the contents of a collection using the Postman Collection v2.1.0 schema format. 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. - For protocol profile behavior, refer to Postman's Protocol Profile Behavior documentation. 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. putEnvironment
ChatGPTReplaces 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 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. removeApiCatalogSystemEnvironmentAssociations
ChatGPTDetaches 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.
removeTeamMembers
ChatGPTRemoves 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.
removeWorkspaceFromPrivateNetwork
ChatGPTRemoves 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.
respondPrivateNetworkAddRequest
ChatGPTResponds 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.
reviewPullRequest
ChatGPTReviews 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.
runMonitor
ChatGPTRuns 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.
searchLearningCenter
ChatGPTSearch 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.
searchPostmanElements
ChatGPTSearch 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"}}]}
submitContextGraphAsk
ChatGPTAsks 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.
syncCollectionWithSpec
ChatGPTSyncs 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.
syncSpecWithCollection
ChatGPTSyncs 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.
transferCollectionFolders
ChatGPTCopies or moves folders into a collection or folder.
transferCollectionRequests
ChatGPTCopies or moves requests into a collection or folder.
transferCollectionResponses
ChatGPTCopies or moves responses into a request.
transferWorkspaceElement
ChatGPTMoves 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.
transferWorkspaceToTeam
ChatGPTMoves 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.
unpublishDocumentation
ChatGPTUnpublishes a collection's documentation. On success, this returns an HTTP \204 No Content\ response.
unpublishMock
ChatGPTUnpublishes a mock server. Unpublishing a mock server sets its Access Control configuration setting to private.
updateApiCatalogSystemEnvironment
ChatGPTUpdates 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.
updateCollectionFolder
ChatGPTUpdates a folder in a collection. For a complete list of properties, refer to the Folder entry in the Postman Collection Format documentation. 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. updateCollectionRequest
ChatGPTUpdates a request in a collection. For a complete list of properties, refer to the Request entry in the Postman Collection Format documentation. Note: - You must pass a collection ID (\12ece9e1-2abf-4edc-8e34-de66e74114d2\), not a collection(\12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2\), 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. updateCollectionResponse
ChatGPTUpdates a response in a collection. For a complete list of properties, see the Postman Collection Format documentation. Note: - You must pass a collection ID (\12ece9e1-2abf-4edc-8e34-de66e74114d2\), not a collection UID (\12345678-12ece9e1-2abf-4edc-8e34-de66e74114d2\), 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. updateCollectionRoles
ChatGPTChanges who can view or edit a collection. Send a \roles\ array where each entry has \op: update\, a \path\ of \/user\, \/group\, or \/team\, and a \value\ array of \{id, role}\ pairs with \role\ set to \VIEWER\ or \EDITOR\. This overwrites the roles for each ID you name, so read the current state with getCollectionRoles first and send the full intended set — omitting someone you meant to keep will change their access. Returns 204 with no body on success. The caller must hold the Editor role on the collection, and external Partner and Guest roles are not supported here.
updateCollectionTags
ChatGPTUpdates a collection's associated tags. This endpoint replaces all existing tags with those you pass in the request body.
updateComponent
ChatGPTRenames 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.
updateComponentDraft
ChatGPTUpdates 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.
updateDetectedSecretResolutions
ChatGPTRecords 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.
updateGovernanceGroup
ChatGPTUpdates a custom governance group's name or description. To change which workspaces are in the group, use updateGovernanceGroupWorkspaces. Postman-managed groups (\type: system\) can't be updated and return 403.
updateGovernanceGroupWorkspaces
ChatGPTAdds and removes workspaces in a custom governance group in one atomic request. Put workspace IDs to add in \create\ and IDs to remove in \delete\; omit either list if unused. Removed workspaces stop being governed by the group's rulesets. If any workspace in the batch can't be applied, nothing changes and the request fails with 409. Postman-managed groups (\type: system\) return 403.
updateMock
ChatGPTUpdates 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.
updateMockServerResponse
ChatGPTUpdates 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\.
updateMonitor
ChatGPTUpdates a monitor's configurations. updatePackage
ChatGPTUpdates 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.
updatePullRequest
ChatGPTUpdates 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.
updateSdkGitConnection
ChatGPTChanges 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.
updateSpecFile
ChatGPTUpdates 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.
updateSpecProperties
ChatGPTUpdates an API specification's properties, such as its name.
updateSpecSyncOptions
ChatGPTConfigures how a specification syncs into one of its generated collections. Set \syncExamples\ to keep example values aligned between the two, and \deleteOrphanedRequests\ to control whether requests whose endpoints have disappeared from the specification are removed on the next sync — leave that one on only when the collection is safe to prune, since it deletes requests. \syncOptions\ must include at least one of \syncExamples\ or \deleteOrphanedRequests\; an empty \syncOptions\ object is rejected. Whichever of the two you omit is left unchanged. Use getSpecCollections to find the collection ID. This changes settings only — it does not sync. Use syncCollectionWithSpec to actually run a sync.
updateTeamSettings
ChatGPTUpdates 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.
updateWorkspace
ChatGPTUpdates 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. - \public\ to \personal\ for team users only. - There are rate limits when publishing public workspaces. - Public team workspace names must be unique. updateWorkspaceGlobalVariables
ChatGPTUpdates and replaces a workspace's global variables. This endpoint replaces all existing global variables with the variables you pass in the request body. updateWorkspaceRoles
ChatGPTChanges 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.
updateWorkspaceTags
ChatGPTUpdates a workspace's associated tags. This endpoint replaces all existing tags with those you pass in the request body.
createAPI
ClaudecreateCollection
ClaudecreateEnvironment
ClaudecreateFolder
ClaudecreateMock
ClaudecreateMonitor
ClaudecreateRequest
ClaudecreateResponse
ClaudecreateWorkspace
ClaudedeleteAPI
ClaudedeleteCollection
ClaudedeleteEnvironment
ClaudedeleteFolder
ClaudedeleteMock
ClaudedeleteMonitor
ClaudedeleteRequest
ClaudedeleteResponse
ClaudedeleteWorkspace
ClaudegetAPI
ClaudegetAllAPIs
ClaudegetAllCollections
ClaudegetAllEnvironments
ClaudegetAllMocks
ClaudegetAllMonitors
ClaudegetAllWorkspaces
ClaudegetCollection
ClaudegetEnvironment
ClaudegetFolder
ClaudegetMock
ClaudegetMonitor
ClaudegetRequest
ClaudegetResponse
ClaudegetWorkspace
ClaudeupdateAPI
ClaudeupdateCollection
ClaudeupdateEnvironment
ClaudeupdateFolder
ClaudeupdateMock
ClaudeupdateMonitor
ClaudeupdateRequest
ClaudeupdateResponse
ClaudeupdateWorkspace
Claude
