# Give developers and agents API access with Postman Passport

> Source: <https://blog.postman.com/give-developers-and-agents-api-access-with-postman-passport/>
> Published: 2026-11-19 16:00:01+00:00

**Key takeaway:** Passport replaces distributed API keys with secret references resolved by a proxy that checks method, host and path, so an agent approved for GET orders.sandbox.example.com/v1/orders/{id} is rejected on POST orders.sandbox.example.com/v1/refunds.

# Give developers and agents API access with Postman Passport

A developer asks their coding agent to investigate a failed order. The agent needs to read order details. Creating a refund would require separate approval.

If you manage API access for the team, you need a way to express that distinction. Which requests should the agent be able to make? Whose access will it use? How will you end that access when the work is done?

Handing over a shared API key can make those decisions harder to enforce. The key may authorize more than the task requires. Once it is in an environment variable or configuration file, the agent and the tools it runs may be able to read it.

With Postman Passport, your team can grant API access without distributing the underlying credential. Consumers send a secret reference. A proxy running in your infrastructure checks their authenticated identity and approved scope, resolves the credential from your secret store, and supplies it to the destination API.

That’s *access without possession*: permission to use an API without receiving its key. Passport also helps you audit developer traffic and flag credentials already being sent by tools and agents.

## Why coding agents make this decision more urgent

An agent can turn one task into a sequence of tool calls, scripts, and network requests. Credentials available to those processes can appear in debug output, generated files, or model context. A malicious instruction is one possible cause; an ordinary troubleshooting step can also expose a value.

In [one developer’s three-week observation of agent traffic](https://blog.postman.com/what-passport-found-in-3-weeks-of-ai-agent-traffic/), Passport detected 22 distinct secrets leaving the laptop. The project’s `.env` file had four entries. Other credentials came from sources such as tool configuration and the operating system’s keychain.

The observation illustrates a practical problem for platform teams: the credentials a workflow uses can extend well beyond the ones you deliberately configured for a task.

## Audit developer traffic and flag detected secrets

Passport’s local traffic inspector, available in the CLI Community Edition, inspects HTTP and HTTPS requests from developer tools, scripts, and coding agents routed through it. When it detects a secret, it flags the request in a browser or terminal dashboard. Findings show the destination, client, time, and secret type, with secret values masked. Headers and URLs are scanned, with optional request-body scanning.

Use those findings to see which tools are sending credentials to which destinations. Review whether that authentication is expected or whether a credential is reaching an unintended service. This gives you a starting point for bringing existing API usage under access control.

Once you’ve identified where credentials are used, you can replace distributed API keys with secret references and approve the operations each consumer needs through Passport’s access-management workflow.

## Approve the API operations an agent needs

Consider a sandbox order service. Its API key supports both reading orders and creating refunds. You want an agent to investigate order status, so you approve use of a secret reference for one endpoint:

`GET orders.sandbox.example.com/v1/orders/{id}`

You don’t approve the refund endpoint. When requests using that reference go through Passport, the proxy checks the method, host, and path before resolving the credential.

| Request using the secret reference | Proxy behavior | 
|---|---|
| `GET orders.sandbox.example.com/v1/orders/123` | Resolves the credential for the approved endpoint and forwards the request | 
| `POST orders.sandbox.example.com/v1/refunds` | Rejects use of the reference for an endpoint outside the approved scope | 

The upstream API receives its usual credential on an approved request. The consumer never needs the actual key to construct that request. For the underlying mechanism, see [how Passport resolves API secrets inside your network](https://blog.postman.com/how-postman-passport-keeps-api-secrets-inside-your-network/).

Choose the scope carefully. An approved read endpoint may still return sensitive data, and a compromised agent could misuse the access it retains. Endpoint restrictions and credential isolation help constrain access; the API’s own authorization and business rules still matter. [OWASP’s guidance on excessive agency](https://genai.owasp.org/llmrisk/llm062025-excessive-agency/) explains why permissions must match the work an agent needs to perform.

## Give an external team access to the same API workflow

The same access decision comes up when a contractor joins a project or an external QA team starts testing it. They need working requests and permission to call the service. Sending the shared key also gives them a credential you’ll later have to account for across their machines and tools.

With Passport, you can make the required endpoints available for access requests. Import them from a Postman Collection, an API specification, a curl request, or a proxy activity export, then map the credentials they require to secret references.

Team members request access, an admin reviews it, and approved consumers call the API using references through the Passport Proxy. A QA engagement might need the order service’s sandbox endpoints for seven days. Production access can be reviewed separately.

This gives the team an explicit workflow for discovering APIs and obtaining permission to use them. The underlying API key doesn’t need to be copied into their shared collection or local environment.

## End access without disrupting other consumers

When an engagement ends, a shared key creates an awkward choice. Keeping it active leaves former consumers with a usable copy. Rotating it can require updates for everyone still using it.

Passport separates a consumer’s approved access from the upstream credential. Revoke the consumer’s grant, then confirm that requests using their reference are denied once revocation takes effect. Other approved consumers can continue using the same underlying key.

Set access duration for the engagement itself. Short-lived certificates and policy bundles support authentication and authorization, but their expiration is separate from the duration of an approved grant.

Key rotation remains necessary when the underlying credential is compromised or your policy requires it. Routine offboarding can be handled through the consumer’s access grant.

## Keep your secret store and add control at request time

Your existing secret store remains the source of the real API credential. Passport adds an access workflow and a proxy that uses the credential on an approved consumer’s behalf.

For a request routed through that proxy:

1. The consumer includes a secret reference where the API expects its credential.
2. The proxy verifies the connection’s authenticated identity and checks whether its scope permits that reference on the requested endpoint.
3. If authorized, the proxy resolves the secret and injects it into the request sent to the destination API.
4. The response returns to the consumer, and the proxy records the request against the authenticated identity.

Secret resolution happens in your infrastructure. The resolved credential goes to the intended API without being delivered to the consumer or Passport Cloud.

Consumers can use the Passport CLI or configure supported external clients to route through the local daemon. Routing and certificate trust need to be configured for the tools you use. The scope checks described here apply to requests that reach the Passport Proxy.

## Evaluate Passport with one API and one consumer

Use the traffic inspector to see which developer tools are sending credentials and where. Then choose a sandbox API whose key is shared among several people or tools. Import its endpoints, map a secret reference, and approve one consumer for a specific operation.

Then verify the access boundary:

1. Send an approved request through Passport and confirm it succeeds.
2. Use the same reference on an endpoint outside the approved scope and confirm the proxy rejects it.
3. Review the request record and confirm which authenticated identity it carries. For an agent, establish whether the connection uses its own identity or its operator’s session.
4. Revoke the grant, repeat the request, and measure when the proxy stops authorizing it.

That exercise gives you a concrete access decision to review with your security team and a working path for the next developer, contractor, or agent that needs the API.

[Open Postman Passport](https://app.usepassport.ai/) to create a namespace and add your first API.
