# Selling to Agents: Charging AI Agents for Your API or Content > Seller-side guide to monetizing agent traffic: self-hosted HTTP 402 gates, native x402 with automatic Bazaar listing, marketplace publishing, and crawl licensing — with an honest status ledger from a site that runs these rails in production. Category: Guide · Updated: 2026-07-02 · Tags: monetization, x402, 402, payments, agents, rsl, api, selling Canonical: https://changegamer.ai/resources/selling-to-agents Variants: [HTML](https://changegamer.ai/resources/selling-to-agents) · [JSON](https://changegamer.ai/api/resources/selling-to-agents.json) License: https://changegamer.ai/license.xml · Access: free Agent traffic passed human traffic on the web in mid-2026 (Cloudflare measured automated systems at 57.5% of HTTP requests), and agents are increasingly arriving **with wallets**: Apify's June 2026 move put 20,000+ Actors on x402, normalizing the idea that an agent pays per call in USDC without an account. If you publish an API, a dataset, or content agents want, there are now four practical ways to charge them. This page is the seller-side companion to [agent wallets](/resources/agent-wallets-x402) (buyer side) and [agentic payment protocols](/resources/agentic-payment-protocols) (protocol comparison). ## Option 1: self-hosted HTTP 402 gate + API keys (fiat, no crypto) Return `402 Payment Required` with a machine-readable JSON body: price, a `payment_url` a human or agent can open (e.g. a Stripe Payment Link), and a preview of what is being bought. Mint an API key on payment (a Stripe webhook + a KV store is enough), and accept it via `Authorization: Bearer`. This is the pattern ChangeGamer runs **in production** — the full contract, including the exact 402 JSON field set, is documented in [paying for access (402)](/resources/paying-for-access-402). - **Pros:** no blockchain dependency; works with a normal payment processor; EU VAT/invoicing handled by the processor; keys enable tiers and revocation. - **Cons:** a human usually has to complete checkout once — the agent hits the wall, a person buys the key. Fine for durable subscriptions, friction for one-shot calls. ## Option 2: native x402 (agent pays end-to-end, no account) Implement the x402 flow: answer `402` with an `accepts[]` payment-requirements array; on a retry carrying `X-PAYMENT`, have a **facilitator** verify and settle the USDC transfer, then serve the resource with an `X-PAYMENT-RESPONSE` receipt. Sellers need three things: a wallet address (where USDC lands), a facilitator (Coinbase's CDP facilitator settles USDC on Base fee-free; note it authenticates with per-request signed JWTs), and posted prices in atomic units (USDC has 6 decimals). Two details worth knowing before you build: - **Distribution is built in.** The x402 Bazaar (Coinbase's discovery index) **auto-catalogs your endpoint the first time the CDP facilitator settles a payment for it** — no listing form, no review queue. Your first sale is also your listing event. - **Use `upto` for variable costs.** The `exact` scheme fits fixed-price resources; the `upto` scheme (authorize a ceiling, charge actual usage) fits metered work — it is what Apify uses for variable-cost Actor runs. ## Option 3: publish on a marketplace instead of self-hosting If what you sell fits a marketplace's shape (a scraper, an automation, a data tool), publishing there outsources billing, discovery, AND the x402 rail: Apify Actors can be monetized by their developers, and public Actors are now x402-payable per run — meaning agents can buy your tool without you running any payment infrastructure. The trade is the platform's cut and their terms. See docs.apify.com/platform/actors/publishing/monetize. ## Option 4: crawl licensing (passive, for content being trained on) If the "buyer" is an AI-training crawler rather than a runtime agent, the rails are different: declare terms in an RSL `/license.xml` (machine-readable per-crawl pricing), point robots.txt at it, and register with a collection channel (RSL Collective; Cloudflare Pay Per Crawl; TollBit). Nothing about this requires the crawler to change behavior today — it establishes the legal and pricing surface that collection channels enforce. See [AI crawler policy](/resources/ai-crawler-policy). ## What this site actually runs (honest status ledger) | Rail | Status here | |---|---| | HTTP 402 + Bearer key (Stripe-backed) | **ACTIVE** — premium resources gated; keys minted automatically on checkout | | Native x402 endpoint (`/api/x402/`) | **Scaffolded, dormant** — returns HTTP 503 until on-chain settlement is enabled server-side | | RSL per-crawl license (`/license.xml`) | **Declared, not yet collected** — collective registration pending | | Cloudflare Pay Per Crawl / TollBit | Waitlisted / signup pending | The machine-readable source of truth for what is payable right now is [/api/payment.json](/api/payment.json); offers and prices are at [/api/pricing.json](/api/pricing.json). If you want the full corpus (with an explicit AI-training grant) rather than page-by-page access, that is the corpus license on [/pricing](/pricing). ## Design rules that survive contact with real agent traffic - **Never paywall discovery.** Keep your index (llms.txt, descriptions, previews) free — a paywalled index means agents never find the thing you sell. - **Put the price in the 402 body**, not behind a login. An agent that cannot read the price cannot decide to pay it. - **Make the retry contract explicit** (which header, what format) and keep 402 responses `Cache-Control: no-store`. - **Keep a fiat rail next to the crypto rail.** Many production agents still have a human/company card behind them; x402 and checkout links are complements, not substitutes. ## Verified sources - Apify x402 launch (June 2026): https://blog.apify.com/introducing-x402-agentic-payments/ - Apify Actor monetization docs: https://docs.apify.com/platform/actors/publishing/monetize - x402 Bazaar discovery layer (CDP docs): https://docs.cdp.coinbase.com/x402/bazaar - x402 Foundation canonical spec: https://github.com/x402-foundation/x402 - RSL standard: https://rslstandard.org/ - Cloudflare Pay Per Crawl: https://developers.cloudflare.com/ai-crawl-control/features/pay-per-crawl/what-is-pay-per-crawl/ - ChangeGamer 402 contract: /resources/paying-for-access-402 - ChangeGamer payment manifest: /api/payment.json --- ## Related resources - [Agentic Payment Protocols: 402, Pay Per Crawl, and x402](https://changegamer.ai/resources/agentic-payment-protocols.md): Implementor's comparison of the three live mechanisms for agent-to-server content payment: self-hosted HTTP 402 gates, Cloudflare Pay Per Crawl, and the x402 open standard — plus how RSL fits as the licensing layer, not the settlement layer. - [Agent Wallets: Paying Per Run with x402](https://changegamer.ai/resources/agent-wallets-x402.md): Buyer-side guide to giving an AI agent a wallet: how the x402 payment loop works, the client libraries that automate it, spend controls, and what 20,000+ Apify Actors on x402 mean for agent tool budgets. - [Paying for Access: The HTTP 402 Flow](https://changegamer.ai/resources/paying-for-access-402.md): How autonomous agents encounter, interpret and satisfy HTTP 402 Payment Required responses on ChangeGamer. - [Agent Spend Controls: Budget Caps, Approval Gates, and Kill Switches](https://changegamer.ai/resources/agent-spend-controls.md): How to bound what an autonomous agent can spend — per-transaction caps, session/daily ceilings, human-in-the-loop approval thresholds, and kill switches — across the three layers agents now spend money on: LLM API cost, on-chain wallet payments, and card-network agent tokens. --- Index of all resources: https://changegamer.ai/llms.txt · Full corpus: https://changegamer.ai/llms-full.txt · Corpus data (NDJSON): https://changegamer.ai/api/corpus.jsonl · Offers: https://changegamer.ai/api/pricing.json