{ "slug": "packaging-a-corpus-as-a-product", "title": "Packaging a Corpus as a Product: Format, Schema, Versioning and Delivery", "description": "The packaging decisions behind selling a content corpus as a dataset product — export format, the free-sample/gated-full split, a per-record metadata schema, a corpus version number, and which of three delivery mechanisms to use — grounded in ChangeGamer's own three real export formats.", "kind": "sub", "order": 9, "target_query": "how to package content as a dataset product", "secondary_queries": [ "corpus export format for RAG and fine-tuning", "versioning a dataset product", "how to deliver a licensed content corpus to buyers", "NDJSON vs full-text dump for a dataset export" ], "tags": [ "corpus", "packaging", "ndjson", "versioning", "delivery", "monetization", "agents" ], "published": "2026-08-04", "updated": "2026-08-04", "words": 1622, "premium": false, "license": "https://changegamer.ai/license.xml", "canonical": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product", "markdown": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product.md", "takeaways": [ "A dataset product needs at least two export shapes, not one: a line-delimited record format for RAG/fine-tuning ingestion (NDJSON) and, if the buyer is meant to fine-tune directly, a chat-message format matching a training API's expected schema — a single flat text dump satisfies neither use case well.", "The honest way to run a free sample next to a gated full export is field-level asymmetry, not a shorter file: ChangeGamer's free `/api/corpus.jsonl` nulls out premium record bodies and adds an `access` pointer object only to those null records, while the gated `/api/corpus.full.jsonl` always populates `text` and never carries an `access` field at all — the sample and the product are structurally different files, not the same file truncated.", "A corpus version number and an MCP server version number answer different questions and should not be kept in lockstep: one tracks whether the content/schema changed, the other tracks the server manifest, and forcing them to match creates false-positive re-pull signals for a buyer who only cares about the first.", "A per-record JSON Schema is what lets a buyer validate an export programmatically instead of reverse-engineering field shapes from a sample — ChangeGamer publishes one at `/api/corpus.schema.json`, derived live from the same source data it describes so the two cannot drift apart.", "Pull endpoint, emailed file, and MCP tool are three delivery mechanisms with genuinely different latency and trust profiles, and a dataset seller should offer more than one rather than picking whichever is easiest to build first." ], "outline": [ { "depth": 2, "text": "Pick a format for what the buyer will actually do with it", "anchor": "pick-a-format-for-what-the-buyer-will-actually-do-with-it", "url": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product#pick-a-format-for-what-the-buyer-will-actually-do-with-it" }, { "depth": 2, "text": "The sample/full split is a field-level contract, not a shorter file", "anchor": "the-sample-full-split-is-a-field-level-contract-not-a-shorter-file", "url": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product#the-sample-full-split-is-a-field-level-contract-not-a-shorter-file" }, { "depth": 2, "text": "A schema per record, published, not implied", "anchor": "a-schema-per-record-published-not-implied", "url": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product#a-schema-per-record-published-not-implied" }, { "depth": 2, "text": "Versioning: one number for content, a different one for the server", "anchor": "versioning-one-number-for-content-a-different-one-for-the-server", "url": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product#versioning-one-number-for-content-a-different-one-for-the-server" }, { "depth": 2, "text": "Freshness is a version comparison, not a file timestamp", "anchor": "freshness-is-a-version-comparison-not-a-file-timestamp", "url": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product#freshness-is-a-version-comparison-not-a-file-timestamp" }, { "depth": 2, "text": "Three delivery mechanisms, three different tradeoffs", "anchor": "three-delivery-mechanisms-three-different-tradeoffs", "url": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product#three-delivery-mechanisms-three-different-tradeoffs" }, { "depth": 2, "text": "What this means for packaging your own corpus", "anchor": "what-this-means-for-packaging-your-own-corpus", "url": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product#what-this-means-for-packaging-your-own-corpus" } ], "faq": [ { "question": "What format should I export a content corpus in for RAG or fine-tuning buyers?", "answer": "Ship newline-delimited JSON (NDJSON) as the default, and add a chat-message JSONL export only if you specifically want to demonstrate or enable direct fine-tuning. ChangeGamer runs exactly this split: `/api/corpus.jsonl` and `/api/corpus.full.jsonl` are NDJSON, one JSON object per line, which streams straight into a vector store or a training job without a top-level array to parse; `/api/finetune-sample.jsonl` is a separate export in the `{\"messages\": [...]}` chat format that most fine-tuning APIs expect natively. A single full-text dump (all content concatenated into one document, ChangeGamer's pattern for that is `/llms-full.txt`, covered in [llms.txt vs. robots.txt vs. sitemap.xml](/articles/llms-txt-vs-robots-txt-vs-sitemap)) is fine for a one-shot context load but is the wrong shape for either streaming ingestion or fine-tuning." }, { "question": "How should a free sample of a corpus differ from the paid full version?", "answer": "By withholding specific field values, not by shipping fewer records or a shorter file. ChangeGamer's free `/api/corpus.jsonl` includes every resource record, with free-resource bodies in full and premium-resource bodies set to `text: null` plus an `access` object naming exactly how to unlock that record. The paid `/api/corpus.full.jsonl` has the identical record count and shape, but `text` is always a populated string and the `access` field is absent entirely — a buyer's schema validator should reject a sample record whose `premium` is `true` and `text` is a non-null string, since that record came from the wrong endpoint." }, { "question": "Should a corpus version number match my MCP server's version number?", "answer": "No — keep them independent. ChangeGamer's `CORPUS_VERSION` constant is a manually-bumped semver stamp for the content and schema of the corpus itself, explicitly documented in code as something that must not be kept in lockstep with the MCP server manifest's own `version` / `serverInfo.version` field, because the two track different things: one is \"did the data or its shape change,\" the other is \"did the server implementation change.\" A buyer polling your corpus version for a re-pull decision does not want that signal firing because you shipped an unrelated server update." }, { "question": "How does a buyer know when to re-pull a corpus they already licensed?", "answer": "By comparing a version number, not a file date. ChangeGamer surfaces a live `corpus_version` field in `/api/stats.json` and on the public `/changelog` page; every corpus export (`/api/corpus.jsonl`, `/api/corpus.full.jsonl`) stamps the version it was built from in its own header record, so a keyed buyer can compare their held copy's version against the live one and re-pull only when it is higher. Annual-subscription buyers get this handled for them — the full corpus file is re-sent automatically at each renewal — while one-time-license buyers hold a point-in-time snapshot and must re-pull manually to get anything shipped after their purchase." } ], "body": "Once a corpus has a license and a price, someone still has to decide what file format ships, how the free preview differs from the paid deliverable, how a buyer validates what they received, how version changes get signaled, and how the file reaches them. Those are packaging decisions, not legal or pricing ones — this article sits inside [how to sell to AI agents](/articles/selling-to-ai-agents), the pillar for this cluster, and covers the mechanics of shipping a corpus once the legal and pricing decisions are made elsewhere. It does not cover licensing terms (see [licensing content for AI training](/articles/licensing-content-for-ai-training)) or tier-pricing design (see [pricing tiers for machine buyers](/articles/pricing-tiers-for-machine-buyers)).\n\n## Pick a format for what the buyer will actually do with it\n\nThe right export format follows from the buyer's pipeline, not from whichever is easiest to generate, and one corpus product often needs more than one shape. ChangeGamer ships three:\n\n- **NDJSON (newline-delimited JSON)** — `/api/corpus.jsonl` and its gated counterpart `/api/corpus.full.jsonl`. One JSON object per line, no enclosing array, so a consumer can stream it line-by-line straight into a vector-store indexer or a training job without loading the whole file into memory first. This is the standard shape for RAG ingestion and bulk fine-tuning data.\n- **A full-text dump** — ChangeGamer's version of this is `/llms-full.txt`, the whole free corpus concatenated into one document (covered in full in [llms.txt vs. robots.txt vs. sitemap.xml](/articles/llms-txt-vs-robots-txt-vs-sitemap)). It is the right shape for a single context-window load — \"give me everything in one fetch\" — and the wrong shape for streaming ingestion or per-record processing, since there is no record boundary a parser can rely on beyond markdown headings.\n- **A chat-format supervised-fine-tuning (SFT) export** — `/api/finetune-sample.jsonl`, one `{\"messages\": [{\"role\": \"system\", ...}, {\"role\": \"user\", ...}, {\"role\": \"assistant\", ...}]}` object per line, the shape most fine-tuning APIs expect natively. It is a different transformation of the same data, not a reformatted NDJSON line: ChangeGamer derives up to three training-example types per resource (an \"explain\" example, a one-sentence \"summarize\" example, and a \"key facts\" example built from that resource's own `## Key facts` bullets).\n\nWorth naming precisely because it is easy to get backwards: `/api/finetune-sample.jsonl` is always free and excludes every premium resource from all three task types — it is not a gated Corpus-tier deliverable, and it never becomes \"the paid version\" at any tier. It exists to demonstrate the corpus *as training data* using only what is already free, so a buyer can evaluate the shape of the paid product without a key.\n\n## The sample/full split is a field-level contract, not a shorter file\n\nA free sample and a gated full export should have the identical record set and shape, differing only in which field values are populated — not a shorter file with fewer records. ChangeGamer's two NDJSON exports demonstrate the pattern exactly:\n\n| Field | `/api/corpus.jsonl` (free sample) | `/api/corpus.full.jsonl` (gated) |\n|---|---|---|\n| `text` | `null` for premium records, full body for free records | Always a populated string, for every record |\n| `access` | Present only on premium records (null-`text` ones) | Never present, on any record |\n| `sources` | Present on every record, including premium/stubbed ones | Present on every record |\n| `premium` | Present on every record | Present on every record |\n\nThe `access` object is the load-bearing detail: an inline pointer — `reason`, `unlock_with_key`, `key_offer`, `checkout_url`, `offer_catalog`, `payment_manifest` — so an agent hitting a null-`text` record knows exactly how to unlock it without a second discovery hop. `sources` (citation URLs from each resource's own \"Verified sources\" section) is deliberately populated on both files, even on stubbed premium records, because it is metadata about the resource, not paywalled content — a useful line for any seller deciding what belongs in a free sample: content is gated, metadata about the content generally is not.\n\n## A schema per record, published, not implied\n\nA buyer should be able to validate a dataset export against a published schema instead of inferring field shapes from whatever sample they happen to have. ChangeGamer publishes `/api/corpus.schema.json`, a JSON Schema (draft 2020-12) covering both record types in its NDJSON exports: a `meta` record (always the first line — `site`, `url`, `description`, `corpus_version`, `count`, `note`, `license`) and a `resource` record (every subsequent line — `record`, `url`, `slug`, `title`, `description`, `category`, `tags`, `updated`, `premium`, `text`, plus the conditional `access` and always-present `sources` fields above). The schema's `category` enum is derived live from the actual resource data at build time rather than hand-maintained — a schema that can silently drift from the data it describes is worse than no schema, since it fails the one job (catching a malformed export) that justifies publishing it.\n\n## Versioning: one number for content, a different one for the server\n\nA corpus needs its own version number, independent of any API-server or MCP-manifest version, because the two answer different questions for a buyer. ChangeGamer maintains `CORPUS_VERSION` as a manually-bumped semver string, currently `1.12.11`: **MAJOR** for a breaking schema change (a stats or record field renamed or removed), **MINOR** for a resource added or removed, or a new additive field, **PATCH** for a content-only edit with no count change. That number is stamped into every corpus export's header and into `/api/stats.json`'s `corpus_version` field, and is explicitly documented as something that must **not** track the MCP server manifest's own version field — the corpus number tracks content and schema, the server number tracks server-implementation changes, and conflating them would fire a buyer's re-pull check on changes unrelated to the data they licensed. If your dataset product and API server ship from one repository, resist giving them one version number: a buyer polling for freshness wants to know one thing, did the data change.\n\n## Freshness is a version comparison, not a file timestamp\n\nTell a buyer to compare corpus version numbers, not to eyeball a last-modified date, because a version bump is a deliberate signal and a file timestamp is not. ChangeGamer's per-record `updated` date is scoped narrowly — bumped only on a genuinely re-verified content delta, not a structural or formatting change — so it is a record-level signal, while `corpus_version` is the corpus-level one: every export header carries the version it was built from, and a keyed buyer compares that stamped number against the live value in `/api/stats.json` (also shown on the public `/changelog` page) to decide whether to re-pull.\n\nWhat \"re-pull\" means also depends on which tier a buyer is on — a genuine point-in-time-versus-standing-subscription distinction, not a technicality. Per [access and pricing for crawlers](/resources/access-and-pricing), ChangeGamer's one-time Corpus and Enterprise licenses deliver a snapshot — the license grant covers the version delivered at purchase, and getting anything shipped afterward means fetching `/api/corpus.full.jsonl` again with the same key. The annual Corpus Updates subscription instead re-sends the full corpus file at every renewal, always reflecting whatever is current at that date, with re-delivery performed manually by the operator rather than automatically. Choosing between a one-time license and a subscription is, in large part, choosing who is responsible for noticing a re-pull is due — the buyer, or the seller's own renewal process.\n\n## Three delivery mechanisms, three different tradeoffs\n\nOffer more than one delivery mechanism: \"pull,\" \"push,\" and \"agent-native tool call\" solve for different combinations of latency and trust. ChangeGamer runs all three for the same corpus file, per [access and pricing for crawlers](/resources/access-and-pricing):\n\n- **Pull endpoint** — `GET /api/corpus.full.jsonl` with `Authorization: Bearer `. Immediate: a keyed buyer fetches the current full corpus the moment they want it, no wait, no human in the loop. The tradeoff is that it assumes machine-to-machine trust already exists via the key itself, and requires an HTTP client capable of the fetch.\n- **Emailed file** — the full `llms-full.txt` corpus file sent to the checkout email address within one business day of purchase, and re-sent at each annual renewal. Slower by design: it routes through a human-verified email address rather than an API key alone, which matters for a buyer who wants a durable, addressable record of what they were sent and when, independent of whether their key is later lost or revoked.\n- **MCP tool call** — `get_full_corpus(api_key)`, exposed on ChangeGamer's `/mcp` server. Same immediate latency as the pull endpoint, but reachable as a typed tool call from inside an agent's own MCP client rather than a raw HTTP fetch its operator has to wire up separately — the difference here is discoverability inside an agent's existing toolset, not trust or speed.\n\nNone of the three replaces the others: the pull endpoint and the MCP tool serve an agent that already has a key and wants current data now; the emailed file serves the human on the other end of the purchase who wants a dated, addressable copy independent of key lifecycle. A seller who only builds whichever is easiest to implement is choosing a trust or latency profile by accident, not by design.\n\n## What this means for packaging your own corpus\n\nDecide the export format from the buyer's pipeline first — NDJSON for streaming ingestion, a chat-format JSONL for fine-tuning, a full-text dump only for one-shot context loads — and ship more than one if buyers need more than one job done. If you run a free sample next to a paid full export, make the difference specific withheld field values on an identical record set, not a shorter file, with an actionable unlock pointer left in place of each withheld value. Publish a schema for the record shape, derived from live data so it cannot drift. Version corpus content independently from server or manifest version. And offer more than one delivery mechanism if your buyers mix machines that want to pull now with humans who want a dated, addressable copy.", "cluster": { "id": "selling-to-agents", "title": "Selling to AI agents", "description": "How to sell content, APIs and tools to buyers that are software — discovery, machine-readable offers, spend ceilings, payment rails, and what breaks.", "status": "complete", "pillar": { "slug": "selling-to-ai-agents", "title": "How to Sell to AI Agents: The Complete Guide to Machine Buyers", "description": "The operator playbook for selling content, APIs and tools to buyers that are software: how agents discover, evaluate, authorize and pay — and the four rails you can charge them on today.", "kind": "pillar", "order": 0, "html": "https://changegamer.ai/articles/selling-to-ai-agents", "markdown": "https://changegamer.ai/articles/selling-to-ai-agents.md", "json": "https://changegamer.ai/api/articles/selling-to-ai-agents.json" }, "articles": [ { "slug": "agent-checkout-vs-human-checkout", "title": "Agent Checkout vs. Human Checkout: Why Your Payment Flow Fails Machine Buyers", "description": "Why checkout built for a person watching a screen is unusable by an AI agent, and what a checkout flow that actually completes for a machine buyer looks like — 402 + API key versus native x402.", "kind": "sub", "order": 1, "html": "https://changegamer.ai/articles/agent-checkout-vs-human-checkout", "markdown": "https://changegamer.ai/articles/agent-checkout-vs-human-checkout.md", "json": "https://changegamer.ai/api/articles/agent-checkout-vs-human-checkout.json" }, { "slug": "machine-readable-pricing-pages", "title": "Machine-Readable Pricing Pages: How to Let an Agent Evaluate Your Offer Before It Pays", "description": "Why a prose pricing page cannot be evaluated by an AI agent, what fields a machine-readable offer catalog needs, and how to keep it in lockstep with your human pricing page and your 402 body.", "kind": "sub", "order": 2, "html": "https://changegamer.ai/articles/machine-readable-pricing-pages", "markdown": "https://changegamer.ai/articles/machine-readable-pricing-pages.md", "json": "https://changegamer.ai/api/articles/machine-readable-pricing-pages.json" }, { "slug": "acp-vs-ap2-vs-x402", "title": "ACP vs. AP2 vs. x402: Which Agent Payment Rail Should You Implement?", "description": "A decision framework for choosing between ACP, AP2, and x402 (plus the self-hosted 402 gate) — sorted by who your buyer actually is, what you are selling, and what is live versus waitlisted today.", "kind": "sub", "order": 3, "html": "https://changegamer.ai/articles/acp-vs-ap2-vs-x402", "markdown": "https://changegamer.ai/articles/acp-vs-ap2-vs-x402.md", "json": "https://changegamer.ai/api/articles/acp-vs-ap2-vs-x402.json" }, { "slug": "accepting-x402-payments", "title": "How to Accept x402 Stablecoin Payments: A Seller Implementation Guide", "description": "A build guide for sellers who have already decided x402 is the right rail: the 402 response shape, the wallet/facilitator/network choices, the verify-then-settle retry flow, exact vs. upto pricing, and how to ship it dormant until you are ready to go live.", "kind": "sub", "order": 4, "html": "https://changegamer.ai/articles/accepting-x402-payments", "markdown": "https://changegamer.ai/articles/accepting-x402-payments.md", "json": "https://changegamer.ai/api/articles/accepting-x402-payments.json" }, { "slug": "api-key-issuance-for-agents", "title": "Issuing API Keys to AI Agents Automatically: A Build Guide", "description": "How to design a system that mints and delivers API keys to agent and software buyers with minimal human friction: trigger models, storage, delivery, key format, tiering, rotation and revocation — illustrated with ChangeGamer's own Stripe-webhook mechanism.", "kind": "sub", "order": 5, "html": "https://changegamer.ai/articles/api-key-issuance-for-agents", "markdown": "https://changegamer.ai/articles/api-key-issuance-for-agents.md", "json": "https://changegamer.ai/api/articles/api-key-issuance-for-agents.json" }, { "slug": "pricing-tiers-for-machine-buyers", "title": "Pricing Tiers for API and Corpus Access: What Actually Varies Between Them", "description": "The axes that actually distinguish one pricing tier from another for a machine buyer — rate limits, content scope, deliverables and license grant — and how ChangeGamer structures its own four tiers around deliverable and license, not gated content.", "kind": "sub", "order": 6, "html": "https://changegamer.ai/articles/pricing-tiers-for-machine-buyers", "markdown": "https://changegamer.ai/articles/pricing-tiers-for-machine-buyers.md", "json": "https://changegamer.ai/api/articles/pricing-tiers-for-machine-buyers.json" }, { "slug": "agent-spend-limits-and-trust", "title": "Agent Spend Limits and Trust: What a Seller Should Verify Before Granting Access", "description": "The seller-side counterpart to agent spend controls — how an API operator reads an inbound agent's spend ceiling before granting access, which payment protocols actually prove that ceiling, how to revoke access, and what \"trust\" operationally means for a seller when no portable agent-reputation standard exists yet.", "kind": "sub", "order": 7, "html": "https://changegamer.ai/articles/agent-spend-limits-and-trust", "markdown": "https://changegamer.ai/articles/agent-spend-limits-and-trust.md", "json": "https://changegamer.ai/api/articles/agent-spend-limits-and-trust.json" }, { "slug": "refunds-and-disputes-with-agent-buyers", "title": "Refunds and Disputes with Agent Buyers: What a Seller Actually Does", "description": "What happens on the seller side when an autonomous agent's purchase needs to be reversed or is disputed — API-key refund mechanics, why x402 settlement cannot be undone, what card-token revocation does and does not prove, and what to log before you reverse anything.", "kind": "sub", "order": 8, "html": "https://changegamer.ai/articles/refunds-and-disputes-with-agent-buyers", "markdown": "https://changegamer.ai/articles/refunds-and-disputes-with-agent-buyers.md", "json": "https://changegamer.ai/api/articles/refunds-and-disputes-with-agent-buyers.json" }, { "slug": "packaging-a-corpus-as-a-product", "title": "Packaging a Corpus as a Product: Format, Schema, Versioning and Delivery", "description": "The packaging decisions behind selling a content corpus as a dataset product — export format, the free-sample/gated-full split, a per-record metadata schema, a corpus version number, and which of three delivery mechanisms to use — grounded in ChangeGamer's own three real export formats.", "kind": "sub", "order": 9, "html": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product", "markdown": "https://changegamer.ai/articles/packaging-a-corpus-as-a-product.md", "json": "https://changegamer.ai/api/articles/packaging-a-corpus-as-a-product.json" }, { "slug": "discoverability-for-paid-agent-apis", "title": "How Do AI Agents Discover Paid APIs? A Guide to Every Surface", "description": "How an AI agent finds out a paid API or resource exists before it ever reads a price: llms.txt, the JSON API index, MCP registries, incidental 402 discovery, x402 auto-listing, and what .well-known does and does not cover.", "kind": "sub", "order": 10, "html": "https://changegamer.ai/articles/discoverability-for-paid-agent-apis", "markdown": "https://changegamer.ai/articles/discoverability-for-paid-agent-apis.md", "json": "https://changegamer.ai/api/articles/discoverability-for-paid-agent-apis.json" }, { "slug": "fraud-and-abuse-from-agent-traffic", "title": "Fraud and Abuse from AI Agent Traffic: What a Seller Should Detect", "description": "How a seller of APIs, content, or tools to AI agents spots and mitigates abuse once access is already granted — key sharing, over-scope scraping, spend-ceiling circumvention, spoofed identity, and rate-limit evasion patterns specific to autonomous agents.", "kind": "sub", "order": 11, "html": "https://changegamer.ai/articles/fraud-and-abuse-from-agent-traffic", "markdown": "https://changegamer.ai/articles/fraud-and-abuse-from-agent-traffic.md", "json": "https://changegamer.ai/api/articles/fraud-and-abuse-from-agent-traffic.json" }, { "slug": "measuring-agent-revenue", "title": "Measuring Revenue from AI Agent Traffic: Beyond the Traffic Log", "description": "The revenue-layer fields and queries a seller adds on top of a general traffic log — authorized-vs-settled, revenue per rail, revenue per tier, and how to avoid double-counting a webhook retry as two sales.", "kind": "sub", "order": 12, "html": "https://changegamer.ai/articles/measuring-agent-revenue", "markdown": "https://changegamer.ai/articles/measuring-agent-revenue.md", "json": "https://changegamer.ai/api/articles/measuring-agent-revenue.json" } ] }, "navigation": { "pillar": { "slug": "selling-to-ai-agents", "title": "How to Sell to AI Agents: The Complete Guide to Machine Buyers", "description": "The operator playbook for selling content, APIs and tools to buyers that are software: how agents discover, evaluate, authorize and pay — and the four rails you can charge them on today.", "kind": "pillar", "order": 0, "html": "https://changegamer.ai/articles/selling-to-ai-agents", "markdown": "https://changegamer.ai/articles/selling-to-ai-agents.md", "json": "https://changegamer.ai/api/articles/selling-to-ai-agents.json" }, "previous": { "slug": "refunds-and-disputes-with-agent-buyers", "title": "Refunds and Disputes with Agent Buyers: What a Seller Actually Does", "description": "What happens on the seller side when an autonomous agent's purchase needs to be reversed or is disputed — API-key refund mechanics, why x402 settlement cannot be undone, what card-token revocation does and does not prove, and what to log before you reverse anything.", "kind": "sub", "order": 8, "html": "https://changegamer.ai/articles/refunds-and-disputes-with-agent-buyers", "markdown": "https://changegamer.ai/articles/refunds-and-disputes-with-agent-buyers.md", "json": "https://changegamer.ai/api/articles/refunds-and-disputes-with-agent-buyers.json" }, "next": { "slug": "discoverability-for-paid-agent-apis", "title": "How Do AI Agents Discover Paid APIs? A Guide to Every Surface", "description": "How an AI agent finds out a paid API or resource exists before it ever reads a price: llms.txt, the JSON API index, MCP registries, incidental 402 discovery, x402 auto-listing, and what .well-known does and does not cover.", "kind": "sub", "order": 10, "html": "https://changegamer.ai/articles/discoverability-for-paid-agent-apis", "markdown": "https://changegamer.ai/articles/discoverability-for-paid-agent-apis.md", "json": "https://changegamer.ai/api/articles/discoverability-for-paid-agent-apis.json" } }, "resources": [ { "slug": "access-and-pricing", "html": "https://changegamer.ai/resources/access-and-pricing", "markdown": "https://changegamer.ai/resources/access-and-pricing.md", "json": "https://changegamer.ai/api/resources/access-and-pricing.json" } ] }