Postman has been accused of automatically installing an AI plugin that attempts to share users' API data in full. The central issue is not the model's capabilities, but whether a developer tool can grant consent to data transmission on a user's behalf.
The Issue First Surfaced on GitHub
The dispute entered the public domain through [Issue #14370](https://github.com/postmanlabs/postman-app-support/issues/14370) in Postman's user support repository.
The issue describes two distinct concerns:
- The Postman client automatically installs an AI plugin.
- Relevant descriptions in the issue say the plugin attempts to share all of the user's API data.
Three different layers are involved:
- The Postman client itself.
- The API environments users use to make requests, inspect responses, and debug.
- The client's plugin installation and permission-granting mechanism.
This is therefore not a question of whether an AI plugin is useful or whether a model produces accurate answers. It reaches directly into a development tool's permission model: where plugins come from, when they are installed, what they can access by default, and whether users can see and revoke those permissions.
One important qualification is necessary. Most of the currently available material consists of user reports and allegations. The Issue title alone cannot confirm that all API data was actually transmitted externally, nor does it establish the complete data path.
What can be confirmed is that the boundary between permitted access and shared data is now disputed, with API credentials and business data close at stake.
The Debate Is Not Really About Features
The story reached the Hacker News front page, earning 612 points and 198 comments. Its discussion attracted far more attention than ordinary feature feedback.
Source: Hacker News discussion
Developers are concerned less about AI failing to write a few lines of code than about where API data might go.
Postman debugging environments often contain:
- API keys in
Authorizationheaders. - OAuth tokens, Bearer tokens, or other signed credentials.
- User details, order contents, and internal parameters in request bodies.
- Customer data, test data, and internal API results in responses.
- Variables stored in Collections, Environments, and Workspaces.
This data may not include every sensitive item in a production environment. It may still be enough to give a third-party service usable credentials or allow it to reconstruct real business requests.
If users see only “Install AI plugin,” without any indication that the default scope includes “all API data,” installing the software and authorizing the transmission of data have effectively been collapsed into a single button.
Installing a Plugin and Sharing Data Are Different Actions
“Allow plugin installation” should not automatically mean “allow all API data to be uploaded.”
The full process can be broken into four steps:
- The client downloads and installs the plugin.
- The plugin requests access to a Workspace, Collection, or local environment variables.
- The user selects which data may be shared.
- The data passes through a specific service to a model provider or Postman's cloud services.
Each step carries a different risk. Automatic installation primarily raises software supply-chain and execution-permission concerns. Data sharing raises concerns about request logs, request and response contents, and credentials.
They should not be handled as one decision.
A more responsible permission interface should display at least:
- The plugin's name, publisher, and version.
- The installation source and integrity verification details.
- The types of data the plugin intends to read.
- Whether Environment variables are included.
- Whether headers, request bodies, and response bodies are included.
- The domains or third-party services receiving the data.
- How long the data will be retained and whether it can be deleted.
When a user clicks “Agree,” that action should approve only the permissions explicitly shown at that moment. It should not function as a blank check for every API datum the tool might access in the future.
The Default Scope May Be More Dangerous Than Silent Installation
Even if the investigation ultimately finds that no bulk transmission occurred, the default scope still deserves scrutiny.
“All API data” could include credentials, environment variables, and business data. A scope that broad turns a routine permission grant into de facto full access.
At least four product boundaries are at stake.
Data minimization. An AI assistant may not need an entire environment. If the user only wants a model to analyze an error, providing the error response, the relevant request, and a few necessary environment names may be sufficient. There is no reason to upload an entire Workspace by default.
Explicit authorization. Different categories of data should be approved separately. Permission to read Collection names should be separate from permission to read request bodies, just as access to environment variables should be separate from access to response content. Users should not have to guess.
Excluding sensitive fields by default. Fields such as Authorization, Cookie, tokens, and API keys should be redacted by default.
Revocable permissions. After sharing is disabled, the plugin should not retain historical access. If data has already been transmitted, the tool must explain how it can be deleted.
Local and cloud data must also be considered. A Postman desktop client does not mean every plugin action occurs on the machine. A plugin may call a remote model directly, or it may first upload context to Postman's services and then forward it to a third party.
From the user's perspective, “local client” describes where the software is installed, not where its data boundaries lie.
Developers Should Audit Permissions First
The immediate priority is not to debate model capabilities. For teams using Postman, the more practical step is to conduct a permission and data-exposure review.
Step one: Review plugin and client update records.
Identify the automatically installed AI plugin by name, version, installation time, and publisher. Check whether it is permitted to update automatically and whether automatic installation can be disabled.
Step two: Inventory Workspaces.
Do not place API credentials directly in sample requests. This shell command can help locate common sensitive field names in a workspace:
rg -n -i --hidden \
'(authorization|api[_-]?key|access[_-]?token|bearer|password|secret|client[_-]?secret)' \
./postman-workspace
This command checks text patterns only. It can help identify obvious risks, but it cannot prove that fields are safe or detect every binary file, encrypted item, or format variant.
Step three: Review Environments and variable synchronization.
Determine whether local variables are being synchronized to team Workspaces, cloud services, or shared Collections. Remove unused variables, separate production credentials from test credentials, and assign sensitive variables shorter expiration periods.
Step four: Review logging and telemetry settings.
Establish whether request bodies, response bodies, or headers are uploaded, stored, or used for analysis. If a team must share debugging context with an AI plugin, create a redacted copy first and provide that instead.
The simple rule is: give the model only what it needs. Convenience for troubleshooting should not become a reason to hand over an entire environment.
Implications for Developer Tools
This matters not only because Postman could lose some user trust. AI plugins are changing the permission model of development tools. Collections and Environments used to be collaboration objects primarily among team members; with agentic assistants added, they can also become sources of model context.
The next round of competition in developer tools will not be decided by model capability alone. Clear disclosure of data access, sensitive-field exclusion by default, limits on third-party forwarding, and the ability to revoke permissions at any time may matter more. The same principle applies when AI Agents connect to enterprise systems: least privilege by default is more trustworthy than an explanation after the fact.
This case is also different from earlier plugin-permission disputes. A conventional plugin that fails usually causes damage confined to the current process. An AI plugin may send context to an external service, where poor selections, prompt injection, and log retention can widen the consequences.
The available material still cannot establish the complete data path or confirm that “all API data” was actually transmitted externally. The next evidence to watch for includes Postman's technical explanation, server-side log evidence, and a verifiable permission configuration.