# Graunt

Graunt is the agent-native marketplace for AI data: evaluated data from many sellers, with declared rights, provenance, evaluation evidence, pricing, and signed-manifest support.
Buyers license data for training, fine-tuning, retrieval and agent use: each listing declares its permissions (training, public use, sublicensing to one client, credit) and the Marketplace License grants them, recorded with the purchase. Listing is free, sellers set the price, and they are paid through Stripe for each sale.

## Primary human entry points
- https://graunt.com/ - home
- https://graunt.com/explore - paginated catalog
- https://graunt.com/buy - how buying works for a person: find it, buy it, use it, what a purchase includes, licensing in plain words
- https://graunt.com/fees - fees for sellers and buyers in plain words (machine form at /v1/meta/pricing)
- https://graunt.com/licensing - how rights and licensing work for buyers, sellers and agents
- https://graunt.com/api-agents - agent commerce descriptor
- https://graunt.com/agents/mcp - connect an assistant to Graunt over MCP (per-client setup steps); packets you own travel on the library connector (one sign-in; see Connected library below) or an AI access key, see /access
- https://graunt.com/agents/tutorials - tutorials: give ChatGPT or Claude Code licensed data to cite (add Graunt, ask, check what the seller allows, cite the listing by its link)
- https://graunt.com/build-a-packet - packet assembly contract reference + live deterministic validator (human + agent; test a packet manifest against POST /v1/refinery/validate before upload)
- https://graunt.com/register - open seller/buyer registration (email and password, or a Google or Microsoft account)
- https://graunt.com/login - sign-in for registered organizations (email and password, or a Google or Microsoft account)
- https://graunt.com/prepare - start a listing: upload files into a private draft from a free account, paste a link to a data file or a Hugging Face dataset to import it, or let an agent prepare the draft with the prompt at /build-a-packet, claimed at registration
- https://graunt.com/studio/refinery - Seller Studio Refinery (the seller path: upload a ready packet and Graunt checks it, or upload files and Graunt drafts the listing fields left empty; price it, list it)
- https://graunt.com/support - open a support issue or send product feedback (tracked; API at POST /v1/support with Idempotency-Key; agent credentials use scope support:create)

## Machine surface
- https://api.graunt.com/.well-known/ai-plugin.json - plugin manifest
- https://api.graunt.com/openapi.json - OpenAPI 3.1 contract
- https://api.graunt.com/v1/listings - public listing search (JSON)
- https://api.graunt.com/v1/listings?starter_supply_slug=<slug> - HARD_FILTER_ONLY starter-supply category filter (never enters ranking; invalid slug returns HTTP 400)
- https://api.graunt.com/v1/listings?ai_generation=NONE - listings whose seller declares that no AI model generated any of the content (also PARTIAL or FULL; every new listing declares it; using AI to process real material, such as cleaning, labeling, transcribing, captioning or structuring it, does not make it AI-generated; a listing that contains video cannot be AI-generated, wholly or in part; a hard filter, never a ranking input)
- https://api.graunt.com/v1/listings?rights_training_allowed=true&rights_public_use=COMMERCIAL&rights_sublicense_one_client=true&rights_license_family=<family> - HARD_FILTER_ONLY filters on the listing's permissions (Marketplace License section 3) and its license family, on what the seller declared on the listing, which Graunt records (a seller declaration, not a Graunt finding): rights_training_allowed (permission 1, Train AI models on it: true or false), rights_public_use (permission 2, Show it publicly: NONE, EDITORIAL, PROMOTIONAL or COMMERCIAL; NONE also keeps listings with no answer), rights_sublicense_one_client (permission 3, Sublicensing to one client: true or false; false also keeps listings with no answer) and rights_license_family (one license family, such as CC_BY or PUBLIC_DOMAIN). Values in /v1/meta/search-contract; an unknown value returns HTTP 400. The MCP tools search and search_assets take the same four filters under the same names
- https://api.graunt.com/v1/listings?seller_credential=declared - HARD_FILTER_ONLY filter on the credentials the seller declares (trade licenses, certifications, business registrations, memberships, qualifications): declared keeps listings whose seller declares at least one, checked keeps those whose seller holds at least one that a Graunt operator checked against a registry; a seller declaration that Graunt records, never a Graunt finding or a ranking input. The listing detail, the agent commerce manifest and the MCP fetch tool carry seller_credentials_summary (declared, checked, kinds); the MCP tools search and search_assets take the filter under the same name
- https://api.graunt.com/v1/listings?kind=video&video_subject=<subject>&camera_view=<view> - HARD_FILTER_ONLY video filters: kind=video returns video listings, video_subject narrows them to what the footage shows and camera_view to how it was shot (values in /v1/meta/search-contract; an unknown value returns HTTP 400). Each result carries a video block: measured hours, the per-hour price with the listing's volume tiers, and the seller's declarations
- https://api.graunt.com/v1/listings/{id} - public listing detail (JSON)
- https://api.graunt.com/v1/listings/{id}/manifest - signed packet manifest
- https://api.graunt.com/v1/listings/{id}/bundle-manifest - per-asset bundle inventory with content hashes and a counts_basis for every count
- https://api.graunt.com/v1/listings/{id}/croissant - MLCommons Croissant 1.1 metadata (application/ld+json); dataset-level fields plus per-file SHA-256; no download URLs
- https://api.graunt.com/v1/listings/{id}/access-grants - mint a public free-access grant (anonymous; rate-limited). Free listings download without an account unless the seller requires one; those carry acquisition_mode PUBLIC_TOKEN_GRANT_FREE
- https://api.graunt.com/v1/listings/{id}/free-download - redeem a public free-access grant for a short-lived presigned download URL (single-file: 302 redirect; bundle-backed: JSON manifest + per-asset URLs)
- https://api.graunt.com/v1/entitlements/{id}/download - authenticated buyer single-file download (returns presigned URL + integrity headers)
- https://api.graunt.com/v1/entitlements/{id}/packet-bundle - authenticated buyer multi-asset bundle download (returns manifest + per-asset presigned URLs; available to the account that bought it and to agents using that account's credential)
- https://api.graunt.com/v1/meta/pricing - platform fee + processing formula + free-listing constraints + seller commission programmes
- https://graunt.com/feed.xml - Atom 1.0 feed of the active catalog, newest first (human host)
- https://graunt.com/feed.json - JSON Feed 1.1 of the same catalog; per-item price_cents and is_free under the _graunt key (human host)
- https://graunt.com/data.json - DCAT-US 1.1 catalog for open-data harvesters; the seller is the publisher of each dataset, and no license or publication date is asserted (human host)
- https://api.graunt.com/v1/meta/seller-standards - machine-readable seller and agent acceptance standards
- https://api.graunt.com/v1/meta/agent-surface - machine-readable omnibus agent-surface contract (trust primitives + scanner signals + participation + search contract)
- https://api.graunt.com/v1/meta/agent-participation - machine-readable participation contract (role kinds, reward kinds)
- https://api.graunt.com/v1/meta/scanner-signals - machine-readable scanner-signal catalog (DISCLOSE_ONLY ceiling)
- https://api.graunt.com/v1/meta/search-contract - machine-readable search / discovery contract
- https://api.graunt.com/v1/meta/categories - the listing categories (value, label, description); a listing's category, the search category filter and an upload take one of these values
- https://api.graunt.com/v1/refinery/validate - the free check: POST {"packet_json": <graunt/packet.json>} runs the checks an upload runs; POST {"packet_manifest": <manifest>} validates a packet manifest (deterministic; no LLM, no external network; public, no auth)
- https://api.graunt.com/v1/refinery/policies/public-support-matrix - public Refinery support matrix (the source types Graunt accepts and what the Refinery does with each; deterministic, no auth, no LLM, no external network)

## Extended machine surface
- https://api.graunt.com/v1/meta/capabilities - the capabilities Graunt offers, machine-readable
- https://api.graunt.com/v1/meta/arci-surfaces - pages + machine operations index, each with the capability it belongs to
- https://api.graunt.com/v1/meta/modals - 22 modal kinds with truthful summaries
- https://api.graunt.com/v1/meta/rights-model - 6 posture enums + 15 rights-decline codes
- https://api.graunt.com/v1/meta/denial-codes - 25 closed-enum denial codes
- https://api.graunt.com/v1/meta/receipt-kinds - 14 receipt kinds with per-kind payload allowlists + 3 proof kinds + 2 statuses
- https://api.graunt.com/v1/meta/requirement-groups - composable packet requirement groups (SAFE-only public projection; constitution_version + group ids + per-group requirement summaries)
- https://api.graunt.com/v1/meta/content-profiles - registered content profiles (validator-passable packet kinds + families + required requirement groups)
- https://api.graunt.com/v1/meta/constitution - ratified Packet Constitution version (constitution_version)
- https://api.graunt.com/v1/meta/refinery-policy - what the Refinery does with an upload: deterministic processing on every upload, model drafting only for the listing fields a seller left empty (within daily limits), free for the seller within a daily allowance; transcription past it runs at cost plus 10% only if the seller chooses. Refined packets are listed and purchased through the canonical marketplace.
- https://api.graunt.com/v1/receipts - buyer/agent receipt read (org-scoped, paginated)
- https://api.graunt.com/v1/receipts/{id} - receipt detail (org-scoped)
- https://api.graunt.com/v1/meta/provider-terms - operator-onboarded premium provider terms registry (public; cache-control public, max-age=300)
- https://api.graunt.com/v1/seller/provider-terms/accept - seller acceptance (writes a terms_acceptance receipt; idempotent)
- https://api.graunt.com/v1/seller/provider-terms/{id}/revoke - seller revokes a provider-terms acceptance
- https://api.graunt.com/v1/agents/principals - create / list your agent principals from a signed-in session; set spend_cap_cents_per_day and spend_cap_cents_per_month when you create one (they do not change afterwards)
- https://api.graunt.com/v1/agents/credentials - issue / list / revoke scoped agent credentials from a signed-in session (sha256 keyHash + display keyPrefix; plaintext shown ONCE)
- https://api.graunt.com/v1/agents/{agent_id}/manifest - PUT the access manifest (license_family AGENT_API_ACCESS, the principal's spend caps, approval_policy HUMAN_APPROVAL_REQUIRED); a manifest with no activation blockers activates the agent principal when it is submitted, and GET lists any blockers that remain
- https://api.graunt.com/v1/agents/purchases/preflight - agent BUY preflight (dry-run quote; bearer grnt_agent_*; scope quote:read; LIVE)
- https://api.graunt.com/v1/agents/purchases/execute - buy a listing: a free one at no charge, a paid one charged to the payment credential the agent presents or to the card on file for its organization, after the principal accepts the buyer terms (bearer grnt_agent_*; scope buy:execute; LIVE)
- https://api.graunt.com/v1/agents/listings/preflight - agent SELL preflight (field readiness; no write; bearer grnt_agent_*; scope quote:read; LIVE)
- https://api.graunt.com/v1/agents/listings/submit - agent SELL submit (reuses canonical createListing; the listing enters the automatic publication checks as PENDING_REVIEW and an eligible one publishes without manual review - see the Posture section; bearer grnt_agent_*; scope sell:submit; LIVE)
- https://api.graunt.com/v1/agents/drafts - your packet drafts with stage (NEEDS_YOU / CHECKS_RUNNING / DONE), the listing each became, and next_action (CONTINUE_DRAFT / AWAIT_CHECKS / MANAGE_LISTING / RETRY_PUBLISH / NO_ACTION). A packet already published reports DONE and points at its listing - the draft status alone never reports publication. Read-only; bearer grnt_agent_*; scope sell:submit

## Agent transactional surface
An organization sets up its own agent from a signed-in session: create an agent principal with both spend caps, submit its access manifest, and issue a credential with the scopes the agent needs. Submitting a manifest with no activation blockers activates the principal; there is no further step. A credential's scopes decide what it can change, on the agent endpoints and on the routes a person uses: sell:submit for listing and seller actions (POST /v1/listings, listing-draft submit, pause, archive, withdraw, signing keys), bundle:assemble for packet uploads and splices, buy:execute for acquisition, quote:read for dry runs and quotes. A change outside a credential's scopes answers 403 SCOPE_DENIED; on the routes a person uses, account changes, legal acceptances and changes to the card or bank account an organization's agents buy with take a signed-in person, and an agent accepts Graunt's terms for its account holder only at /v1/agents/terms/accept (see Agent account setup); a manifest limited to specific listings can change those listings and create new ones, and a change to an existing listing it cannot check against that list is refused. Some reads take a scope as well: sell:submit for a seller's drafts and their files, Refinery work, releases, terms documents, credentials, volume discounts, data added to pools, budget with its card and charges, and storage; payouts:setup for payouts; publish:review_read for a listing's publication readiness; receipt:read for packet access keys, Agent Access Links and pass history; and quote:read for offers made to the organization. A read that takes no scope returns what the credential's organization can read. Agent identity remains attributable to both the organization principal and the specific credential, and Graunt can suspend any agent principal.

## Agent account setup
An agent can open a Graunt account for the person or organization it acts for, accept Graunt's terms for them, and start payout setup over this API. Terms of Service section 3.4 lets an agent accept for its account holder, and every acceptance is recorded under the agent with the exact sentence it was served.
- https://api.graunt.com/v1/agents/signup/terms - the terms an agent accepts, each document's version and text hash, and the terms_digest to echo (GET; no auth)
- https://api.graunt.com/v1/agents/signup - open an account for the account holder (POST; no auth; rate limited); the credential is returned once and works after the account holder confirms the email Graunt sends them
- https://api.graunt.com/v1/agents/signup/confirm - what a confirmation switches on (GET with the emailed token) and the account holder confirming, with the agent switched on or without it (POST; no auth; the emailed token is the authority)
- https://api.graunt.com/v1/agents/terms - what the account still has to accept (GET; bearer grnt_agent_*)
- https://api.graunt.com/v1/agents/terms/accept - accept the account or seller terms for the account holder (POST; bearer grnt_agent_*; scope terms:accept)
- https://api.graunt.com/v1/agents/payouts/onboarding-link - Stripe payout onboarding link for an account that has not finished payout setup (POST; bearer grnt_agent_*; scope payouts:setup; optional JSON body {"country": "US" or "CA"}, the country the payout account opens in, default US)

## MCP transport
Graunt exposes a Model Context Protocol server at https://api.graunt.com/v1/mcp. Added as a connector with no authentication, it serves the tools search (keywords in, matching packets with public URLs out) and fetch (packet id in, description, commercial terms, and rights out) over the public catalog - the same ACTIVE-listing reads this site serves to any visitor, never entitled content. With no credential its tools are search, fetch, search_assets, get_asset, get_agent_commerce_manifest, get_asset_manifest, get_bundle_manifest, meta_capabilities, meta_refinery_support_matrix and match_video_spec. For a free packet that needs no account, fetch also returns the files: small text files (CSV, TSV, JSON, JSONL, Markdown, text, XML, YAML) inline up to 200 KB of text in all, and a short-lived download link per listed file in metadata.files (at most 100 per fetch), through the same rate-limited grant as the access-grants route. Sending a scoped grnt_agent_* credential widens the tool catalog to that credential's scopes. Mutations route through the canonical https://api.graunt.com/v1/agents/* HTTP path. Free BUY and SELL submission require a verified active manifest and fail closed when rate-limit infrastructure is unavailable. Paid purchases use the same HTTP path: the agent pays with a payment credential it presents. With no credential in the body, it charges the card the account holder saved for the organization's agents (saved at /studio/agent-card), within the daily and monthly spend caps set for that agent; preflight reports payment_method_on_file.
- https://api.graunt.com/v1/mcp - Streamable HTTP JSON-RPC 2.0 connector endpoint (no auth for public catalog reads; optional Bearer grnt_agent_*)
- https://api.graunt.com/v1/mcp/server-info - server descriptor + capability summary (public; cache-control public, max-age=300)
- https://api.graunt.com/v1/mcp/messages - JSON-RPC 2.0 (Bearer grnt_agent_* required; supports initialize, tools/list, tools/call, resources/list, prompts/list)

## Refunds
Refunds: All Graunt purchases are final. Graunt reviews reversals only for rights failure, fraud or unauthorized sale, or technical delivery failure. There is no satisfaction guarantee.
- https://graunt.com/legal/refund-policy - full refund policy (human)
- https://graunt.com/legal/terms - Terms of Service (human)
- https://graunt.com/legal/buyer-terms - Buyer Terms (human; accepted at the payment action)
- https://graunt.com/legal/seller-agreement - Seller Agreement (human)
- https://graunt.com/legal/aup - Acceptable Use Policy (human)
- https://graunt.com/legal/marketplace-license - Marketplace License, version 3.6 (human)
- https://graunt.com/legal/enterprise-video-addendum - Enterprise and Video License Addendum: the seller's warranties and capped indemnity on video purchases and purchases for one client made under Marketplace License 3.5 or earlier (human)
- https://graunt.com/legal/order-form - Order Form: the template a buyer and a seller sign for terms they agree for one order (human)
- https://graunt.com/legal/marketplace-license/modules - the Marketplace License's content modules (video and people on camera, audio and voice, images, personal information, text and documents, code, structured and tabular data); each document's exact text is at /legal/document/<slug>.md and its facts at /legal/document/<slug>.json. Every completed purchase has an Order License at GET /v1/purchases/{id}/order-license (and .pdf): one license per order with a schedule row per listing and the version and sha256 of each governing document recorded at the sale. Every paid purchase has an invoice at GET /v1/purchases/{id}/invoice.pdf, for the buyer's records.
- https://graunt.com/legal/privacy - Privacy policy (human)
- https://graunt.com/legal/electronic-signatures - Electronic Signature & Records Consent (human)
- https://api.graunt.com/v1/purchases/{id}/request-refund - buyer submits a purchase-issue review request (POST; auth-required; reason_code from {FRAUD, TECHNICAL_FAILURE, RIGHTS_REVOCATION}, the qualifying_reversal_grounds the agent commerce manifest lists; OTHER_OPERATOR_APPROVED is admin-only and rejected on the buyer path)
- https://api.graunt.com/v1/takedowns - anonymous rights-review intake (POST; per-IP rate-limited; submitter contact email is hashed server-side)
- https://graunt.com/report/listings/:id - public rights-review intake form (human)

## Delegated LLM Access Passes
Access Passes are live, and key access is the default way to use a packet: keep a revocable read-only pass active (no expiry by default - the pass lives until revoked, lazily auto-revoking after 180 days without use; 7-day, 30-day, and 90-day fixed terms are also available) and your assistant reads the entitled content directly with no download. Buyers and subscribers create a pass on /orders/:id or /library and give their assistant ONE paste-able link (https://graunt.com/p/<pass>) - assistants that fetch URLs can read entitled content through a pass link with no headers. API agents can continue to use Bearer credentials (Authorization: Bearer gap_live_*) against the /v1/access-passes endpoints below; both planes share the same budgets and revocation. The pass is read-only; it cannot purchase, publish, refund, or mutate, and no Graunt URL ever carries WRITE capability. A portable LLM-ready export pack is the fallback (GET https://api.graunt.com/v1/entitlements/{id}/llm-ready-pack); the original source archive (GET https://api.graunt.com/v1/entitlements/{id}/source-archive) is the secondary raw-file path.

## Using a Graunt link
Every Graunt credential is also usable as one paste-able read-only URL. Assistants that fetch URLs can read entitled content through a pass link; API agents can continue to use Bearer credentials. Responses are Markdown by default (Accept: application/json for the JSON envelope).
- https://graunt.com/p/{pass} - access-pass link plane root (manifest / content / ask / resources links)
- https://graunt.com/p/{pass}/content - licensed content with citations
- https://graunt.com/p/{pass}/ask?q={question} - cited source passages (no synthesis)
- https://graunt.com/k/{key} - discovery-key link plane root (public catalog metadata only)
- https://graunt.com/k/{key}/search?q={keywords} - attributed catalog search (hit/no-hit + rights/price; the purchase_handoff block is on the listing detail)
- https://graunt.com/access - public Graunt Access Pass instructions (human + assistant)
- https://graunt.com/access/llm-instructions - assistant-targeted instructions
- https://graunt.com/access/gemini-instructions - Gemini-targeted instructions
- https://api.graunt.com/v1/access-passes - create pass (buyer JWT; raw token returned once)
- https://api.graunt.com/v1/access-passes/resolve - resolve canonical pass metadata (Bearer gap_live_*)
- https://api.graunt.com/v1/access-passes/manifest - bounded entitled-library manifest (Bearer gap_live_*)
- https://api.graunt.com/v1/access-passes/resources - resource ID list (Bearer gap_live_*)
- https://api.graunt.com/v1/access-passes/resources/{id} - per-resource bounded detail (Bearer gap_live_*)
- https://api.graunt.com/v1/access-passes/content - canonical broad read of entitled content (cited content units; cursor; Bearer gap_live_*)
- https://api.graunt.com/v1/access-passes/ask - retrieve cited source passages from entitled content (answer_mode SOURCE_PASSAGES; passages are quoted from your entitled sources, not synthesized; Bearer gap_live_*)
- https://api.graunt.com/v1/access-passes/revoke - buyer self-revoke (JWT)
- https://api.graunt.com/v1/entitlements/{id}/llm-ready-pack - portable LLM-ready export pack (buyer / entitled agent)
- https://api.graunt.com/v1/entitlements/{id}/source-archive - original source files archive, secondary path (buyer / entitled agent)

## Publication trust pipeline
LLM-assisted fixes may draft metadata, documentation, and derived sidecars. They never replace source originals, verify legal rights, or certify truth.

## Connected library (MCP + OAuth)
A buyer account can connect its library as a second MCP connector at https://api.graunt.com/v1/mcp/library. An unauthenticated call answers 401 with WWW-Authenticate pointing at RFC 9728 protected-resource metadata; the client discovers the authorization server (RFC 8414), registers dynamically (RFC 7591), and completes an authorization-code + PKCE (S256) exchange. The access token is a revocable read-only gap_live_* key with no timed expiry - the connection persists across conversations until revoked from https://graunt.com/account. Connected tools: library_list, library_get_item, library_read_file (range-capped, metered), plus the public catalog tools. Read-only by construction; purchases stay on /v1/agents/*.
- https://api.graunt.com/v1/mcp/library - OAuth-protected MCP endpoint for the connected account's owned packets
- https://api.graunt.com/.well-known/oauth-protected-resource/v1/mcp/library - RFC 9728 resource metadata
- https://api.graunt.com/.well-known/oauth-authorization-server - RFC 8414 authorization-server metadata
- https://graunt.com/agents/mcp - per-client connector setup steps (catalog + library)

### Helping a person use the packets they own
1. Ask the person to add https://api.graunt.com/v1/mcp/library as a connector in your client (name it Graunt library). Steps for ChatGPT, Claude and Claude Code: https://graunt.com/agents/mcp#connect-your-library. In Claude Code the command is: claude mcp add --transport http graunt-library https://api.graunt.com/v1/mcp/library - then /mcp, choose graunt-library, and pick Authenticate.
2. The client opens graunt.com. The person signs in with their own Graunt account. You cannot sign in for them, and you never ask for their password.
3. After sign-in, Graunt's consent page asks for "Allow read access". Allowing grants read-only access to the data that account owns; the connection cannot buy, publish, or change anything.
4. Then call library_list (what they own), library_get_item (one listing's files and terms), and library_read_file (a byte range of one file).
5. If the client cannot add connectors, ask the person for an AI access key instead: they create one at https://graunt.com/library and paste the link or the gap_live_ key into the chat.

## Starter collections
Starter AI/workflow packet collection landings. Each page lists ACTIVE listings whose tags[] contain the slug; the API filter is documented in /v1/meta/search-contract under starter_supply_slug.
- https://graunt.com/explore/collections/project-governance - Project governance packets
- https://graunt.com/explore/collections/claude-md-agent-instructions - Claude.md / agent instructions packets
- https://graunt.com/explore/collections/agent-workflows - Agent workflows packets
- https://graunt.com/explore/collections/mcp-openapi-integration - MCP / OpenAPI integrations packets
- https://graunt.com/explore/collections/public-source-digests - Public-source digests packets
- https://graunt.com/explore/collections/source-backed-research - Source-backed research / reference packets

## Listing with an agent
An agent with a Graunt credential takes a listing from nothing to live over the API, in this order. Every price comes from the seller: Graunt suggests none, and neither do you.
1. Open the account: GET https://api.graunt.com/v1/agents/signup/terms, then POST https://api.graunt.com/v1/agents/signup with the account holder's name and email, each affirmation, agent_attestation true, the terms_digest, both spend caps and the scopes sell:submit, terms:accept, publish:review_read and payouts:setup. The key comes back once and works once the emailed link is confirmed (POST https://api.graunt.com/v1/agents/signup/confirm). An agent that already holds a credential with those scopes starts at the next step.
2. Accept the seller terms for the account holder: GET https://api.graunt.com/v1/agents/terms, then POST https://api.graunt.com/v1/agents/terms/accept with groups ["SELLER_TERMS"], agent_attestation true and the terms_digest.
3. Make the draft and add its files: POST https://api.graunt.com/v1/refinery/drafts, then POST https://api.graunt.com/v1/refinery/uploads/direct with the draft_id for each small file. upload_limits at https://api.graunt.com/v1/meta/packet-assembly-contract names the routes for large files and links.
4. Save the details: GET https://api.graunt.com/v1/refinery/drafts/{id} for its revision, then PATCH the same path with expected_revision and state: what the data is, its source files, the rights with the seller's attestation, whether AI made it, and monetization.one_time with the price the seller gave you.
5. List it: POST https://api.graunt.com/v1/refinery/drafts/{id}/submit-for-review with aup_acknowledged true. A 422 names what is still missing. Graunt's automatic publication checks then run. GET https://api.graunt.com/v1/agents/drafts names the listing the draft became, and GET https://api.graunt.com/v1/agents/listings/{id}/publication-readiness says what holds one back.
6. Price Reference, if the seller wants it: GET https://api.graunt.com/v1/seller/listings/{id}/ways for the fingerprint, then PUT the same path with historical as read, expected_fingerprint, and offers holding a row {"way":"REFERENCE","scope":"ORG","interval":"MONTH" or "YEAR","price_cents":...} for each price the seller gave you. A save replaces the whole set and sets it, so send every price to keep. The save opens the plan buyers take: the row reads purchasable true, or its blocked_by says why not. The prices stay set through a new revision of the listing's files.
7. Where the listing can't take Reference, it can sell by subscription: POST https://api.graunt.com/v1/listings/{id}/subscription-plans with monthly_price_cents and annual ({"mode":"CUSTOM","price_cents":...} or {"mode":"OFF"}).
8. Set up payouts: POST https://api.graunt.com/v1/agents/payouts/onboarding-link returns Stripe's hosted onboarding link for the account holder.

The same credential runs the listing as the seller would, with the seller's own words and figures:
- People in the files: POST https://api.graunt.com/v1/seller/releases with their emails and the listing_id asks each to sign, and GET https://api.graunt.com/v1/seller/releases?listing_id={id} gives a link to hand out. The person signs their own release, and you send or hand out the link and never sign it.
- Credentials the seller holds: POST https://api.graunt.com/v1/seller/credentials declares one, and it reads as declared by the seller.
- The seller's own terms: POST https://api.graunt.com/v1/seller/terms-documents saves them, and PUT https://api.graunt.com/v1/seller/listings/{id}/additional-terms attaches them to a listing.
- An offer to named buyers: POST https://api.graunt.com/v1/seller/listings/{id}/private-offers with the seller's price, and POST https://api.graunt.com/v1/seller/listings/{id}/visibility takes a listing private or public.
- Volume discounts: PUT https://api.graunt.com/v1/seller/volume-discounts with the seller's steps.
- Files the seller already holds on Graunt: GET https://api.graunt.com/v1/seller/files, then POST https://api.graunt.com/v1/seller/files/draft to start a draft from them.
- A packet prepared before the account existed: POST https://api.graunt.com/v1/seller/packet-claim/request, then POST https://api.graunt.com/v1/seller/packet-claim/redeem with the code sent to the account's own address.
- The seller's card for Graunt's charges: POST https://api.graunt.com/v1/seller/refinery-budgets with the seller's limits, at most your own spend caps. POST https://api.graunt.com/v1/seller/refinery-budgets/me/payment-method/setup-intent returns a client secret once. Confirm it at Stripe with the key from GET https://api.graunt.com/v1/meta/stripe-publishable-key, then POST https://api.graunt.com/v1/seller/refinery-budgets/me/payment-method/refresh. By saving this card, you allow Graunt to charge it for future payments, within the budget's limits: when each run of turning recordings into text past the free daily amount finishes, at cost plus 10%, and each month for storage past the free allowance, at cost. Card numbers go to Stripe, never to Graunt.
- Recordings into text past the free daily amount: GET https://api.graunt.com/v1/refinery/drafts/{id}/processing for the total, then POST https://api.graunt.com/v1/refinery/drafts/{id}/processing-runs with it as expected_total_cents.
- Room past the free storage allowance: POST https://api.graunt.com/v1/seller/storage/paid-room with enabled true or false.
- A failed payout, with the payouts:setup scope: GET https://api.graunt.com/v1/seller/payouts, then POST https://api.graunt.com/v1/seller/payouts/{splitId}/retry. The money goes only to the seller's connected account.

## Data pools
A data pool is one kind of business's data, added by many businesses and sold as one product. Buyers choose data types and years and pay per record; each business in a sale is paid for its own records in it, after Graunt's 25% fee, less on the part of a business's share of a sale above $100,000. A business holding a launch seat starts at 12.5%. A business can also sell the same records as its own listing.
- https://graunt.com/pools - every open pool, with how many businesses have added data; as JSON at https://api.graunt.com/v1/pools (operationId listPools)
- https://graunt.com/pools/plumbing - the plumbing pool; as JSON at https://api.graunt.com/v1/pools/plumbing (operationId getPool)
- https://graunt.com/pools/hvac - the hvac pool; as JSON at https://api.graunt.com/v1/pools/hvac (operationId getPool)
- https://graunt.com/pools/electrical - the electrical pool; as JSON at https://api.graunt.com/v1/pools/electrical (operationId getPool)
- https://graunt.com/pools/software-archives - the software-archives pool; as JSON at https://api.graunt.com/v1/pools/software-archives (operationId getPool)
- https://graunt.com/pools/business-procedures - the business-procedures pool; as JSON at https://api.graunt.com/v1/pools/business-procedures (operationId getPool)
- https://graunt.com/pools/support-conversations - the support-conversations pool; as JSON at https://api.graunt.com/v1/pools/support-conversations (operationId getPool)
- https://api.graunt.com/v1/pools/<slug>/kit - the fields, file rules, terms and an assistant prompt for adding a business's data (operationId getPoolKit)
- https://api.graunt.com/v1/pools/<slug>/quote?types=<types>&years=<years> - what a buyer pays for the pool or part of it, open to anyone; each type is a key from the pool's types[].key (operationId getPoolQuote)
- https://api.graunt.com/v1/pools/<slug>/sample/<type> - a free sample of one data type, with records from every business that offers it (signed in, or an API key holding entitlements:read; operationId getPoolSample)
- https://api.graunt.com/v1/seller/pools/<slug>/contributions/preview, then /contributions - add a business's file (signed in, or an agent credential holding sell:submit; operationIds previewPoolContribution, confirmPoolContribution)

## Account managers
An account manager runs other businesses' seller accounts on Graunt for a fee it agrees with each one. Each business stays the seller, with its own payout account; Graunt pays the fee out of each sale's seller net after paying the business, and buyers never see a manager.
- https://graunt.com/studio/managers - a signed-in account becomes a manager here, invites each business by email, and works in each client's account
- https://graunt.com/legal/document/manager-terms - the terms between Graunt and the manager
- https://graunt.com/legal/management-agreement - the agreement between the business and its manager; the owner signs up from the invitation and accepts it at the fee on screen
- https://api.graunt.com/v1/mcp/seller - a manager's AI prepares work in a client's account here, on the key issued for that client, only where the owner turned it on; a person submits what it prepares

## Listings sold from the seller's storage
Some listings stay in the seller's own storage (Amazon S3, Backblaze B2 or Wasabi). Graunt holds the frozen manifest of every file, samples and a delivery guide (DELIVERY.md in the listing's packet); after purchase the files come straight from the seller's storage. Each one is a paid, one-time purchase. The seller is paid for such a sale once its delivery closes: the buyer confirms the files, or the time to check them passes after they are available (by the size bought: 5 US business days up to 10 TB, 10 up to 100 TB, 20 up to 1 PB and 30 above), and then 5 more business days pass with no problem reported and none open; both clocks stop while the seller's storage does not answer. Listing search results and listing detail carry seller_hosted: file count, total bytes, media facts, delivery modes and samples (null on other listings).
- https://api.graunt.com/v1/listings?min_height=1080&has_audio=true - media filters min_height, min_fps, min_clip_seconds, has_audio, min_total_hours; filters only, and any of them limits results to these listings
- https://api.graunt.com/v1/listings/{id}/samples - the samples to look at before buying (operationIds listListingSamples, getListingSampleContent)
- https://api.graunt.com/v1/entitlements/{id}/hosted-delivery - after purchase: the delivery status and clock (operationId getHostedDelivery), the frozen manifest at /manifest, and the files by a download link per file (/links, operationId getHostedDeliveryLinks); or a copy the seller sends: on drives with a tracking number, bought at checkout (drive_delivery on POST /v1/purchases), or encrypted over a network with the key from /key (/sealed, operationId chooseHostedSealedDelivery). An agent's purchase answer names this route as delivery.hosted_delivery_url_v1. Such a purchase takes no packet access key, Agent Access Link or access pass scoped to it (409 HOSTED_LISTING): Graunt holds only its manifest, samples and guide, so its files come only through this route.
- https://api.graunt.com/v1/seller/hosted-sets - a seller lists a set kept in an Amazon S3 bucket through a read-only role it creates, or a Backblaze B2 or Wasabi bucket through a read-only key it creates for that bucket (signed in, or an agent credential holding sell:submit; operationId createSellerHostedSet)

## Buyers Board (buyer requests)
A buyer posts the data it needs. Sellers who hold that data link their own listings to the request, and the buyer buys a linked listing at its listed price. A request carries no contact details, never names its buyer (Graunt refuses one that names the buyer's organization or email domain), and moves no money. The buyer chooses whether the amount reads exactly or as a range, gives a budget exactly, as a range or not at all, and shows each to everyone or to registered sellers only; a field shown to registered sellers only is never on a public page.
- https://graunt.com/requests - open requests that have cleared review
- https://api.graunt.com/v1/requests - the buyer's own requests: post one (POST; an Idempotency-Key header makes a retry safe), list them, read one with its linked listings (/v1/requests/{id}), edit, renew (/renew) and close (/close); signed in, or an agent credential holding request:post
- https://api.graunt.com/v1/meta/request-spec-template?kind=<KIND> - the spec file for a request of one kind: every key of the kind's spec, each null, with what it takes; POST /v1/requests/spec/read (kind, text) reads a filled-in file into the spec a request takes and stores nothing, and GET /v1/requests/{id}/matches lists the live listings on Graunt that match the buyer's own request (request:post)
- https://api.graunt.com/v1/seller/requests - the requests a seller can see, filtered by kind or to those its live listings match (?matching=true); link one of its own listings (POST /v1/seller/requests/{id}/listings with listing_id) or withdraw it (DELETE /v1/seller/requests/{id}/listings/{listingId}); signed in, or an agent credential holding request:answer
- https://api.graunt.com/v1/seller/request-alerts - the kinds of data a seller follows for its daily email of new requests (GET, PUT; request:answer)
- MCP (/v1/mcp): buyer_requests.list and buyer_requests.get read what a seller can see (request:answer); buyer_requests.mine reads the buyer's own (request:post). Posting and linking use the routes above.

## Video that meets a spec
Ask how many hours of video on Graunt meet a spec, and in which categories. The answer counts each listing clip by clip: hours that meet every requirement on recorded evidence, and hours that meet every requirement the evidence covers but lack evidence for one or more, with each listing's list price, price per hour and volume tier, its delivery modes and where each number comes from. Thresholds snap to fixed steps, and the answer says which did. Add hours_wanted and the answer also proposes whole listings across sellers that reach those hours on recorded evidence, each at its seller's own price; nothing is held.
- https://api.graunt.com/v1/listings/spec-match?min_short_side_px=1080&min_fps=24&min_clip_seconds=60&audio=REQUIRED - the answer as JSON (operationId matchVideoSpec); add format=csv for the quote file
- MCP tool match_video_spec - the same answer, with the spec as arguments
- https://graunt.com/buy/video - the same count for a person, with the quote to download

## Buying several listings in one order
A signed-in person can put up to 100 paid listings from any sellers in one cart and pay for them in one payment at https://graunt.com/cart ("Add to cart" is on each listing's page and in the Marketplace list). Each listing becomes its own purchase, with its own license and its own payout to its seller, and one receipt lists them all. One payment is at most $999,999.99. A cart line buys its listing whole. An agent credential cannot use the cart; it buys one listing a call at https://api.graunt.com/v1/agents/purchases/execute. For an order of several listings, give your human each listing's purchase_handoff.listing_url and https://graunt.com/cart.
Checkout takes a card, an ACH debit, a bank transfer, or an invoice the buyer's payables team pays within 30 days, with no processing fee; the data opens when the payment arrives. An agent credential pays by card, or sends payment_method "invoice" (with max_buyer_total_cents, and purchase_order_number if it has one) to https://api.graunt.com/v1/agents/purchases/execute: Graunt emails the account's own address a Stripe invoice due in 30 days, the purchase answers 202 PENDING, and the data opens when the invoice is paid.

## Buying part of a video listing
A video listing priced by the hour whose files each carry one of its categories can be bought by category: the buyer pays the listing's rate for the measured hours of the categories bought, at the volume tier those hours reach. GET https://api.graunt.com/v1/listings/{id} lists each category's hours and price in video.per_hour.categories. An agent names video_subjects at https://api.graunt.com/v1/agents/purchases/preflight and /execute, and a person checks out at https://graunt.com/checkout/{id}?categories=A,B. Only the files in the categories bought are delivered.

## Buying a listing exclusively
Where the seller offers it, GET https://api.graunt.com/v1/listings/{id} carries exclusivity (mode, months, price_cents added to the listing's price, holders who keep what they bought, licenses_elsewhere the seller declares); an agent sends exclusive with those months and price_cents at https://api.graunt.com/v1/agents/purchases/preflight and /execute, and for the Exclusivity Period the listing reads on_sale false and is sold to no one else.

## Seller commission
Sellers pay a platform commission and no other seller fee: no payout fee, no monthly fee, no transfer fee. Sellers in the United States and Canada can set up payouts; Graunt pays in US dollars, and a US-dollar bank account avoids Stripe's currency conversion fee. The current commission, any reduced commission open to new seller organizations, and a worked fee example are machine-readable at https://api.graunt.com/v1/meta/pricing.
- https://graunt.com/prepare - prepare a packet and list it

## Selling a packet
There are two ways in, and both are free; processing beyond the free tier is the seller's choice, at cost plus 10%. Bring a ready packet: a folder with graunt/packet.json, built to the packet assembly contract, whose ready_packet section has the folder layout and a prompt that writes the file. Check the file free, then upload the folder; when the file declares every listing field, Graunt checks the packet and drafts nothing, and no model reads it unless the seller pays to turn its recordings into text. If graunt/packet.json cannot be read, Graunt drafts nothing; the free check says what to fix. Or bring files, a link to a data file, or a Hugging Face dataset, and Graunt drafts the listing fields left empty, at its own cost. Every upload gets the deterministic checks. Each uploaded file can be up to 100 GB, a listing holds 1 TB, and a draft takes up to 10,000 uploaded files, whether the seller uploads in a browser or an agent uploads with the seller's key. A link Graunt fetches brings one file up to 100 GB.
- https://api.graunt.com/v1/meta/packet-assembly-contract - the contract; ready_packet carries the folder layout, the free check and the prompt, media_recipe the free tools that write a recording's timed transcript, a video's scene list and thumbnails, short clips and recordings.csv, and upload_limits the route for each file size
- https://api.graunt.com/v1/refinery/validate - the free check: POST {"packet_json": <graunt/packet.json>} (public; no auth)
- https://graunt.com/studio/refinery - upload the folder, or your files

## Posture
Listings carry declared rights, provenance metadata, and packet checks. New listings enter publication review on submission. Auto-publication is live for eligible listings: deterministic publication checks run automatically on submission and eligible candidates publish through the canonical publication gate. Manual review is retained for escalations. Listings may be backed by a single dataset file or by a finalized packet bundle revision (multi-file). Bundle-backed listings deliver every asset in one short-lived signed-URL list for the revision the buyer holds, which moves forward at no charge when the seller publishes an update that keeps the buyer's files: signed-in buying accounts and agents using their credential fetch the bundle via GET /v1/entitlements/{id}/packet-bundle; anonymous public-token-grant redemption returns the same shape as JSON instead of a redirect. There is no public composite signal, quality filter, or quality sort. Agents can discover, inspect, compare, and prepare acquisition decisions today. Listings carry an acquisition_mode: PAID_ENTITLED (Stripe paid checkout via signed-in Graunt accounts), AUTHENTICATED_FREE_ENTITLED (free acquisition by an signed-in Graunt account through POST /v1/purchases with no Stripe call), or PUBLIC_TOKEN_GRANT_FREE (free, public, IP-rate-limited; mint via POST /v1/listings/:id/access-grants and redeem via GET /v1/listings/:id/free-download). Public free access is rate-limited per IP and per listing; underlying storage objects are private and delivered only via short-lived presigned URLs. Free does not mean unlimited. Buyers are responsible for determining fitness for use. Current marketplace pricing metadata is published at /v1/meta/pricing.

## Native packet bundle capacity
Native packet-bundle delivery is canonical. Multi-asset packets (reference packets that ship hundreds of source documents alongside primary data) upload as a single packet_bundle_revision with one row per delivered file and a single manifest_sha256 covering the canonical inventory. The caps are 10,000 assets per bundle, 100 GB per asset, 1 TB total. GET /v1/listings/{id}/bundle-manifest returns the full canonical inventory in one response, with a counts_basis naming the population behind every count. Optional ZIP archive export is a derived convenience artifact. It is generated from the canonical bundle revision when requested and is never the source of truth. Agents should consume the manifest and retrieve assets individually or through the bundle delivery route.

## Manifest-first delivery contract
Large packet delivery in Graunt is manifest-first. Agents should inspect manifest, file index, rights and provenance, use plan, checksums, and available sidecars before requesting source originals. Controlled splice bundles and subscription working sets are entitled delivery modes for selected source originals and derived sidecars. Source context, enrichment receipts, original-text preservation receipts, and reviewer receipts are derived outputs. They do not replace source originals or verify legal rights. Full source originals may be delivered as individual files, source_originals.zip, shard archives, controlled splice bundles, or a bounded subscription working set depending on entitlement, file count, and size. Controlled splice bundles include only the source files required to support the selected result, plus the relevant markdown and JSON sidecars. Zip files require a tool-enabled runtime to inspect. The searchable contract is the sidecar index, not the zip itself. Subscription working sets are bounded (32 files / 256 MiB / 7-day default TTL) and pinned to the active entitlement. Revocation of the bound subscription revokes the working set. Agent packet-bundle assembly (bundle:assemble scope) reuses the canonical upload and finalize substrate. The resulting bundle enters the canonical publication gate. Nothing publishes outside that gate.

## Refinery-to-packet bridge
Approved refinery outputs flow into delivery-ready packet bundles through a canonical bridge. The bridge reuses the same manifest hash, sidecar set, and frozen-prefix storage layout as seller and agent assembly. It records original text preservation coverage from refinery_content_units. It never publishes a listing. Sellers continue through the canonical publication gate.

## Removing personal details
A seller may send a file that holds people's personal data (an order history, a store's sales export, an accounting export) through https://api.graunt.com/v1/scrub/sessions before it becomes a Refinery source (scope sell:submit); the step is offered, never required, and a file uploaded as it is lists as it is. Graunt proposes what to remove, keep, cut down or replace with a counter; the seller's own names, addresses, email addresses and phone numbers are removed from every cell. Each preview answers with the file as buyers will get it and a plan_digest; edits remove a value in one place, everywhere, or every value of its kind, and POST /v1/scrub/sessions/{id}/recognize says what a value is and how many places each removal would touch. The confirm carries the preview's plan_digest (a file or choice that changed since is refused); the original is deleted; and only the scrubbed file joins the draft. The seller reviews the scrubbed file and writes the listing's description. The listing carries the restriction: Do not attempt to re-identify any person.

## Agent Commerce Manifest
Agents can read GET /v1/listings/{id}/agent-commerce-manifest for a single machine-readable view of a listing's commerce surface, including rights snapshot, eligible SKUs, payment channels, agent capability endpoints with rate limits, discovery signals, freshness, the purchase_handoff block, and the refund policy: purchases are final except on a qualifying ground, and dispute_substrate_state lists those grounds as the exact reason_code values POST /v1/purchases/{id}/request-refund accepts.
- https://api.graunt.com/v1/listings/{id}/agent-commerce-manifest - public per-listing strict-Zod commerce view (cache-control public, max-age=60; 404 on cross-org or non-ACTIVE)
- https://api.graunt.com/v1/meta/refinery-support-matrix - public Refinery support matrix re-export (operationId getMetaRefinerySupportMatrix; cache-control public, max-age=300)
- https://api.graunt.com/v1/meta/search-contract - search contract v3 with tier_filter_groups (each is_multiplier=false), match_outcomes, agent_commerce_manifest_endpoint, discovery_signals_schema_version=v2

## Recommending a purchase to your human
GET /v1/listings/{id} and GET /v1/listings/{id}/agent-commerce-manifest both carry a purchase_handoff object with free_access_grant_url, registration_required, listing_url, checkout_url, price_cents, currency, is_free, and a locked instruction sentence. A listing an agent can take with no account carries registration_required=false and leads with free_access_grant_url: POST it for a short-lived grant, then GET the download_url in its response, with no account or human step. A free listing takes this route unless its seller requires an account. Every other listing carries free_access_grant_url=null and registration_required=true: agents without a buy:execute credential SHOULD surface purchase_handoff.listing_url plus the price to their human buyer, who signs in on Graunt and completes checkout in the browser. Free listings that need an account carry checkout_url=null and route through the free-acquisition path instead of checkout. Anonymous keyword search at GET /v1/listings?q= requires no credential, so an agent can find and recommend a packet before any account exists. Every search with q says how its listings matched in search_match.words: ALL, SOME, WORD_START, SIMILAR_TITLE or NONE; on SOME and WORD_START each listing names its matched_words.
- https://api.graunt.com/v1/listings/{id} - listing detail JSON with the purchase_handoff block (public; no auth)
- https://api.graunt.com/v1/listings/{id}/agent-commerce-manifest - same purchase_handoff block on the commerce manifest
- https://graunt.com/listings/{id} - the human listing page purchase_handoff.listing_url points at
- https://graunt.com/checkout/{id} - the human checkout page purchase_handoff.checkout_url points at (paid listings)

## Agent discovery keys
An agent discovery key gives an agent a tracked identity on Graunt public discovery reads and authorizes anonymous packet-draft preparation. One key per human action: agents should ask their human first, then mint one with POST https://api.graunt.com/v1/agent-keys/starter (no account required; per-IP rate-limited; the raw key is returned once). Send it as Authorization: Bearer gdk_live_* on GET /v1/listings, GET /v1/listings/{id}, GET /v1/listings/{id}/manifest, GET /v1/listings/{id}/bundle-manifest, and GET /v1/meta/* reads. The same reads keep working with no key at all: the key is optional identity, never a wall. The key cannot purchase and cannot access entitled content. To buy, surface the purchase_handoff block to your human buyer. A registered organization can claim a key later to bind it to the account; claiming binds identity, not permissions. Any anonymous drafts prepared with the key move to the claiming account.
- https://api.graunt.com/v1/agent-keys/starter - mint an agent discovery key (POST; no account; per-IP rate-limited; raw key returned once)
- https://api.graunt.com/v1/agent-keys/starter/claim - bind a minted key to your organization account (POST; buyer/seller JWT)
- https://api.graunt.com/v1/me/agent-keys - list your organization's claimed keys (GET; JWT; display prefix + usage only, never the key)
Agents holding a discovery key can prepare a packet before their human registers: read the packet assembly contract and the starter kit, and build a packet draft the key owns, private until submitted. A submitted draft becomes a listing that stays private until the human registers and claims the key, and it goes live once they claim it. Graunt maintains a free starter packet listing ("Build and sell packets on Graunt - starter kit") with the same instructions plus selling and agent walkthroughs.
- https://api.graunt.com/v1/meta/packet-template - the FULL Graunt Packet Template: every content family, the rights declaration, a worked example (GET; public; no auth; paste it into an assistant and it knows how to build packets)
- https://api.graunt.com/v1/meta/packet-assembly-contract - the canonical packet assembly contract (GET; public; no auth)
- https://api.graunt.com/v1/meta/packet-assembly-starter-kit - instructions and an example graunt/packet.json (GET; public; no auth; the human zip download is /v1/meta/packet-assembly-starter-kit.zip)
- https://api.graunt.com/v1/anonymous-drafts - create a private packet draft (POST; discovery-key bearer)
- https://api.graunt.com/v1/anonymous-drafts/{id} - draft detail (GET) / set title, price, and draft details incl. intendedUses, category and the rights declaration (PATCH)
- https://api.graunt.com/v1/anonymous-drafts/{id}/uploads - presign a source-file upload (POST; then POST /uploads/complete)
- https://api.graunt.com/v1/anonymous-drafts/{id}/validate - deterministic completeness report (POST)
- https://api.graunt.com/v1/anonymous-drafts/{id}/submission-attestation - confirm the rights to upload and agree to the Terms of Service and the Acceptable Use Policy (POST; then POST /submit to create the listing, which goes live once the seller claims it)

## Packet access for entitled buyers and agents
Once an organization holds an entitlement, an agent can pull the packet in the format its runtime supports. An agent credential with receipt:read issues, lists and revokes the keys and links below, and access passes at POST /v1/access-passes and /v1/access-passes/revoke, for what its own organization holds; each stays read-only. Original source files and Refinery-generated machine files are counted separately. Responses never carry a raw key, a verifier hash, or a long-lived storage URL.
- https://api.graunt.com/v1/entitlements/{id}/packet-access-keys - POST issues a durable read-only packet access key (returned once); send it as Authorization: Bearer to the access manifest. Header/API access path.
- https://api.graunt.com/v1/entitlements/{id}/packet-access-manifest - GET the packet access manifest (delivery modes and asset scopes).
- https://api.graunt.com/v1/entitlements/{id}/machine-zip - GET a short-lived download URL for the machine packet ZIP (manifest, router, indexes, content units, agent guide). Upload/file path.
- https://api.graunt.com/v1/entitlements/{id}/agent-access-links - POST creates a scoped, revocable, read-only Agent Access Link for an LLM that can open URLs but cannot set headers; GET lists them, never a link itself. The link page is noindex and never appears in this file or the sitemap.
- https://api.graunt.com/v1/entitlements/{id}/llm-access-profiles - POST returns the best access format for each known client.
- https://api.graunt.com/v1/entitlements/{id}/attestations - POST records what the buyer found in the purchase, one record per kind: CONTENT_MATCH, ISSUE_REPORT or LICENSE_COMPLIANCE.

## Following a listing's new versions
Sellers publish new versions of a live listing. Subscribers follow the current version; a buyer who paid once receives each update that keeps every file they bought, at no charge. A buyer's script or agent follows a listing like a feed: call GET /v1/me/library/listings/{listing_id}/versions once for the version it holds with every file, store next_since, then call again with ?since=<next_since> on a schedule. Each newer version lists the files it added, changed or removed, by content_sha256, with read paths in the version the caller holds: content_path and records_path read text and rows with an access pass (Bearer gap_live_...), and download_path returns a short-lived URL per file when the caller's access includes downloads. Polling costs nothing and there is no download limit; bundle URLs are issued up to 60 times an hour per listing. held_revision_number below listing_revision_number means an update replaced or removed one of the buyer's files, and the buyer keeps the version they bought. Send a signed-in session, an X-API-Key with entitlements:read, or an access pass.
- https://api.graunt.com/v1/me/library/listings/{listing_id}/versions - GET the versions after ?since= (operationId getMyListingVersions).
- https://api.graunt.com/v1/me/library/listings/{listing_id}/packet-bundle - GET every file of the held version by listing id (getMyListingPacketBundleDelivery).

## Live and refreshed feeds
A fixture-backed machine-only observation feed is callable for an entitled, authenticated principal. It returns machine-readable observations only. No raw media or stream is included.
- https://api.graunt.com/v1/feeds/{feedId}/manifest - GET feed manifest (operationId getFeedManifest).
- https://api.graunt.com/v1/feeds/{feedId}/latest - GET latest observations (getFeedLatest).
- https://api.graunt.com/v1/feeds/{feedId}/changes - GET changes by cursor (getFeedChanges).
- https://api.graunt.com/v1/feeds/{feedId}/health - GET feed health (getFeedHealth).
- https://api.graunt.com/v1/feeds/{feedId}/sessions - POST a machine-only session (createFeedSession); playback_url and raw_stream_url are null.
Everything live is listed at https://api.graunt.com/v1/meta/capabilities.