Prism (Facilitator)

Prism acts as the x402 facilitator — it adds payment enforcement to your HTTP endpoints without you implementing the protocol directly. You configure prices; Prism handles the 402 response, payment verification, and on-chain settlement.

This page covers x402 from the merchant/facilitator perspective. For the buyer/agent side, see Agent Wallet (Buyer Side).

How It Works

A request arrives without a valid payment header
Middleware returns 402 Payment Required with x402Version, accepts, and resource fields
The agent’s wallet pays on-chain and retries with an X-PAYMENT header
Prism’s Spectrum layer verifies the on-chain transfer
If valid, the request proceeds and the transaction hash returns in X-PAYMENT-RESPONSE

Your application code only runs after payment is confirmed.

Integration

You don’t implement the x402 protocol directly — the Prism SDK middleware handles it. You configure what to charge, and the middleware handles the 402 response, payment verification, and settlement automatically. It’s available for TypeScript, Python, and Java frameworks:

import { prismPaymentMiddleware } from "@1stdigital/prism-express";

app.use(
  prismPaymentMiddleware(
    {
      identifyToken: process.env.PRISM_IDENTIFY_TOKEN,
      baseUrl: "https://prism-gw.fd.xyz",
    },
    {
      "/api/premium":     { price: "$0.01", description: "Premium API access" },
      "/api/ai/generate": { price: "$0.50", description: "AI content generation" },
    },
  ),
);

See the Quick Start for a complete example, or the SDK Overview for framework-specific guides.

Payment Requirements (402 Response)

When the middleware returns 402, the response body contains:

Field	Type	Description
`x402Version`	integer	Protocol version (currently `2`)
`error`	string	Human-readable reason, e.g. `"Payment required to access this resource"`
`resource`	object	Describes the gated resource (see below)
`accepts`	array	List of accepted payment options — one entry per chain/token combination
`extensions`	object	Reserved for future protocol extensions; currently `null`

The resource object contains:

Field	Type	Description
`url`	string	Full URL of the resource being protected
`description`	string	Human-readable description of what’s being purchased (nullable)
`mimeType`	string	MIME type of the response once payment is settled (nullable)

Each entry in accepts contains:

Field	Type	Description
`scheme`	string	Payment scheme. Prism emits `"exact"` (EIP-3009 `transferWithAuthorization`)
`network`	string	CAIP-2 chain identifier — e.g. `"eip155:8453"` (Base mainnet), `"eip155:84532"` (Base Sepolia)
`asset`	string	ERC-20 contract address of the settlement token (not a symbol)
`payTo`	string	Spectrum settlement contract address — the `to` field in the EIP-3009 authorization
`amount`	string	Amount in atomic token units (nullable). Example: `"10000"` = $0.01 USDC at 6 decimals
`maxTimeoutSeconds`	integer	Authorization validity window in seconds. Default: `300`
`extra`	object	EIP-712 domain info (nullable). Fields: `name`, `version` — present for tokens like USDC

Payment Verification

When the agent sends a request with the X-PAYMENT header:

Prism parses the signed payment from the header
Forwards it to the Spectrum settlement layer
Spectrum executes the on-chain transfer and verifies: correct amount, correct token, correct recipient, valid signature
If settlement succeeds, the request proceeds and the transaction hash is returned in the X-PAYMENT-RESPONSE header
If settlement fails, the middleware returns 402 with an error

The merchant never needs to verify payments manually — the middleware handles everything between the 402 and the 200.

Pricing Models

Fixed Pricing

Set a static price per endpoint — every request costs the same:

{
  "/api/weather": {
    price: "$0.001",
    description: "Weather data"
  }
}

Tiered Pricing

Different prices for different endpoints:

{
  "/api/basic/*": {
    price: "$0.0001",
    description: "Basic API tier"
  },
  "/api/premium/*": {
    price: "$0.01",
    description: "Premium API tier"
  },
  "/api/ai/generate": {
    price: "$0.50",
    description: "AI generation"
  }
}

Dynamic Pricing

For endpoints where the price depends on the request, apply per-route middleware:

app.get(
  "/api/compute",
  prismPaymentMiddleware(config, {
    "/api/compute": {
      price: calculatePrice(req), // dynamic based on request
      description: "Compute resources",
    },
  }),
  (req, res) => {
    res.json({ result: "Computed" });
  },
);

x402 is an open standard — learn more at x402.org. Prism implements the specification and handles the protocol complexity through the SDK, so you configure prices and the middleware does the rest.

SDK Overview

Framework guides for TypeScript, Python, and Java

x402 Implementation

Both sides of x402: the wallet signs, Prism settles

Getting Started

Concepts

Architecture

Integrations

API Reference

Going to Production

AI Tooling

How It Works

Integration

Payment Requirements (402 Response)

Payment Verification

Pricing Models

Fixed Pricing

Tiered Pricing

Dynamic Pricing

SDK Overview

x402 Implementation

​How It Works

​Integration

​Payment Requirements (402 Response)

​Payment Verification

​Pricing Models

​Fixed Pricing

​Tiered Pricing

​Dynamic Pricing

SDK Overview

x402 Implementation

How It Works

Integration

Payment Requirements (402 Response)

Payment Verification

Pricing Models

Fixed Pricing

Tiered Pricing

Dynamic Pricing