# AcqPath — RSL rights preflight > Can I use this URL for RAG, summarization, AI input, training or search? Check machine-readable declared content rights. Reports are evidence, not licenses or legal clearance. MCP: https://api.getacqpath.com/mcp (Streamable HTTP). Paid report delivery uses HTTP x402 outside MCP. Fresh 0.02 USDC; deep 0.05 USDC. Verify live capabilities and the prepared signed quote. Secure POST: https://api.getacqpath.com/v1/rights/preflight. Use the tested AcqPath SIWX adapter with unchanged official TS/Python payment signers and random nonces. Generic zero-config clients and stock SIWX-only hooks are unsupported on this secure route. Separate stock route: https://api.getacqpath.com/v1/rights/preflight/x402, fresh 0.02 USDC, normal official TS/Python x402, no SIWX or custom signer. First valid use binds the body; the payment signature does not sign it in advance. Stock guide: https://developers.getacqpath.com/examples/STOCK-X402.md. No API key or AcqPath account is required for the current x402 flow. UNKNOWN and unsupported inputs do not authorize ingestion. Private claims and signatures stay outside model context. Partners: https://developers.getacqpath.com/partners — three events prove the integration path; use 25 eligible events or 6 hours as the normal shadow decision gate, with a hard cap of 50 events or 24 hours. Evidence contract: https://developers.getacqpath.com/packages/evidence-bridge/schemas/resolution-v1.json. ## Integration - [A source URL is not a source-rights record](https://developers.getacqpath.com/): Your agents may log the URL without preserving observable rights/TDM declarations. AcqPath adds verifiable source-rights observations for reviews and AI workflows. - [Keep the source-rights record beside your AI workflow](https://developers.getacqpath.com/partners): A source URL in a tool trace may not preserve what the page declared. Add verifiable evidence without replacing your crawler, MCP gateway or policy engine. - [Prove the evidence gap in 25 events, not 30 days](https://developers.getacqpath.com/partners/proof-sprint): A 15–30 minute integration. Three events prove the path; 25 eligible events or 6 hours is the normal decision gate, with a hard cap of 50 events or 24 hours. - [Shadow mode: observe without blocking](https://developers.getacqpath.com/partners/shadow-mode): Run AcqPath in parallel, preserve the existing result path, and collect signed evidence for a fast integration proof. - [Integrate source-rights evidence without rebuilding your tools](https://developers.getacqpath.com/partners/integration-kit): Preserve observable declarations and uncertainty alongside the URL your web agents, crawlers or RAG pipelines already process. - [rights-evidence.resolution.v1](https://developers.getacqpath.com/partners/evidence-contract): A provider-neutral contract that separates source-rights evidence from transport state and from the consumer-owned policy decision. - [What did the source declare before the tool ran?](https://developers.getacqpath.com/partners/gateway): Attach verified source-rights evidence to URL-bearing tool calls. Your gateway still owns the decision and enforcement. - [A crawler result should carry more than a URL](https://developers.getacqpath.com/partners/crawler): Attach an observation of machine-readable usage declarations to eligible public-web results without changing crawling behavior or bypassing access controls. - [When content enters a corpus, preserve the source evidence](https://developers.getacqpath.com/partners/rag): A later audit needs more than the ingestion timestamp. Keep verifiable source-rights observations beside document provenance. - [Give policy decisions an evidence input, not another verdict](https://developers.getacqpath.com/partners/policy-engine): Use an independent observation of source declarations as one policy input. Your current engine retains allow, deny and review authority. - [From a source URL to a verifiable rights observation](https://developers.getacqpath.com/quickstart): Record what an eligible public HTTPS source declares for the intended use, review the exact purchase terms, and verify the evidence before attaching it to your existing workflow. - [Connect AcqPath to an MCP client](https://developers.getacqpath.com/connect): Remote Streamable HTTP at api.getacqpath.com/mcp. No seller API key is required for public capabilities and quote preparation. - [Rights evidence in an agent workflow](https://developers.getacqpath.com/integrations): Choose the purpose, preserve evidence and keep the ingestion decision in your application. Framework-neutral examples use the same bounded buyer adapter. - [Coverage, decisions and limitations](https://developers.getacqpath.com/scope): Dynamic public HTTPS eligibility on secure routes, a separate reviewed origin set and clear limits. UNKNOWN never becomes permission. - [0.02 USDC fresh. 0.05 USDC deep.](https://developers.getacqpath.com/pricing): Get a verifiable source-rights observation with the existing per-report x402 price disclosed before payment. No subscription or walletless plan is live. - [Uncertain delivery shouldn't mean a second payment](https://developers.getacqpath.com/recovery): Resume the same privately stored authorization and operation after a timeout. Preserve source, purpose and verified delivery binding. - [The AcqPath HTTP x402 purchase contract](https://developers.getacqpath.com/http-x402): Quote first, private claim second, signed payment third. This is a multi-step report flow, not a generic one-call paid MCP tool. - [Your agent fetched the page. What did the source declare?](https://developers.getacqpath.com/ai-input): A tool trace preserves where the page came from. Keep a signed observation of available rights/TDM signals for AI input beside it. - [Don't lose source-rights context at ingestion](https://developers.getacqpath.com/rag-ingestion): Record what was observable when external content entered your RAG pipeline; preserve provenance, uncertainty and the declared purpose. - [Indexing creates provenance. Preserve usage declarations too.](https://developers.getacqpath.com/indexing-search): Keep a timestamped source-rights observation beside the indexed URL and your search workflow. - [A dataset URL is not a training-rights record](https://developers.getacqpath.com/training): Before training ingestion, document available machine-readable declarations for ai-train. Missing evidence never authorizes model training. - [Can I crawl this URL? Keep crawl and AI use separate.](https://developers.getacqpath.com/crawl): AcqPath does not offer a paid crawl-permission product. Evaluate actual downstream AI input, indexing, training or search declarations separately. - [Marketplace and x402 compatibility](https://developers.getacqpath.com/bazaar-status): Current buyer contracts, supported client modes and live verification sources for AcqPath x402 integrations. - [Can I use this URL for RAG?](https://developers.getacqpath.com/rag-rights): Preflight a source before adding it to a retrieval corpus. Later model use may need a separate ai-input check; do not silently buy both. - [Does this page declare restrictions before crawling?](https://developers.getacqpath.com/crawl-rights): There is no paid crawl purpose and this service does not fetch content for you. Apply robots.txt, access controls and your crawler policy first; use ai-input only for planned downstream AI processing. - [Can I summarize or use this page as AI input?](https://developers.getacqpath.com/ai-input-rights): Check declared usage terms before research, summarization or adding a web page to model context. - [Can I train on this content?](https://developers.getacqpath.com/training-rights): Check declarations before adding a supported URL to a training dataset. A report does not acquire training rights. - [Can I index this content?](https://developers.getacqpath.com/indexing-rights): Use search for a search pipeline; choose ai-index for an AI/RAG index. Keep the purpose aligned with the actual downstream use. - [Preflight a URL through one stable HTTP endpoint](https://developers.getacqpath.com/public-http): Account-free declared-rights evidence for autonomous content use. Start without payment and check client compatibility before spending. - [Batch rights checks and policy revalidation](https://developers.getacqpath.com/gateway): Check up to four reviewed URLs before AI ingestion; detect observed policy changes on repeat use. Exact Base USDC pricing and verified TS/Python delivery. - [Stock x402 marketplace Rights Preflight](https://developers.getacqpath.com/stock-x402): Fresh Rights Preflight at 0.02 USDC on Base with unmodified official TS/Python x402 buyers. Separate first-use binding model; no SIWX. ## Machine-readable assets - [Agent skill](https://developers.getacqpath.com/SKILL.md) - [OpenAPI subset](https://developers.getacqpath.com/openapi.json) - [Service metadata](https://developers.getacqpath.com/service.json) - [Discovery profile](https://developers.getacqpath.com/.well-known/acqpath-distribution.json) - [Capabilities snapshot](https://developers.getacqpath.com/capabilities.json) - [Pricing snapshot](https://developers.getacqpath.com/pricing.json) - [MCP configuration](https://developers.getacqpath.com/mcp-config.json) - [Input examples](https://developers.getacqpath.com/examples.json) - [Documented tools](https://developers.getacqpath.com/mcp-tools.json) - [Full reference](https://developers.getacqpath.com/llms-full.txt) ## Rights Gateway Dynamic HTTPS applies to Secure Preflight and Gateway; the separate Stock x402 route is reviewed-only. Ingestion Gate: POST /v1/rights/ingestion-gate, 1–4 reviewed URLs. Fresh 0.04 + 0.02 per unique URL; deep 0.06 + 0.04 USDC. Revalidate: POST /v1/rights/revalidate, authentic prior checkpoint, fresh 0.03 / deep 0.06 USDC. Gateway fees buy bounded observation including UNKNOWN. Same official TS/Python + AcqPath SIWX adapter. No domain completeness or legal clearance. Guide: https://developers.getacqpath.com/examples/GATEWAY.md ## Full integration reference # A source URL is not a source-rights record Canonical: https://developers.getacqpath.com/ Your agents may log the URL without preserving observable rights/TDM declarations. AcqPath adds verifiable source-rights observations for reviews and AI workflows. ## The URL is not the source-rights record Agents, crawlers and RAG pipelines often record which page they fetched. That log alone may not preserve machine-readable rights/TDM declarations visible when the source was checked. If the record is missing, a later review cannot reliably reconstruct that earlier observation merely by reopening the page. ## Why the missing evidence matters A source may declare a restriction, require a licence or expose no usable declaration. Without a timestamped observation, reviewers have less context for evaluating how a source entered an AI workflow. Declarations can change. AcqPath does not claim that every URL grants permission, and does not replace an application's own rights review. ## Illustrative example: before and after Without a source-rights observation: resource URL recorded, ingestion event recorded, source-rights declaration at check time not captured. With an AcqPath observation: resource and declared purpose, observed decision such as LICENSE_REQUIRED, source hash, observation time and signed evidence for later review. Illustrative only, not a live report about a real publisher. A meaningful source check may return UNKNOWN or unavailable; neither grants permission. ## Add the evidence layer; keep policy control AcqPath inspects available public source-rights signals for a declared purpose and preserves a verifiable observation. Your existing tools keep running, and your application's policy remains responsible for allow, deny or review. Start with one eligible public HTTPS URL, inspect the prepared outcome and exact payment terms, then verify the signed report before attaching it to the audit or provenance record. - [View the partner evidence contract](https://developers.getacqpath.com/partners/evidence-contract) - [Start integrating](https://developers.getacqpath.com/quickstart) ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Partner integrations: prove value in 25 events Do not replace your policy engine on day one. Run AcqPath beside the existing workflow. Three eligible events prove the integration path; the normal commercial decision gate is 25 eligible events or 6 hours, with a hard cap of 50 events or 24 hours. The existing request still executes. AcqPath adds verified source-rights evidence to an audit stream. If the evidence gap is useful, increase paid attach rate immediately instead of waiting through a long pilot. - [Partner integration paths](https://developers.getacqpath.com/partners) - [25-event Proof Sprint](https://developers.getacqpath.com/partners/proof-sprint) ## Preflight one URL, with no AcqPath account POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Start the public HTTP journey](https://developers.getacqpath.com/public-http) - [RAG rights](https://developers.getacqpath.com/rag-rights) - [Training rights](https://developers.getacqpath.com/training-rights) ## Connect once. Keep payment in your application. MCP endpoint: https://api.getacqpath.com/mcp MCP exposes capabilities and quote preparation. A generic chat host does not complete payment. Keep private quote claims outside model context. ```text { "mcpServers": { "acqpath": { "url": "https://api.getacqpath.com/mcp" } } } ``` - [MCP configuration examples](https://developers.getacqpath.com/connect) - [HTTP/x402 quickstart](https://developers.getacqpath.com/quickstart) ## Choose the actual use AI input: ai-input. Indexing and RAG corpus preparation: ai-index. Training: ai-train. Search: search. RAG may need both ai-index and ai-input. Crawl permission and robots.txt checks are separate. - [AI input](https://developers.getacqpath.com/ai-input) - [RAG / ingestion](https://developers.getacqpath.com/rag-ingestion) - [Indexing / search](https://developers.getacqpath.com/indexing-search) - [Training](https://developers.getacqpath.com/training) - [Crawler boundary](https://developers.getacqpath.com/crawl) ## Know the scope before buying LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. A report may be UNKNOWN, unavailable or incomplete. No observation is a license or legal clearance. The caller policy remains authoritative. - [Current API capabilities](https://api.getacqpath.com/v1/capabilities) - [Coverage and decision meanings](https://developers.getacqpath.com/scope) ## Live integration contract Use the public status page, live capabilities endpoint and prepared x402 response as the current source of truth for availability, coverage and payment terms. Internal rollout state is not part of the buyer contract. - [Service status](https://status.getacqpath.com) - [Live capabilities](https://api.getacqpath.com/v1/capabilities) ## Separate stock marketplace endpoint SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Same signed authorization plus same normalized request recovers the existing stock result; changed input or another route is rejected after binding. A pre-use leaked stock authorization can be raced for another same-priced request. Keep signed HTTP requests private. Never create a replacement authorization after an uncertain payment. - [Stock endpoint, JSON, official TypeScript/Python and recovery](https://developers.getacqpath.com/stock-x402) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) # Keep the source-rights record beside your AI workflow Canonical: https://developers.getacqpath.com/partners A source URL in a tool trace may not preserve what the page declared. Add verifiable evidence without replacing your crawler, MCP gateway or policy engine. ## What will your team show during a later review? A tool trace usually identifies the URL and execution. It may not retain the machine-readable licence conditions or restrictions that were observable when the source was checked. AcqPath adds a source-rights observation record to the existing workflow. Your customer policy remains responsible for enforcement; Observe mode does not change the original action. - [See evidence contract](https://developers.getacqpath.com/partners/evidence-contract) ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Start with evidence. Decide on enforcement later. The first integration mode is Observe: AcqPath runs beside the existing request path and writes evidence to your audit stream. Nothing is blocked and no existing policy is replaced. Three eligible events prove the integration path. Any material rights/drift signal can end the sprint early. Otherwise use 25 eligible events or 6 hours as the normal commercial gate; never exceed 50 events or 24 hours. ```text existing request ───────────────→ existing execution └─→ AcqPath Evidence → audit log 3 events = integration smoke test 25 events / 6h = normal decision gate 50 events / 24h = hard stop ``` - [Run the 25-event Proof Sprint](https://developers.getacqpath.com/partners/proof-sprint) - [Shadow-mode pattern](https://developers.getacqpath.com/partners/shadow-mode) ## One provider-neutral evidence contract Every integration consumes rights-evidence.resolution.v1. Evidence statements are declared_permitted, declared_prohibited, license_required or unknown. Transport states are resolved, unavailable, unsupported or invalid. AcqPath never maps that evidence to your final allow/deny decision. The consumer-owned policy engine remains authoritative. - [Evidence contract](https://developers.getacqpath.com/partners/evidence-contract) - [JSON Schema](https://developers.getacqpath.com/packages/evidence-bridge/schemas/resolution-v1.json) ## Choose the architecture you already have AI or MCP gateway: observe tool calls and pass the normalized evidence into the existing policy engine. Crawler or search API: attach rightsEvidence beside the existing URL/content result. RAG: persist source_rights with document provenance. Policy engine: consume an attested evidence input without moving enforcement into AcqPath. - [Gateway pattern](https://developers.getacqpath.com/partners/gateway) - [Crawler pattern](https://developers.getacqpath.com/partners/crawler) - [RAG pattern](https://developers.getacqpath.com/partners/rag) - [Policy-engine pattern](https://developers.getacqpath.com/partners/policy-engine) ## What a typical audit trail may not capture A normal audit log can prove who acted, which tool executed, the URL and the timestamp. It may not preserve what the publisher declared about machine use at that time, the signed source-state evidence behind the decision, or later declaration drift. If your system already captures those fields, AcqPath fits as the external evidence source behind them rather than replacing your audit or governance layer. ## Build internally vs integrate Building this internally means maintaining declaration discovery, RSL parsing, purpose mapping, conflict handling, source hashing, timestamps, signatures, freshness, caching, retry semantics, revalidation, drift detection, URL normalization and SSRF controls. AcqPath collapses those evidence concerns behind one provider-neutral contract while your application keeps policy and enforcement. - [30-minute integration kit](https://developers.getacqpath.com/partners/integration-kit) ## Current production boundary Secure Preflight and Gateway accept eligible public HTTPS origins beyond the four independently reviewed publishers, with signed relay, robots/DNS/TLS controls and bounded per-origin budgets. Stock x402 is a separate reviewed-only route. Missing declarations can yield UNKNOWN. A customer-owned Base USDC x402 buyer is still required for paid reports. Walletless API keys, prepaid credits, invoices and subscriptions are not live. A neutral adapter can map URLs and a configured shadow-mode purpose without replacing the partner policy engine. - [Current live capabilities](https://api.getacqpath.com/v1/capabilities) - [Current Gateway limits](https://developers.getacqpath.com/gateway) # Prove the evidence gap in 25 events, not 30 days Canonical: https://developers.getacqpath.com/partners/proof-sprint A 15–30 minute integration. Three events prove the path; 25 eligible events or 6 hours is the normal decision gate, with a hard cap of 50 events or 24 hours. ## 1. Connect beside the existing workflow Use the provider-neutral Evidence Bridge and one architecture adapter. Keep the existing request path unchanged. The sprint begins in Observe mode only. Use explicit intended purpose for every event: ai-input, ai-index, ai-train or search. Do not infer purpose from a tool name. - [Integration kit](https://developers.getacqpath.com/partners/integration-kit) - [Shadow gateway example](https://developers.getacqpath.com/examples/gateway-shadow.mjs) ## 2. Stop at the first commercial gate Do not wait for 100 events. After three eligible events the integration path is proven. A material rights/drift signal can produce GO immediately. Otherwise decide at 25 eligible events or 6 hours; extend only when inconclusive and never beyond 50 events or 24 hours. At the current 0.02 USDC fresh single-resource Preflight price, 25 paid fresh reports correspond to 0.50 USDC and 50 to 1.00 USDC. The live prepared 402 is always authoritative, and Preflight events with no paid offer are not equivalent to paid reports. ## 3. Generate the local report Keep shadow events in your own environment as NDJSON. Start the local watcher once; it monitors the file, prints progress, and stops automatically on GO, REVIEW or STOP_OR_FIX. Raw URLs and evidence do not need to leave the partner environment. ```text node examples/proof-sprint.mjs events.ndjson ``` - [Automatic Proof Sprint watcher](https://developers.getacqpath.com/examples/proof-sprint.mjs) - [One-shot report generator](https://developers.getacqpath.com/examples/shadow-report.mjs) - [Sample events](https://developers.getacqpath.com/examples/shadow-events.ndjson) ## 4. Convert immediately when value is visible The local report returns GO, REVIEW, EXTEND or STOP_OR_FIX. GO means a material rights/drift signal appeared. REVIEW means verified evidence exists but the buyer should compare it with its existing audit trail. EXTEND may run only to 50 events / 24 hours. STOP_OR_FIX means the yield is too weak or eligibility/integration needs correction. If none of those happen, stop. The sprint is designed to produce a fast yes/no decision, not to manufacture a long pilot. # Shadow mode: observe without blocking Canonical: https://developers.getacqpath.com/partners/shadow-mode Run AcqPath in parallel, preserve the existing result path, and collect signed evidence for a fast integration proof. ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Execution contract The existing tool call, crawl or ingestion operation remains authoritative during shadow mode. Evidence resolution runs beside it and writes a separate audit event. Evidence failure must not change the existing result in Observe mode. Use the hosting platform background primitive when available, such as waitUntil, a queue or a durable job. Do not rely on an unobserved promise if the process may terminate immediately. ```text const result = await existingToolCall(); background(resolveEvidence().then(audit.write)); return result; // no enforcement in Observe mode ``` - [Runnable gateway shadow pattern](https://developers.getacqpath.com/examples/gateway-shadow.mjs) ## Four adoption modes OBSERVE: log evidence only. ATTACH: add evidence to the returned result or document metadata. ADVISE: pass evidence into the existing policy engine. ENFORCE: the partner policy engine may block or route based on its own rule. AcqPath provides the evidence contract in every mode. It does not become the partner policy engine. ## Failure semantics resolved means verified evidence is available. unavailable means the provider or source could not produce a usable result. unsupported means the requested purpose or source is outside the supported contract. invalid means evidence failed validation. A semantic unknown is still resolved evidence with statement unknown. Do not collapse unknown and unavailable into the same state. ## Deployment-configured purpose is explicit When a tool call has a public URL but no declared user intent, the owning customer may explicitly set ai-input or another supported purpose as a deployment default for Observe only. The audit record must label purpose_source=configured_default. Do not replace an explicitly invalid purpose with a default. This is not authorization for new content use, autonomous purchasing or enforcement. Paid buyers use the separate x402 flow. - [Observe adapter](https://developers.getacqpath.com/examples/PARTNER-OBSERVE.md) # Integrate source-rights evidence without rebuilding your tools Canonical: https://developers.getacqpath.com/partners/integration-kit Preserve observable declarations and uncertainty alongside the URL your web agents, crawlers or RAG pipelines already process. ## What changes after integration? Before: your tool returns a URL and content, while source-rights declarations at observation time may be missing from the record. After: the same tool still runs; a separate provider-neutral record can identify the resource and intended use and retain verified rights evidence with a timestamp and source reference. Example only. A missing declaration, UNKNOWN or provider outage does not mean content use is authorized. - [Read the neutral resolution schema](https://developers.getacqpath.com/partners/evidence-contract) ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Purpose for URL-bearing tools without user intent A partner may explicitly configure ai-input as a deployment-level shadow default. Mark the resulting purpose_source as configured_default in the audit context. Never infer user intent from a tool name or override a malformed explicit purpose. The tool continues unchanged in Observe mode. AcqPath provides evidence, not a policy verdict; real paid evidence requires customer-controlled x402 authorization and budget limits. - [Partner Observe adapter reference](https://developers.getacqpath.com/examples/PARTNER-OBSERVE.md) ## Architecture AcqPath is the external evidence provider. Your existing gateway, crawler, ingestion layer or policy engine remains the execution and enforcement owner. ```text Agent / Crawler / RAG ↓ AcqPath Evidence Bridge ↓ rights-evidence.resolution.v1 ↓ Your audit / policy engine / metadata ``` - [Evidence Bridge README](https://developers.getacqpath.com/packages/evidence-bridge/README.md) - [Resolution schema](https://developers.getacqpath.com/packages/evidence-bridge/schemas/resolution-v1.json) ## Copy-paste patterns Use the smallest adapter matching the existing architecture. The partner-specific work should be field mapping, not a new policy engine. - [Gateway shadow](https://developers.getacqpath.com/examples/gateway-shadow.mjs) - [Crawler enrichment](https://developers.getacqpath.com/examples/crawler-enrichment.mjs) - [RAG ingestion metadata](https://developers.getacqpath.com/examples/rag-ingestion.mjs) - [Policy-engine input](https://developers.getacqpath.com/examples/policy-engine-input.mjs) ## 30-minute technical path 0–5 min: read live capabilities and choose intended purpose. 5–15 min: wire Evidence Bridge to the existing buyer flow. 15–25 min: write shadow events to the local audit stream. 25–30 min: send the first eligible event and confirm a verified evidence_ref or an explicit unsupported/unavailable state. Then start the local Proof Sprint watcher. It monitors the partner-owned NDJSON stream and automatically prints the commercial verdict; raw URLs do not need to leave the partner environment. - [Proof Sprint](https://developers.getacqpath.com/partners/proof-sprint) - [Live capabilities](https://api.getacqpath.com/v1/capabilities) ## Security boundary Pin the evidence verification key and exact payment terms. Keep claims, signatures, checkpoint data and recovery state private. Do not put them in prompts, analytics, support tickets or logs. AcqPath reports observed declarations. It does not establish publisher ownership, grant a license or provide legal clearance. ## Production limits you should design around Dynamic HTTPS eligibility is live on Secure Preflight and Gateway with bounded global/per-origin quotas. The four reviewed origin entries remain a separate set, and Stock x402 retains only those four. Do not promise universal crawl access or report availability. Integrations require backpressure, a stable operation identity, private recovery checkpoints and customer-authorized payment budget. API-key billing, subscriptions and invoices are not active. See the portable Observe adapter. - [Observe adapter and fixtures](https://developers.getacqpath.com/examples/PARTNER-OBSERVE.md) # rights-evidence.resolution.v1 Canonical: https://developers.getacqpath.com/partners/evidence-contract A provider-neutral contract that separates source-rights evidence from transport state and from the consumer-owned policy decision. ## Evidence statements declared_permitted, declared_prohibited, license_required and unknown describe the observed source-rights evidence. None of them is a legal clearance. ## Resolution states resolved, unavailable, unsupported and invalid describe whether usable evidence was produced. A resolved unknown is intentionally different from an unavailable provider/source. ## Canonical shape The request binds resource and explicit intended purpose. Verified evidence includes provider, observation time, optional expiry and an evidence_ref that can be retained with the partner audit record. ```text { "schema": "rights-evidence.resolution.v1", "status": "resolved", "request": { "schema": "rights-evidence.request.v1", "resource": "https://example.com/article", "intended_use": {"purpose": "ai-index"}, "context": {} }, "evidence": [{ "schema": "rights-evidence.v1", "kind": "source_rights_declaration", "statement": "license_required", "provenance": { "provider": "AcqPath", "observed_at": "2026-10-07T08:00:00Z", "evidence_ref": "urn:acqpath:evidence:sha256:..." }, "verification": {"status": "verified", "algorithm": "Ed25519"} }], "error": null } ``` - [Resolution JSON Schema](https://developers.getacqpath.com/packages/evidence-bridge/schemas/resolution-v1.json) - [Bridge source](https://developers.getacqpath.com/packages/evidence-bridge/index.mjs) # What did the source declare before the tool ran? Canonical: https://developers.getacqpath.com/partners/gateway Attach verified source-rights evidence to URL-bearing tool calls. Your gateway still owns the decision and enforcement. ## Why this evidence matters Attach verified source-rights evidence to URL-bearing tool calls. Your gateway still owns the decision and enforcement. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Start in Observe mode Extract the selected source URL and explicit intended purpose from the gateway context. Resolve evidence in parallel with the existing tool call and write the resolution to the gateway audit stream. Do not make AcqPath the first enforcement point. Prove the evidence gap at the 25-event / 6-hour decision gate, or earlier if a material signal appears, then move to Advise or partner-owned Enforce if useful. - [Gateway shadow code](https://developers.getacqpath.com/examples/gateway-shadow.mjs) - [Shadow semantics](https://developers.getacqpath.com/partners/shadow-mode) ## Policy handoff When the partner is ready, serialize the same resolution into an attested policy input. The existing policy engine decides allow, deny, warn or review. - [Policy input adapter](https://developers.getacqpath.com/examples/policy-engine-input.mjs) # A crawler result should carry more than a URL Canonical: https://developers.getacqpath.com/partners/crawler Attach an observation of machine-readable usage declarations to eligible public-web results without changing crawling behavior or bypassing access controls. ## Why this evidence matters Attach an observation of machine-readable usage declarations to eligible public-web results without changing crawling behavior or bypassing access controls. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Attach one field Keep the existing URL, content and metadata response. Add rightsEvidence containing the provider-neutral resolution for the explicit machine-use purpose. This is an Attach-mode integration: the consumer can log, display or route on the evidence later. Unsupported sources remain explicit rather than silently allowed. ```text { "url": "https://example.com/article", "markdown": "...", "rightsEvidence": { "schema": "rights-evidence.resolution.v1", "status": "resolved", "evidence": [{"statement": "license_required"}] } } ``` - [Crawler enrichment code](https://developers.getacqpath.com/examples/crawler-enrichment.mjs) ## Current scale boundary The public gateway is not an arbitrary-domain high-volume crawler. Today use reviewed coverage and bounded operations. Large embedded crawler volume should move to the future reviewed partner-origin registry + asynchronous batch path rather than weakening SSRF controls. # When content enters a corpus, preserve the source evidence Canonical: https://developers.getacqpath.com/partners/rag A later audit needs more than the ingestion timestamp. Keep verifiable source-rights observations beside document provenance. ## Why this evidence matters A later audit needs more than the ingestion timestamp. Keep verifiable source-rights observations beside document provenance. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Attach evidence to provenance For corpus preparation use the actual purpose, normally ai-index; model-context use may require a separate ai-input evaluation. RAG is a workflow, not a purpose value. In Observe or Attach mode, preserve the existing ingestion path and add source_rights metadata. Later the partner policy engine may decide whether a statement should block or require review. - [RAG evidence code](https://developers.getacqpath.com/examples/rag-ingestion.mjs) - [RAG rights guide](https://developers.getacqpath.com/rag-ingestion) # Give policy decisions an evidence input, not another verdict Canonical: https://developers.getacqpath.com/partners/policy-engine Use an independent observation of source declarations as one policy input. Your current engine retains allow, deny and review authority. ## Why this evidence matters Use an independent observation of source declarations as one policy input. Your current engine retains allow, deny and review authority. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Evidence in, partner decision out AcqPath returns source-rights evidence and verification state. The partner policy engine maps that evidence to allow, deny, warn or review according to its own policy. This keeps policy ownership auditable and avoids coupling AcqPath evidence semantics to one enforcement product. - [Policy input adapter](https://developers.getacqpath.com/examples/policy-engine-input.mjs) - [Evidence contract](https://developers.getacqpath.com/partners/evidence-contract) # From a source URL to a verifiable rights observation Canonical: https://developers.getacqpath.com/quickstart Record what an eligible public HTTPS source declares for the intended use, review the exact purchase terms, and verify the evidence before attaching it to your existing workflow. ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Separate stock marketplace endpoint SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Same signed authorization plus same normalized request recovers the existing stock result; changed input or another route is rejected after binding. A pre-use leaked stock authorization can be raced for another same-priced request. Keep signed HTTP requests private. Never create a replacement authorization after an uncertain payment. - [Stock endpoint, JSON, official TypeScript/Python and recovery](https://developers.getacqpath.com/stock-x402) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Start with the stable public endpoint POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Public buyer journey](https://developers.getacqpath.com/public-http) ## Official TypeScript / Node and Python integration SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Add the AcqPath transport adapter, independently pinned service terms/key, private durable store, explicit buyer opt-in and stable operation ID. It adds one unsigned prebinding round trip and one official SIWX signature; the stock payment signer is unchanged. Use the same operation ID, body and store after response loss. Never replace a pending authorization. EOA only; private-store retention and Python canonical-input limits are explained in the guide. - [Complete configured-client guide](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) - [TypeScript / Node adapter](https://developers.getacqpath.com/examples/acqpath.mjs) - [Node integration example](https://developers.getacqpath.com/examples/official-node.mjs) - [Pinned Node manifest](https://developers.getacqpath.com/examples/official-client-package.json) - [Python adapter](https://developers.getacqpath.com/examples/acqpath_httpx.py) - [Python integration example](https://developers.getacqpath.com/examples/official-python.py) - [Pinned Python requirements](https://developers.getacqpath.com/examples/official-requirements.txt) ## 1. Check eligibility and declare purpose Read /v1/capabilities. coverage_mode=PUBLIC_HTTPS_DYNAMIC_WITH_SAFETY_GATE and dynamic_public_https=true distinguish eligible public HTTPS from reviewed origins. Stock x402 remains reviewed-only. Supply the intended purpose explicitly (ai-input, ai-index, ai-train or search). Use deployment defaults only when configured by the owning partner for Observe. Query, credentials, fragments, private IPs and nonstandard ports are rejected. ```text GET https://api.getacqpath.com/v1/capabilities ``` - [Read-only JavaScript example](https://developers.getacqpath.com/examples/read-only.mjs) - [Read-only Python example](https://developers.getacqpath.com/examples/read-only.py) ## 2. Prepare and buy through the supported adapter Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. A selected real resource can consume metadata quota even before payment. Reuse one stable operation ID. The prepared 402 binds this input; an empty POST only describes the service. The guide includes exact dependency installation and calls with your existing buyer-controlled EOA signer. - [Copy-paste TS/Python instructions](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) ## 3. Handle unavailable and UNKNOWN available:false with NO_VERIFIABLE_DECLARATION has no report fee. A discovered but unsupported declaration can produce a purchasable UNKNOWN report. Inspect the preview and decide whether diagnostic evidence is worth buying. UNKNOWN, missing declarations, unsupported origins and LICENSE_REQUIRED do not authorize use. A report records observed RSL declarations; it is not a license or legal clearance. ## 4. Reuse the integration safely Use one stable logical purchase ID for one resource/purpose/context request. Resume an existing checkpoint after a timeout. Start a new purchase only for a deliberately new evidence request. AcqPath adapters are supplied as source, not published npm/PyPI packages. Install their pinned official dependencies and follow the configured-client guide. ```text git clone https://github.com/reflectme-source/acqpath-distribution.git cd acqpath-distribution node examples/read-only.mjs ``` - [Source repository](https://github.com/reflectme-source/acqpath-distribution) - [Recovery decisions](https://developers.getacqpath.com/recovery) ## Existing legacy integrations The quote → private claim → report URL SDK remains available for existing users. New integrations use the public SIWX adapter above; no custom payment nonce is needed. - [Legacy source example](https://developers.getacqpath.com/examples/evidence-gate.mjs) # Connect AcqPath to an MCP client Canonical: https://developers.getacqpath.com/connect Remote Streamable HTTP at api.getacqpath.com/mcp. No seller API key is required for public capabilities and quote preparation. ## Separate stock marketplace endpoint SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Same signed authorization plus same normalized request recovers the existing stock result; changed input or another route is rejected after binding. A pre-use leaked stock authorization can be raced for another same-priced request. Keep signed HTTP requests private. Never create a replacement authorization after an uncertain payment. - [Stock endpoint, JSON, official TypeScript/Python and recovery](https://developers.getacqpath.com/stock-x402) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Current supported buyer integration SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Fresh 0.02 USDC; deep 0.05 USDC on Base eip155:8453. Pin the exact recipient, USDC asset, fee and Ed25519 verification key. The adapter verifies offer, report, receipt and delivery binding. Private checkpoint files retain bearer authorizations and are not application-level encrypted; protect them with private ACLs and encrypted storage. - [Install, call and verify: complete TS/Python guide](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) - [Public buyer journey](https://developers.getacqpath.com/public-http) ## Cursor / generic mcpServers configuration Use a client that supports remote Streamable HTTP. Keep quote results containing claim_token in a private application path, not a shared conversation. ```text { "mcpServers": { "acqpath": { "url": "https://api.getacqpath.com/mcp" } } } ``` ## VS Code mcp.json Add the remote server to a workspace MCP configuration after reviewing its tool permissions. ```text { "servers": { "acqpath": { "type": "http", "url": "https://api.getacqpath.com/mcp" } } } ``` ## Claude Code This registers the public endpoint. It does not authorize a wallet or implement paid HTTP redemption. ```text claude mcp add --transport http acqpath https://api.getacqpath.com/mcp ``` ## Tools and payment boundary acqpath_capabilities: read current capability metadata. acqpath_rights_quote: prepare a report quote; may fetch metadata and consume quota; returns a sensitive claim. The runtime also lists a disabled legacy provider-routing tool. Exclude acqpath_quote from the integration allowlist. The distribution metadata cannot change the core tools/list response. Initialize and list tools to test the connection. Only call quote when the selected supported resource actually needs evidence. - [Documented tool schemas](https://developers.getacqpath.com/mcp-tools.json) - [HTTP payment and verification](https://developers.getacqpath.com/http-x402) # Rights evidence in an agent workflow Canonical: https://developers.getacqpath.com/integrations Choose the purpose, preserve evidence and keep the ingestion decision in your application. Framework-neutral examples use the same bounded buyer adapter. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Current supported buyer integration SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Fresh 0.02 USDC; deep 0.05 USDC on Base eip155:8453. Pin the exact recipient, USDC asset, fee and Ed25519 verification key. The adapter verifies offer, report, receipt and delivery binding. Private checkpoint files retain bearer authorizations and are not application-level encrypted; protect them with private ACLs and encrypted storage. - [Install, call and verify: complete TS/Python guide](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) - [Public buyer journey](https://developers.getacqpath.com/public-http) ## RAG and ingestion gates Call before adding selected supported URLs to a corpus. Use ai-index for indexing, then separately ai-input for model context if needed. UNKNOWN or unsupported results hold ingestion. - [RAG / ingestion guide](https://developers.getacqpath.com/rag-ingestion) - [TypeScript workflows](https://developers.getacqpath.com/examples/workflows.ts) ## Research agents Evaluate selected sources before summarization or model context with ai-input. Store the verified resource, purpose and evaluation time alongside provenance. Do not quote every search result. - [AI input guide](https://developers.getacqpath.com/ai-input) ## Crawlers Crawl authorization is separate. Use your robots/access policy before retrieval, then the actual downstream paid purpose before ingestion. Do not send crawl as a paid quote purpose. - [Crawler boundary](https://developers.getacqpath.com/crawl) ## One reusable buyer adapter Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. The examples expose no wallet key interface and make no payment when imported or run in read-only mode. Supply your own bounded signer only in a private buyer application. - [JavaScript adapter](https://developers.getacqpath.com/examples/evidence-gate.mjs) - [Framework-neutral workflow contract](https://developers.getacqpath.com/examples/workflow.json) - [Example guide](https://github.com/reflectme-source/acqpath-distribution/blob/main/examples/README.md) # Coverage, decisions and limitations Canonical: https://developers.getacqpath.com/scope Dynamic public HTTPS eligibility on secure routes, a separate reviewed origin set and clear limits. UNKNOWN never becomes permission. ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Observed coverage Reviewed exact origins: medium.com, theguardian.com, rslstandard.org and rslcollective.org. These four origin entries are not the total eligible HTTPS source universe. Read coverage_mode and dynamic_public_https in production capabilities. Dynamic acceptance has public-network restrictions, robots controls and bounded global/per-origin budgets. Some sources expose no verifiable declaration. Stock x402 only supports reviewed origins. - [Live capabilities](https://api.getacqpath.com/v1/capabilities) - [Capability snapshot](https://developers.getacqpath.com/capabilities.json) ## Decision vocabulary ALLOW_DECLARED: the supported profile observed a relevant allowance. DENY_DECLARED: a relevant prohibition was observed. LICENSE_REQUIRED: a licensing requirement was observed. UNKNOWN: insufficient, conflicting or unsupported evidence. None of these outcomes verifies ownership. AcqPath does not acquire licenses or grant legal clearance. ## What is not offered No unrestricted crawl, guaranteed source access, license acquisition, ownership verification, provider-routing purchase, paid MCP delivery, automatic refund or legal clearance is offered. Dynamic HTTPS is safety-gated evidence collection, not permission for all websites. One analysis may require multiple public metadata fetches. Current quotas and the single Railway relay have not been load-certified for 100,000 URLs per month. A signed report is not independent on-chain reconciliation. # 0.02 USDC fresh. 0.05 USDC deep. Canonical: https://developers.getacqpath.com/pricing Get a verifiable source-rights observation with the existing per-report x402 price disclosed before payment. No subscription or walletless plan is live. ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Explicit report prices LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. The signed prepared quote controls the exact amount, network and recipient. AcqPath does not sell a license to publisher content. - [Machine-readable pricing](https://developers.getacqpath.com/pricing.json) - [Live capability prices](https://api.getacqpath.com/v1/capabilities) ## Unavailability and diagnostic value A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. No Stripe Checkout, API key, prepaid credits, subscription, walletless invoice or volume plan is live. Those are isolated design work pending certification. ## Economics and recovery Quote/fetch quotas, rate limits and infrastructure constraints are separate from price. No volume discount or subscription is currently implemented. After ambiguous payment submission, resume the original private checkpoint. A refund request is an operator-reviewed record, not an automatic transfer. # Uncertain delivery shouldn't mean a second payment Canonical: https://developers.getacqpath.com/recovery Resume the same privately stored authorization and operation after a timeout. Preserve source, purpose and verified delivery binding. ## Why this evidence matters Resume the same privately stored authorization and operation after a timeout. Preserve source, purpose and verified delivery binding. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Separate stock marketplace endpoint SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Same signed authorization plus same normalized request recovers the existing stock result; changed input or another route is rejected after binding. A pre-use leaked stock authorization can be raced for another same-priced request. Keep signed HTTP requests private. Never create a replacement authorization after an uncertain payment. - [Stock endpoint, JSON, official TypeScript/Python and recovery](https://developers.getacqpath.com/stock-x402) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Current supported buyer integration SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Fresh 0.02 USDC; deep 0.05 USDC on Base eip155:8453. Pin the exact recipient, USDC asset, fee and Ed25519 verification key. The adapter verifies offer, report, receipt and delivery binding. Private checkpoint files retain bearer authorizations and are not application-level encrypted; protect them with private ACLs and encrypted storage. - [Install, call and verify: complete TS/Python guide](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) - [Public buyer journey](https://developers.getacqpath.com/public-http) ## SIWX adapter recovery Resume the same operation ID, input and durable private directory. The exact saved payment and SIWX proof are reused; a pending or uncertain operation must not receive a replacement authorization. Checkpoints contain bearer authorizations and are not application-level encrypted. Use private ACLs/encrypted storage; no automatic cleanup is provided. Never reuse an archived operation ID. - [Complete configured-client guide](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) ## Before any signature Assign a stable logical request ID. Store credentials/checkpoints outside logs and model context. Stop on mismatched recipient, network, price, signed offer or evidence key. ## After ambiguous submission For the public SIWX flow, call the same adapter again with the same operation ID, input and private directory; it reloads the saved request/payment/SIWX state. The separate legacy quote/claim client resumes its own claim checkpoint. Do not re-quote or invoke the wallet again to clear the error. A locked or interrupted-before-checkpoint state requires investigation; do not delete the lock or overwrite the state automatically. ## When delivery is not verified Hold ingestion on signature, receipt or binding mismatch. Retain the private checkpoint for recovery. UNKNOWN never becomes permission because a payment succeeded. Reconciliation has not been repaired in this phase. Manual recovery may be necessary; zero-support operation is an objective, not a demonstrated guarantee. # The AcqPath HTTP x402 purchase contract Canonical: https://developers.getacqpath.com/http-x402 Quote first, private claim second, signed payment third. This is a multi-step report flow, not a generic one-call paid MCP tool. ## Separate stock marketplace endpoint SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Same signed authorization plus same normalized request recovers the existing stock result; changed input or another route is rejected after binding. A pre-use leaked stock authorization can be raced for another same-priced request. Keep signed HTTP requests private. Never create a replacement authorization after an uncertain payment. - [Stock endpoint, JSON, official TypeScript/Python and recovery](https://developers.getacqpath.com/stock-x402) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Current supported buyer integration SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Fresh 0.02 USDC; deep 0.05 USDC on Base eip155:8453. Pin the exact recipient, USDC asset, fee and Ed25519 verification key. The adapter verifies offer, report, receipt and delivery binding. Private checkpoint files retain bearer authorizations and are not application-level encrypted; protect them with private ACLs and encrypted storage. - [Install, call and verify: complete TS/Python guide](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) - [Public buyer journey](https://developers.getacqpath.com/public-http) ## 1. Install the tested dependencies Node 22.16+: @x402/core, @x402/evm, @x402/fetch, @x402/extensions 2.25.0 and viem 2.56.3. Python 3.12/3.13: x402 2.22.0, httpx 0.28.1, deliberate ABNF 2.2.0 pin. Use the supplied manifest/requirements with the source adapter. - [Installation and complete examples](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) ## 2. Authorize exactly one logical request Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. The adapter owns PAYMENT-SIGNATURE, SIGN-IN-WITH-X, X-AcqPath-Payment-Intent and X-AcqPath-Request. Do not manually replace a nonce or provide these headers. The extra SIWX signature binds the selected order and exact payment. ## 3. Verify delivery and recover A successful paid result is returned only after the adapter verifies the Ed25519 report, signed settlement receipt, input/purpose, amount and transaction-bound delivery proof. HTTP 200 with available:false and charge_micro:0 is unpaid, not a verified paid report. On timeout, use the SAME operation ID, input and private directory. Preserve unresolved authorizations; an uncertain 503 needs existing operator reconciliation. Never delete pending state or start another payment to clear an error. A verified receipt is not independent on-chain finality. - [Recovery](https://developers.getacqpath.com/recovery) ## Legacy boundary The older quote/claim SDK still serves existing integrations. Its report URL and encrypted store are separate from the public SIWX adapter. Existing legacy behavior does not require new buyers to implement a bound EIP-3009 nonce. UNKNOWN is not permission; a report is not a license. # Your agent fetched the page. What did the source declare? Canonical: https://developers.getacqpath.com/ai-input A tool trace preserves where the page came from. Keep a signed observation of available rights/TDM signals for AI input beside it. ## Why this evidence matters A tool trace preserves where the page came from. Keep a signed observation of available rights/TDM signals for AI input beside it. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call Use ai-input before placing source content into the model context. There is no separate summarize purpose or blanket permission guarantee. Deduplicate by canonical URL, purpose and context. Request new evidence only when your freshness policy requires it. ## Input and purchase Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-input", "tier": "fresh", "user_class": "commercial", "max_total_micro": "20000" } ``` ## Decision and retry UNKNOWN, missing declarations, unsupported origins and LICENSE_REQUIRED do not authorize use. A report records observed RSL declarations; it is not a license or legal clearance. Verify all evidence and use one durable purchase ID. Resume an existing checkpoint after ambiguity; never create a replacement charge blindly. - [Connect MCP](https://developers.getacqpath.com/connect) - [Reusable TypeScript examples](https://developers.getacqpath.com/examples/workflows.ts) - [HTTP quickstart](https://developers.getacqpath.com/quickstart) # Don't lose source-rights context at ingestion Canonical: https://developers.getacqpath.com/rag-ingestion Record what was observable when external content entered your RAG pipeline; preserve provenance, uncertainty and the declared purpose. ## Why this evidence matters Record what was observable when external content entered your RAG pipeline; preserve provenance, uncertainty and the declared purpose. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call RAG is a workflow, not a purpose enum. Indexing and model input can require separate ai-index and ai-input evaluations. Deduplicate by canonical URL, purpose and context. Request new evidence only when your freshness policy requires it. ## Input and purchase Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-index", "tier": "fresh", "user_class": "commercial", "max_total_micro": "20000" } ``` ## Decision and retry UNKNOWN, missing declarations, unsupported origins and LICENSE_REQUIRED do not authorize use. A report records observed RSL declarations; it is not a license or legal clearance. Verify all evidence and use one durable purchase ID. Resume an existing checkpoint after ambiguity; never create a replacement charge blindly. - [Connect MCP](https://developers.getacqpath.com/connect) - [Reusable TypeScript examples](https://developers.getacqpath.com/examples/workflows.ts) - [HTTP quickstart](https://developers.getacqpath.com/quickstart) # Indexing creates provenance. Preserve usage declarations too. Canonical: https://developers.getacqpath.com/indexing-search Keep a timestamped source-rights observation beside the indexed URL and your search workflow. ## Why this evidence matters Keep a timestamped source-rights observation beside the indexed URL and your search workflow. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call Use ai-index for indexing and search for search. Do not substitute one purpose for the other. Deduplicate by canonical URL, purpose and context. Request new evidence only when your freshness policy requires it. ## Input and purchase Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-index", "tier": "fresh", "user_class": "commercial", "max_total_micro": "20000" } ``` ## Decision and retry UNKNOWN, missing declarations, unsupported origins and LICENSE_REQUIRED do not authorize use. A report records observed RSL declarations; it is not a license or legal clearance. Verify all evidence and use one durable purchase ID. Resume an existing checkpoint after ambiguity; never create a replacement charge blindly. - [Connect MCP](https://developers.getacqpath.com/connect) - [Reusable TypeScript examples](https://developers.getacqpath.com/examples/workflows.ts) - [HTTP quickstart](https://developers.getacqpath.com/quickstart) # A dataset URL is not a training-rights record Canonical: https://developers.getacqpath.com/training Before training ingestion, document available machine-readable declarations for ai-train. Missing evidence never authorizes model training. ## Why this evidence matters Before training ingestion, document available machine-readable declarations for ai-train. Missing evidence never authorizes model training. A source URL and event time alone may not preserve what the site exposed at observation time. AcqPath records the result and uncertainty for review, not a licence or legal clearance. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call Use ai-train before including selected source content in training preparation. AcqPath does not audit an entire dataset or acquire training licenses. Deduplicate by canonical URL, purpose and context. Request new evidence only when your freshness policy requires it. ## Input and purchase Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-train", "tier": "fresh", "user_class": "commercial", "max_total_micro": "20000" } ``` ## Decision and retry UNKNOWN, missing declarations, unsupported origins and LICENSE_REQUIRED do not authorize use. A report records observed RSL declarations; it is not a license or legal clearance. Verify all evidence and use one durable purchase ID. Resume an existing checkpoint after ambiguity; never create a replacement charge blindly. - [Connect MCP](https://developers.getacqpath.com/connect) - [Reusable TypeScript examples](https://developers.getacqpath.com/examples/workflows.ts) - [HTTP quickstart](https://developers.getacqpath.com/quickstart) # Can I crawl this URL? Keep crawl and AI use separate. Canonical: https://developers.getacqpath.com/crawl AcqPath does not offer a paid crawl-permission product. Evaluate actual downstream AI input, indexing, training or search declarations separately. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Before crawling Respect your crawler access, robots and site policy before retrieval. A rights report is not a robots.txt validator, permission grant or access-control bypass. The existing free XML inspection path accepts a legacy crawl purpose, but it inspects supplied XML only; it does not fetch the URL and cannot establish usage rights. ## Before ingestion Once your crawler has a legitimately selected supported source, choose the actual paid purpose: ai-input, ai-index, ai-train or search. Check live coverage → call POST /v1/rights/preflight through the AcqPath SIWX adapter → verify the prepared signed offer → preserve the unchanged official payment authorization privately → complete SIWX prebinding/authorization → receive the verified report. Use the same operation ID, input and private store after ambiguity; never create a replacement payment. ## Hold uncertain sources UNKNOWN, missing declarations, unsupported origins and LICENSE_REQUIRED do not authorize use. A report records observed RSL declarations; it is not a license or legal clearance. - [Indexing / search](https://developers.getacqpath.com/indexing-search) - [RAG ingestion](https://developers.getacqpath.com/rag-ingestion) - [Documented XML inspection](https://developers.getacqpath.com/openapi.json) # Marketplace and x402 compatibility Canonical: https://developers.getacqpath.com/bazaar-status Current buyer contracts, supported client modes and live verification sources for AcqPath x402 integrations. ## Supported buyer contracts Secure mode uses the tested AcqPath SIWX adapter with official TypeScript/Node and Python x402 signers. The separate stock endpoint supports fresh Rights Preflight with official stock-wire clients and first-valid-use request binding. Use the prepared 402 as the authority for network, asset, recipient, amount and expiry. Compatibility outside the documented routes is not implied. - [Stock x402 integration](https://developers.getacqpath.com/stock-x402) - [Secure buyer integration](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) ## Operational source of truth Current service availability is published on the AcqPath status page. Current origin coverage and prices are published by the live capabilities endpoint. These public contracts replace internal rollout notes as the buyer-facing source of truth. - [Service status](https://status.getacqpath.com) - [Live capabilities](https://api.getacqpath.com/v1/capabilities) ## Security boundary Keep payment signatures, claims and recovery state private. A signed report is evidence of observed declarations, not a license or legal clearance. UNKNOWN and LICENSE_REQUIRED never become permission automatically. # Can I use this URL for RAG? Canonical: https://developers.getacqpath.com/rag-rights Preflight a source before adding it to a retrieval corpus. Later model use may need a separate ai-input check; do not silently buy both. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call Preflight a source before adding it to a retrieval corpus. Later model use may need a separate ai-input check; do not silently buy both. Use a canonical URL from the live supported-origin list. Coverage does not guarantee a billable or permissive result. ## Request without payment POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-index", "tier": "fresh", "max_total_micro": "20000" } ``` ## Possible outcomes ALLOW_DECLARED is observed evidence, not permission. DENY_DECLARED and LICENSE_REQUIRED require a hold or applicable license review. UNKNOWN stays UNKNOWN. No legal advice, legal clearance, ownership verification or license acquisition. HTTP 403 is not bypassed. ## Price and integration Fresh 0.02 USDC; deep 0.05 USDC. Base mainnet eip155:8453; USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; recipient 0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec. The verified signed offer is authoritative; paying buys the report, not content rights. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Public HTTP buyer journey](https://developers.getacqpath.com/public-http) - [Runnable JavaScript unpaid example](https://developers.getacqpath.com/examples/public-preflight.mjs) - [Python unpaid example](https://developers.getacqpath.com/examples/public-preflight.py) # Does this page declare restrictions before crawling? Canonical: https://developers.getacqpath.com/crawl-rights There is no paid crawl purpose and this service does not fetch content for you. Apply robots.txt, access controls and your crawler policy first; use ai-input only for planned downstream AI processing. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call There is no paid crawl purpose and this service does not fetch content for you. Apply robots.txt, access controls and your crawler policy first; use ai-input only for planned downstream AI processing. Use a canonical URL from the live supported-origin list. Coverage does not guarantee a billable or permissive result. ## Request without payment POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-input", "tier": "fresh", "max_total_micro": "20000" } ``` ## Possible outcomes ALLOW_DECLARED is observed evidence, not permission. DENY_DECLARED and LICENSE_REQUIRED require a hold or applicable license review. UNKNOWN stays UNKNOWN. No legal advice, legal clearance, ownership verification or license acquisition. HTTP 403 is not bypassed. ## Price and integration Fresh 0.02 USDC; deep 0.05 USDC. Base mainnet eip155:8453; USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; recipient 0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec. The verified signed offer is authoritative; paying buys the report, not content rights. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Public HTTP buyer journey](https://developers.getacqpath.com/public-http) - [Runnable JavaScript unpaid example](https://developers.getacqpath.com/examples/public-preflight.mjs) - [Python unpaid example](https://developers.getacqpath.com/examples/public-preflight.py) # Can I summarize or use this page as AI input? Canonical: https://developers.getacqpath.com/ai-input-rights Check declared usage terms before research, summarization or adding a web page to model context. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call Check declared usage terms before research, summarization or adding a web page to model context. Use a canonical URL from the live supported-origin list. Coverage does not guarantee a billable or permissive result. ## Request without payment POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-input", "tier": "fresh", "max_total_micro": "20000" } ``` ## Possible outcomes ALLOW_DECLARED is observed evidence, not permission. DENY_DECLARED and LICENSE_REQUIRED require a hold or applicable license review. UNKNOWN stays UNKNOWN. No legal advice, legal clearance, ownership verification or license acquisition. HTTP 403 is not bypassed. ## Price and integration Fresh 0.02 USDC; deep 0.05 USDC. Base mainnet eip155:8453; USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; recipient 0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec. The verified signed offer is authoritative; paying buys the report, not content rights. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Public HTTP buyer journey](https://developers.getacqpath.com/public-http) - [Runnable JavaScript unpaid example](https://developers.getacqpath.com/examples/public-preflight.mjs) - [Python unpaid example](https://developers.getacqpath.com/examples/public-preflight.py) # Can I train on this content? Canonical: https://developers.getacqpath.com/training-rights Check declarations before adding a supported URL to a training dataset. A report does not acquire training rights. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call Check declarations before adding a supported URL to a training dataset. A report does not acquire training rights. Use a canonical URL from the live supported-origin list. Coverage does not guarantee a billable or permissive result. ## Request without payment POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-train", "tier": "fresh", "max_total_micro": "20000" } ``` ## Possible outcomes ALLOW_DECLARED is observed evidence, not permission. DENY_DECLARED and LICENSE_REQUIRED require a hold or applicable license review. UNKNOWN stays UNKNOWN. No legal advice, legal clearance, ownership verification or license acquisition. HTTP 403 is not bypassed. ## Price and integration Fresh 0.02 USDC; deep 0.05 USDC. Base mainnet eip155:8453; USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; recipient 0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec. The verified signed offer is authoritative; paying buys the report, not content rights. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Public HTTP buyer journey](https://developers.getacqpath.com/public-http) - [Runnable JavaScript unpaid example](https://developers.getacqpath.com/examples/public-preflight.mjs) - [Python unpaid example](https://developers.getacqpath.com/examples/public-preflight.py) # Can I index this content? Canonical: https://developers.getacqpath.com/indexing-rights Use search for a search pipeline; choose ai-index for an AI/RAG index. Keep the purpose aligned with the actual downstream use. ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## When to call Use search for a search pipeline; choose ai-index for an AI/RAG index. Keep the purpose aligned with the actual downstream use. Use a canonical URL from the live supported-origin list. Coverage does not guarantee a billable or permissive result. ## Request without payment POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. ```text { "resource": "https://rslstandard.org/", "purpose": "search", "tier": "fresh", "max_total_micro": "20000" } ``` ## Possible outcomes ALLOW_DECLARED is observed evidence, not permission. DENY_DECLARED and LICENSE_REQUIRED require a hold or applicable license review. UNKNOWN stays UNKNOWN. No legal advice, legal clearance, ownership verification or license acquisition. HTTP 403 is not bypassed. ## Price and integration Fresh 0.02 USDC; deep 0.05 USDC. Base mainnet eip155:8453; USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; recipient 0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec. The verified signed offer is authoritative; paying buys the report, not content rights. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Public HTTP buyer journey](https://developers.getacqpath.com/public-http) - [Runnable JavaScript unpaid example](https://developers.getacqpath.com/examples/public-preflight.mjs) - [Python unpaid example](https://developers.getacqpath.com/examples/public-preflight.py) # Preflight a URL through one stable HTTP endpoint Canonical: https://developers.getacqpath.com/public-http Account-free declared-rights evidence for autonomous content use. Start without payment and check client compatibility before spending. ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Separate stock marketplace endpoint SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Same signed authorization plus same normalized request recovers the existing stock result; changed input or another route is rejected after binding. A pre-use leaked stock authorization can be raced for another same-priced request. Keep signed HTTP requests private. Never create a replacement authorization after an uncertain payment. - [Stock endpoint, JSON, official TypeScript/Python and recovery](https://developers.getacqpath.com/stock-x402) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## 1. Discover capability and prepare SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. POST https://api.getacqpath.com/v1/rights/preflight with {resource,purpose,tier:"fresh",max_total_micro:"20000"}. A prepared 402 includes price/network/asset and the required private request binding. Empty POST is discovery-only. HTTP 200 with available:false and charge_micro:"0" is not a purchased report. There is no AcqPath account, API key or operator token. Supported paid purposes: ai-input, ai-index, ai-train, search. Start with GET /v1/capabilities. Do not call the disabled acqpath_quote routing tool. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-input", "tier": "fresh", "max_total_micro": "20000" } ``` ## Official TypeScript / Node and Python integration SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Add the AcqPath transport adapter, independently pinned service terms/key, private durable store, explicit buyer opt-in and stable operation ID. It adds one unsigned prebinding round trip and one official SIWX signature; the stock payment signer is unchanged. Use the same operation ID, body and store after response loss. Never replace a pending authorization. EOA only; private-store retention and Python canonical-input limits are explained in the guide. - [Complete configured-client guide](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) - [TypeScript / Node adapter](https://developers.getacqpath.com/examples/acqpath.mjs) - [Node integration example](https://developers.getacqpath.com/examples/official-node.mjs) - [Pinned Node manifest](https://developers.getacqpath.com/examples/official-client-package.json) - [Python adapter](https://developers.getacqpath.com/examples/acqpath_httpx.py) - [Python integration example](https://developers.getacqpath.com/examples/official-python.py) - [Pinned Python requirements](https://developers.getacqpath.com/examples/official-requirements.txt) ## 2. Inspect the 402 Fresh 0.02 USDC; deep 0.05 USDC. Base mainnet eip155:8453; USDC 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913; recipient 0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec. The verified signed offer is authoritative; paying buys the report, not content rights. A stranger can inspect the endpoint and prepare a real LICENSE_REQUIRED resource without an AcqPath API key. Preserve X-AcqPath-Request privately. A decoded header is not signature verification. ## 3. Payment compatibility boundary SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. Standard x402 v2 uses PAYMENT-REQUIRED, PAYMENT-SIGNATURE and PAYMENT-RESPONSE. After verifying the offer, use the unchanged official signer with the AcqPath SIWX adapter. Legacy nonce-binding support is retained only for existing integrations. Retain identical normalized input and private request context. Do not modify a standard signer nonce after signing. The repository legacy SDK targets quote/claim report URLs and is not a drop-in public endpoint client. - [Detailed external buyer contract](https://developers.getacqpath.com/examples/PUBLIC-BUYER.md) ## 4. Successful signed output The GET contract at the same endpoint describes the JSON schema. Successful paid output contains report, evidence, payment_settlement and delivery_proof. Verify Ed25519 evidence, signed receipt, source/purpose and exact amount/transaction binding before accepting it. Published examples are synthetic; no external paid delivery has yet been proven. On uncertainty preserve the same checkpoint and request; never generate a second signature. A settlement response is not independent chain finality or duplicate-charge proof. ALLOW_DECLARED is observed evidence, not permission. DENY_DECLARED and LICENSE_REQUIRED require a hold or applicable license review. UNKNOWN stays UNKNOWN. No legal advice, legal clearance, ownership verification or license acquisition. HTTP 403 is not bypassed. ## Examples and workflows JavaScript and Python examples run only the unpaid HTTP preparation; TypeScript maps RAG, crawler, research, training and search workflows. Configured official-client integrations are documented below; generic zero-config buyers remain unsupported on the secure SIWX endpoint; use the separate fixed fresh stock endpoint for tested stock clients. - [JavaScript](https://developers.getacqpath.com/examples/public-preflight.mjs) - [Python](https://developers.getacqpath.com/examples/public-preflight.py) - [TypeScript workflow gates](https://developers.getacqpath.com/examples/public-workflows.ts) - [MCP connection](https://developers.getacqpath.com/connect) ## Copy-paste TypeScript / Node integration Inject your configured buyer signer; allowPayment defaults to false. ```text import { createAcqPathFetch, privateFileStore } from './acqpath.mjs'; // Inject an existing buyer-controlled viem EOA signer. No key is stored here. export async function preflight({ signer, operationId, input, privateDirectory, allowPayment = false }) { const buy = createAcqPathFetch({ signer, expected: {"origin":"https://api.getacqpath.com","network":"eip155:8453","asset":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","payTo":"0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec","amount":"20000"}, publicJwk: {"key_ops":["verify"],"ext":true,"alg":"Ed25519","crv":"Ed25519","x":"PzeeZ8d8Np85ix9ialbrLZz9ebY_Og72dScn1IAft6M","kty":"OKP"}, store: privateFileStore(privateDirectory), allowPayment, }); return buy('https://api.getacqpath.com/v1/rights/preflight', { method: 'POST', operationId, body: JSON.stringify(input), }); } ``` ## Copy-paste Python integration Inject your existing buyer account; no seller secrets or AcqPath account required. ```text from acqpath_httpx import AcqPathClient, PrivateFileStore # Inject an existing buyer-controlled eth_account LocalAccount. async def preflight(account, operation_id, input, private_directory, allow_payment=False): buyer = AcqPathClient( signer=account, expected={"origin":"https://api.getacqpath.com","network":"eip155:8453","asset":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","payTo":"0xf69DBbd053fb0Fbc78ADfdB1BFe3b0D1F57300ec","amount":"20000"}, public_jwk={"kty":"OKP","crv":"Ed25519","x":"PzeeZ8d8Np85ix9ialbrLZz9ebY_Og72dScn1IAft6M"}, store=PrivateFileStore(private_directory), allow_payment=allow_payment, ) try: return await buyer.post('https://api.getacqpath.com/v1/rights/preflight', json=input, operation_id=operation_id) finally: await buyer.aclose() ``` ## Pinned dependencies, delivery verification and retry Install the supplied pinned Node manifest or Python requirements with the source adapter. The complete guide includes installation, a call using your existing buyer account, response handling and exact same-operation recovery. No internal design document is needed. External revenue remains 0 USDC in the verified baseline. A configured buyer is technically supported; the absence of a real external paid E2E is an evidence limitation, not a technical payment block. - [Complete installation and verified-response examples](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) # Batch rights checks and policy revalidation Canonical: https://developers.getacqpath.com/gateway Check up to four reviewed URLs before AI ingestion; detect observed policy changes on repeat use. Exact Base USDC pricing and verified TS/Python delivery. ## Live source eligibility and trust boundary LIVE: Secure Preflight and Gateway accept eligible public HTTPS URLs through a signed, public-network-only relay. The four origins in reviewed coverage are independently reviewed sources, not the dynamic eligibility limit. Stock x402 remains reviewed-origins-only. Robots, access restrictions, per-origin quotas and UNKNOWN outcomes still apply. - [Current production capabilities](https://api.getacqpath.com/v1/capabilities) - [Eligible URL and reviewed coverage](https://developers.getacqpath.com/scope) ## Rights Gateway: select the paid operation LIVE Base USDC pricing: Secure Preflight 0.02 fresh / 0.05 deep per prepared settled report; Ingestion Gate 0.04 + 0.02 per distinct URL fresh or 0.06 + 0.04 per URL deep (1–4 eligible public HTTPS URLs); Revalidation 0.03 fresh / 0.06 deep. Stock x402 stays fresh-only 0.02 and reviewed-only. No new subscription, prepaid, API-key billing or invoicing plan is active. A Secure Preflight may offer a disclosed paid UNKNOWN or no-declaration diagnostic after meaningful public-source observation. An outage with no usable source observation, invalid URL or exhausted safety budget is not billable Preflight. Gateway pricing covers a bounded observation attempt after verified authorization. UNKNOWN never authorizes content use. SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. - [Gateway limits, prices and workflow](https://developers.getacqpath.com/gateway) - [Complete TypeScript and Python examples](https://developers.getacqpath.com/examples/GATEWAY.md) ## Machine contract and intended use POST /v1/rights/ingestion-gate takes resources, purpose, tier, freshness_seconds and max_total_micro. A single URL uses a one-element resources array. ai-input covers model input or summarization; ai-index covers indexing for RAG; ai-train covers training; search covers search. Choose the actual use. Crawl is not a paid RSL purpose or a robots access grant. Canonical URL duplicates count once; at most four entries are accepted. POST /v1/rights/revalidate takes the same scope with one resource and previous: the signed checkpoint from a delivered gateway resource item. It always reobserves conditionally (freshness_seconds: 0). Resource, purpose, user class, geography and tier must match. A new revalidation is a separately authorized purchase, never a retry of an earlier purchase. ```text { "resources": [ "https://rslstandard.org/" ], "purpose": "ai-input", "tier": "fresh", "freshness_seconds": 300, "max_total_micro": "60000" } ``` - [Live operation schemas](https://api.getacqpath.com/openapi.json) - [Live coverage](https://api.getacqpath.com/v1/capabilities) ## Signed evidence and conservative interpretation The verified report includes operation ID, SKU, deterministic evaluator profile, observation/evaluation timestamps, cache age, provenance, source hashes, normalized RSL 1.0 signals, conflicts, policy fingerprints, observed license references and signed checkpoints. Legal clearance is always false. IETF AIPREF drafts are not evaluated. PERMITTED_BY_OBSERVED_DECLARATION is an observation, not legal permission. LICENSE_REQUIRED does not acquire a license. CONFLICT and UNKNOWN remain explicit. Revalidation returns UNCHANGED, CHANGED, DECLARATION_ADDED, DECLARATION_REMOVED, LICENSE_PATH_CHANGED, CONFLICT_CHANGED, SOURCE_UNAVAILABLE or UNKNOWN. Incomplete current or prior evidence never proves removal. A raw policy declaration change can change the fingerprint even when the normalized verdict is unchanged. ## Work, freshness and recovery bounds Secure Ingestion Gate accepts up to four eligible public HTTPS URLs per operation. Fresh allows at most four metadata fetches per resource; deep allows eight; concurrent resource work is capped at two. Dynamic origins use separate limits and a global Railway relay cap, and throughput at 100,000 URLs/month is not certified. No private-network access or unauthorized source bypass. Cache reuse exposes the original observation timestamp and age. Revalidation uses conditional requests and 304 when supported. Each item is bounded at 12,000 bytes and the gateway report at 52,000 bytes. A failed or oversized source produces UNKNOWN. A durable interrupted execution fails closed without automatic recomputation or settlement. Use the supplied TS/Python adapter and its private ACL-protected state directory. Files are not application-level encrypted. Keep original operation ID, normalized input and directory on retry. Never log signed artifacts, checkpoint state or private request context. The adapter verifies report, receipt and delivery binding; HTTP 200 alone is insufficient. Preserve pending state across rollback; an older server version may not understand new gateway journal records. - [Copy-paste Node / Python](https://developers.getacqpath.com/examples/GATEWAY.md) - [Recovery](https://developers.getacqpath.com/recovery) # Stock x402 marketplace Rights Preflight Canonical: https://developers.getacqpath.com/stock-x402 Fresh Rights Preflight at 0.02 USDC on Base with unmodified official TS/Python x402 buyers. Separate first-use binding model; no SIWX. ## Choose the right security contract SUPPORTED SECURE MODE: tested official TypeScript/Node x402 2.25.0 and Python x402 2.22.0 with the AcqPath SIWX adapter on /v1/rights/preflight; unchanged signer and random nonce, recommended when payer-signed request binding is required. SUPPORTED STOCK WIRE MODE: the same official stock clients without SIWX, custom nonce, signer or buyer hook on /v1/rights/preflight/x402, fresh only, 0.02 USDC. Stock binds one request atomically at first valid use; it does not sign the POST body in advance. Zero-config compatibility outside this fixed stock endpoint, stock SIWX-only hooks, Payments MCP and generic paid proxies are not supported by this integration. The secure SIWX route remains recommended for callers requiring payer-signed body binding. Stock mode is one authorization for one fixed fresh Preflight execution; deep, Gate and Revalidation remain on their existing secure integrations. No verifiable declaration after authorized observation means no settlement; that authorization stays bound to its attempted input. - [Complete stock TypeScript/Python guide](https://developers.getacqpath.com/examples/STOCK-X402.md) - [Recommended SIWX integration](https://developers.getacqpath.com/examples/OFFICIAL-CLIENTS.md) ## Exact production request POST https://api.getacqpath.com/v1/rights/preflight/x402 with Content-Type: application/json. This valid unpaid POST returns a 402 without source work or order creation. The fee is 20000 micro-USDC (0.02 USDC), Base mainnet eip155:8453, current Base USDC and the existing AcqPath recipient. ```text { "resource": "https://rslstandard.org/", "purpose": "ai-input", "max_total_micro": "20000" } ``` - [Live production schema](https://api.getacqpath.com/openapi.json) - [Unpaid stock contract metadata](https://api.getacqpath.com/v1/rights/preflight/x402) ## Recovery and limits An EIP-3009 signature does not sign the arbitrary POST body. Keep the signed request private before transmission. The first valid use atomically binds it to the normalized input and fixed SKU; identical signed retries recover, changed input rejects. A leaked authorization can be raced before first use. Persist the exact outgoing body and PAYMENT-SIGNATURE in private durable HTTP retry infrastructure. The simple stock client examples do not install a durable recovery store. Do not invoke a payment wrapper again to recover without the original signed state: it may create another purchase. UNCONFIRMED requires operator reconciliation; no second settlement is automatically attempted. Verify report evidence, delivery proof and authenticated receipt against AcqPath public DID keys and expected input/payment terms. HTTP 200 alone is not sufficient. UNKNOWN and LICENSE_REQUIRED do not grant ingestion rights. - [Complete verification and recovery instructions](https://developers.getacqpath.com/examples/STOCK-X402.md) ## Marketplace compatibility The stock endpoint is designed for the documented official TypeScript/Python x402 wire flow. The secure SIWX route remains the recommended choice when payer-signed request binding is required. Use live service status, the prepared 402 and the documented route contract to determine current compatibility. Marketplace listing or discovery metadata is not a substitute for validating the payment contract. - [Service status](https://status.getacqpath.com) - [Complete stock TypeScript/Python guide](https://developers.getacqpath.com/examples/STOCK-X402.md)