Explainer · agentic payments
P3P turns HTTP 402 into a mandate-backed payment flow for AI agents.
Pine Labs Payments Protocol, or P3P, is an HTTP-native agent-payment protocol designed so AI agents can discover a paid resource, receive a payment challenge, act within delegated user authority, retry with a payment credential and receive a verifiable receipt. The important distinction is that P3P uses HTTP 402, but it is not the same protocol as x402.
Published 12 September 2026 · current Pine Labs documentation and rollout evidence checked before publication
11 Jun 2026
Pine Labs announced P3P for autonomous agent payments
HTTP 402
Paid-resource challenge pattern used by the current P3P quickstart
3 live modes
OTM, UPI ReservePay and cards in current developer documentation
What P3P solves
The human approves a bounded mandate first; the agent can transact later
A conventional checkout often assumes a person will appear at the payment step to authenticate the transaction. That assumption breaks autonomous commerce. P3P instead puts user consent into a mandate and delegated authorization layer before the paid request is executed.
Pine Labs' current protocol documentation describes a standard HTTP flow: an agent calls a protected resource, receives an HTTP 402 challenge, creates a scoped payment credential, retries the request, and receives a payment receipt after the server captures the payment. Client and server SDKs handle the challenge, token, retry, capture and receipt mechanics.
The authorization layer is deliberately separate from the payment rail. Pine Labs pairs P3P with Grantex for delegated identity, spend controls and auditability, while the underlying payment method can be UPI ReservePay, a One Time Mandate or cards according to the current developer documentation.
Payment lifecycle
The useful P3P state machine is challenge → authority → capture → receipt
1. Mandate
The user establishes a bounded payment mandate and delegated authority before autonomous spending begins.
2. Paid request
The agent requests a protected resource or transaction endpoint using ordinary HTTP.
3. 402 challenge
The server returns machine-readable payment requirements instead of redirecting to a human checkout page.
4. P3P credential
The client creates a payment credential tied to the authorized payment context and retries the request.
5. Capture
The server verifies the credential and executes the authorized debit/capture on the configured payment rail.
6. Receipt + delivery
The completed interaction returns payment evidence; the commercial workflow must also expose the actual resource, booking or fulfilment result.
P3P vs x402 vs MCP
Sharing HTTP 402 does not make two payment protocols interchangeable
| Surface | Primary contract | What it standardizes | Payment / settlement layer |
|---|---|---|---|
| P3P | Agent ↔ paid resource | HTTP 402 challenge, delegated mandate, P3P payment credential, capture and receipt | UPI ReservePay, OTM and cards in current Pine Labs docs |
| x402 | Client/agent ↔ paid HTTP resource | Machine-readable payment requirements and settlement proof | Separate x402 protocol ecosystem and supported settlement rails |
| MCP | Model/runtime ↔ tool | Tool discovery, schemas, resources and invocation | Not a payment rail by itself |
| UPI ReservePay | User mandate ↔ underlying payment rail | Pre-authorized funds that can support later bounded debits | Underlying authorization/funding primitive rather than an agent protocol |
HTTP 402 is a status code; the protocol around it determines what an agent can actually parse, authorize and settle. P3P's current quickstart uses its own credential and receipt lifecycle. x402 has its own payment-requirement and settlement semantics. MCP can expose either system as a tool, but MCP does not itself settle the payment.
Builder checklist
Six controls matter more than merely returning a 402
Put consent before autonomy
Create the user mandate and delegated authority before an agent reaches a paid resource. A payment protocol should execute inside an existing permission envelope, not invent permission at checkout.
Bind every payment to the intended resource
Keep amount, resource, expiry and authorization scope explicit. Pine Labs describes P3P payment tokens as bounded so they cannot simply be replayed or redirected to another purchase.
Make retries idempotent
A network retry must not become a second capture. Persist request, order and payment identifiers so the agent can reconcile an ambiguous timeout before spending again.
Keep merchant credentials server-side
Pine Labs' SDK guidance explicitly warns against exposing trusted merchant credentials in browser code. Agent convenience does not remove ordinary secret-management boundaries.
Separate payment evidence from delivery evidence
A verifiable receipt can prove a payment state. The agent still needs a machine-readable product, booking, API result or fulfilment state before it can conclude the commercial task succeeded.
Measure real buyer progression
Do not treat 402 probes, crawler hits, schema validation or directory checks as demand. Track qualified discovery, payment authorization, delivery and repeat use as separate states.
zFinia interpretation
Agent-payment protocols are differentiating by authority model and settlement rail, not converging on one universal stack
P3P is strategically interesting because it combines an HTTP-native paid-resource flow with payment infrastructure already familiar to Indian consumers and merchants. The practical selection question for an autonomous buyer is therefore not “which protocol won?” but “which protocol is supported by this seller, which authority does it require, which rail actually moves value, and what receipt proves the result?”
Sources
Pine Labs — P3P overview — protocol roles, delegated authorization, payment methods and receipt model.
Pine Labs — P3P quickstart — current HTTP 402, credential, retry and mandate flow.
Pine Labs — P3P SDKs — client/server mechanics and server-side credential guidance.
Pine Labs — P3P launch, 11 June 2026 — launch architecture and the role of Grantex and UPI mandates.
L&T Finance / Pine Labs partnership coverage — September 2026 Agentic Storefront and autonomous flight-booking rollout.