# Synthex Forge — x402 Paid Agent Services (remote · x402.synthexforge.com)

Paid agent services settled in USDC on Base via x402. Signed, verifiable, and free to verify.

- Trust score: 63/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-23

## Components

- remote · `x402.synthexforge.com`: 63/100 (this document), [markdown](https://verifymcp.io/servers/com-synthexforge-x402-paid-agent-services/x402.md), [page](https://verifymcp.io/servers/com-synthexforge-x402-paid-agent-services/x402)

## Channel facts

- Endpoint: `https://x402.synthexforge.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-23.

- **Endpoint Security**: 80/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 49/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 25390 tokens (~230/item across 110 items; 110 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability check failed: schema churn in the 1 day we've observed: 0 tool removals, 1 breaking changes, 0 auth/transport breaks, 90 additions.
- **Tool Coverage**: 72/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 15% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "mcp_eval_judge" implies "eval" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 111 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### How do I install the Synthex Forge — x402 Paid Agent Services MCP server?

Synthex Forge — x402 Paid Agent Services is a hosted endpoint at https://x402.synthexforge.com/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http com-synthexforge-x402-paid-agent-services 'https://x402.synthexforge.com/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "com-synthexforge-x402-paid-agent-services": {
      "url": "https://x402.synthexforge.com/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-synthexforge-x402-paid-agent-services": {
      "type": "http",
      "url": "https://x402.synthexforge.com/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-synthexforge-x402-paid-agent-services]
url = "https://x402.synthexforge.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-synthexforge-x402-paid-agent-services": {
      "type": "remote",
      "url": "https://x402.synthexforge.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-synthexforge-x402-paid-agent-services --url 'https://x402.synthexforge.com/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-synthexforge-x402-paid-agent-services:
    url: "https://x402.synthexforge.com/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "com-synthexforge-x402-paid-agent-services": {
      "Transport": "http",
      "Url": "https://x402.synthexforge.com/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-synthexforge-x402-paid-agent-services -t streamable-http -u 'https://x402.synthexforge.com/mcp'
```

### Other

```json
{
  "mcpServers": {
    "com-synthexforge-x402-paid-agent-services": {
      "type": "http",
      "url": "https://x402.synthexforge.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-23 (score 63, −6)

- [security regression] Stability: unverified → fail
- [security regression] A breaking change shipped without a version bump: still 1.0.0
- [security] Tool “signed_attest” rewrote its description, which is the text the model reads
- [security] Tool “verify_signature” rewrote its description, which is the text the model reads
- [security] Tool “attestation_receipt” rewrote its description, which is the text the model reads
- [security] Tool “attested_financial_evidence” rewrote its description, which is the text the model reads
- [security] Tool “data_validate” rewrote its description, which is the text the model reads
- [security] Tool “edge_prior” rewrote its description, which is the text the model reads
- [security] Tool “forensics_ingest” rewrote its description, which is the text the model reads
- [security] Tool “forensics_query” rewrote its description, which is the text the model reads
- [security] Tool “health” rewrote its description, which is the text the model reads
- [security] Tool “memory_get” rewrote its description, which is the text the model reads
- [security] Tool “memory_put” rewrote its description, which is the text the model reads
- [security] Tool “policy_check” rewrote its description, which is the text the model reads
- [security] Tool “preflight” rewrote its description, which is the text the model reads
- [security] Tool “rates_reference” rewrote its description, which is the text the model reads
- [security] Tool “reputation_lookup” rewrote its description, which is the text the model reads
- [security] Tool “signed_research” rewrote its description, which is the text the model reads
- [security] Tool “synthesis_verdict” rewrote its description, which is the text the model reads
- [security] Tool “trusted_route_lookup” rewrote its description, which is the text the model reads
- [security] Tool “verify_catalog_register” rewrote its description, which is the text the model reads
- [security] Tool “x402_index” rewrote its description, which is the text the model reads
- [functional regression] Tool coverage: 100% → 15%
- [functional regression] Schema quality: 194 → 230
- [functional regression] “signed_attest” made “claim” required, so existing callers break
- [functional] Destructive annotations: pass → 0
- [functional] New tool “a2a_escrow”
- [functional] New tool “a2a_settlement”
- [functional] New tool “agent_handoff”
- [functional] New tool “agent_run”
- [functional] New tool “api_ebook_download”
- [functional] New tool “audit_evidence_package”
- [functional] New tool “bestex_evidence”
- [functional] New tool “budget_preflight”
- [functional] New tool “bureau_audit”
- [functional] New tool “bureau_receipt_check”
- [functional] New tool “bureau_reputation”
- [functional] New tool “compliance_check”
- [functional] New tool “containment_register”
- [functional] New tool “contract_term_extract”
- [functional] New tool “corpus_anchor”
- [functional] New tool “counterparty_score”
- [functional] New tool “credentials_issue”
- [functional] New tool “data_c2pa_verify”
- [functional] New tool “data_freshness”
- [functional] New tool “data_signed_snapshot”
- [functional] New tool “decision_attest”
- [functional] New tool “delivery_attest”
- [functional] New tool “dispute_ruling”
- [functional] New tool “edge_replication”
- [functional] New tool “finance_precision”
- [functional] New tool “fund_tearsheet”
- [functional] New tool “governance_reserve”
- [functional] New tool “governance_settle”
- [functional] New tool “identity_agent_attest”
- [functional] New tool “identity_control_proof”
- [functional] New tool “index_x402”
- [functional] New tool “invoice_ocr”
- [functional] New tool “latency_benchmark”
- [functional] New tool “licence_check”
- [functional] New tool “mandate_compliance”
- [functional] New tool “market_calendar”
- [functional] New tool “market_history”
- [functional] New tool “market_history_bulk”
- [functional] New tool “market_regime”
- [functional] New tool “market_snapshot”
- [functional] New tool “mcp_eval_judge”
- [functional] New tool “mcp_threatmodel_tool_permission”
- [functional] New tool “mcp_verify_uptime”
- [functional] New tool “nav_attest”
- [functional] New tool “output_verify”
- [functional] New tool “pass_purchase”
- [functional] New tool “pass_purchase_trial”
- [functional] New tool “payment_deadline”
- [functional] New tool “payment_envelope_validate”
- [functional] New tool “portfolio_risk”
- [functional] New tool “pretrade_risk”
- [functional] New tool “procurement_reconcile”
- [functional] New tool “provenance_overlay”
- [functional] New tool “quant_monte_carlo”
- [functional] New tool “quant_overlap”
- [functional] New tool “quant_risk_of_ruin”
- [functional] New tool “quant_significance”
- [functional] New tool “quota_preflight”
- [functional] New tool “readiness_attest”
- [functional] New tool “route_execute”
- [functional] New tool “sec_extract”
- [functional] New tool “security_dependency_risk”
- [functional] New tool “security_redteam_authorized_scan”
- [functional] New tool “security_threatmodel”
- [functional] New tool “settlement_conditional”
- [functional] New tool “settlement_receipt”
- [functional] New tool “settlement_route_advice”
- [functional] New tool “signed_research_get”
- [functional] New tool “sla_breach_evidence”
- [functional] New tool “sme_screen”
- [functional] New tool “social_search”
- [functional] New tool “spend_anomaly”
- [functional] New tool “spend_ledger_attest”
- [functional] New tool “strategy_capacity”
- [functional] New tool “strategy_verdict”
- [functional] New tool “task_acceptance”
- [functional] New tool “uptime_attest”
- [functional] New tool “utils_code_review_brief”
- [functional] New tool “utils_doc_convert”
- [functional] New tool “utils_invoice_extract”
- [functional] New tool “utils_pii_redact”
- [functional] New tool “utils_schema_cleanup”
- [functional] New tool “utils_translate_doc”
- [functional] New tool “verdict_agent”
- [functional] New tool “verdict_batch”
- [functional] New tool “verdict_endpoint”
- [functional] New tool “verdict_service”
- [functional] New tool “verdict_tool”
- [functional] New tool “x402_anchor”
- [functional] New tool “x402_quote”
- [cosmetic] “attestation_receipt” added an optional parameter “action”
- [cosmetic] “attestation_receipt” added an optional parameter “actor”
- [cosmetic] “attestation_receipt” added an optional parameter “metadata”
- [cosmetic] “attestation_receipt” added an optional parameter “subject”
- [cosmetic] “attestation_receipt” added an optional parameter “tx”
- [cosmetic] “attested_financial_evidence” added an optional parameter “company”
- [cosmetic] “attested_financial_evidence” added an optional parameter “period”
- [cosmetic] “data_validate” added an optional parameter “as_of”
- [cosmetic] “edge_prior” added an optional parameter “family”
- [cosmetic] “edge_prior” added an optional parameter “free_text”
- [cosmetic] “forensics_ingest” added an optional parameter “action”
- [cosmetic] “forensics_ingest” added an optional parameter “action_hash”
- [cosmetic] “forensics_ingest” added an optional parameter “actor_did”
- [cosmetic] “forensics_ingest” added an optional parameter “metadata”
- [cosmetic] “forensics_ingest” added an optional parameter “policy_ref”
- [cosmetic] “forensics_ingest” added an optional parameter “timestamp”
- [cosmetic] “forensics_query” added an optional parameter “actor_did”
- [cosmetic] “forensics_query” added an optional parameter “entries”
- [cosmetic] “memory_get” added an optional parameter “owner”
- [cosmetic] “memory_put” added an optional parameter “owner”
- [cosmetic] “policy_check” added an optional parameter “as_of”
- [cosmetic] “reputation_lookup” added an optional parameter “agent”
- [cosmetic] “signed_attest” added an optional parameter “claim_type”
- [cosmetic] “signed_research” added an optional parameter “context”
- [cosmetic] “signed_research” added an optional parameter “depth”
- [cosmetic] “synthesis_verdict” added an optional parameter “audit”
- [cosmetic] “synthesis_verdict” added an optional parameter “quant”
- [cosmetic] “synthesis_verdict” added an optional parameter “research”
- [cosmetic] “synthesis_verdict” added an optional parameter “subject”
- [cosmetic] “trusted_route_lookup” added an optional parameter “routes”
- [cosmetic] “verify_catalog_register” added an optional parameter “claim”
- [cosmetic] “verify_catalog_register” added an optional parameter “claim_sha256”
- [cosmetic] “verify_catalog_register” added an optional parameter “edges”
- [cosmetic] “verify_catalog_register” added an optional parameter “service_name”
- [cosmetic] “verify_catalog_register” added an optional parameter “service_url”
- [cosmetic] “verify_catalog_register” added an optional parameter “signature”
- [cosmetic] “x402_index” added an optional parameter “min_uptime_pct”
- [cosmetic] “x402_index” added an optional parameter “network”
- [cosmetic] “x402_index” added an optional parameter “require_conformance”
- [cosmetic] “attestation_receipt” reworded the description of “receipt_type”
- [cosmetic] “attested_financial_evidence” reworded the description of “statement”
- [cosmetic] “data_validate” reworded the description of “coerce”
- [cosmetic] “data_validate” reworded the description of “payload”
- [cosmetic] “data_validate” reworded the description of “repair”
- [cosmetic] “data_validate” reworded the description of “schema”
- [cosmetic] “data_validate” reworded the description of “strict”
- [cosmetic] “edge_prior” reworded the description of “instrument”
- [cosmetic] “edge_prior” reworded the description of “strategy_type”
- [cosmetic] “edge_prior” reworded the description of “timeframe”
- [cosmetic] “memory_get” reworded the description of “key”
- [cosmetic] “memory_put” reworded the description of “key”
- [cosmetic] “memory_put” reworded the description of “value”
- [cosmetic] “policy_check” reworded the description of “action”
- [cosmetic] “policy_check” reworded the description of “caller_state”
- [cosmetic] “policy_check” reworded the description of “policy”
- [cosmetic] “preflight” reworded the description of “checks”
- [cosmetic] “preflight” reworded the description of “kind”
- [cosmetic] “preflight” reworded the description of “target”
- [cosmetic] “rates_reference” reworded the description of “base”
- [cosmetic] “rates_reference” reworded the description of “quote”
- [cosmetic] “rates_reference” reworded the description of “symbol”
- [cosmetic] “reputation_lookup” reworded the description of “events”
- [cosmetic] “signed_attest” reworded the description of “claim”
- [cosmetic] “signed_research” reworded the description of “topic”
- [cosmetic] “verify_signature” reworded the description of “body”
- [cosmetic] “verify_signature” reworded the description of “sha256”
- [cosmetic] “verify_signature” reworded the description of “signature”
- [cosmetic] “x402_index” reworded the description of “limit”
- [cosmetic] “x402_index” reworded the description of “max_price_usd”
- [cosmetic] “x402_index” reworded the description of “query”
- [cosmetic] “attestation_receipt” dropped the optional parameter “payload”
- [cosmetic] “forensics_ingest” dropped the optional parameter “evidence”
- [cosmetic] “forensics_query” dropped the optional parameter “query”
- [cosmetic] “reputation_lookup” dropped the optional parameter “agent_id”
- [cosmetic] “synthesis_verdict” dropped the optional parameter “inputs”
- [cosmetic] “trusted_route_lookup” dropped the optional parameter “target”
- [cosmetic] “verify_catalog_register” dropped the optional parameter “service”
- [cosmetic] “x402_index” dropped the optional parameter “category”

### 2026-10-22 (score 69)

First indexed and scored.

## MCP tools (110)

### `api_ebook_download` (~185 tokens)

Api Ebook Download

Ebook Download

VALUE: The full 121-page book 'x402 — The Agent Economy' — the definitive account of building machine-native services agents pay for, in one file.

PRICE: $29.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

### `rates_reference` (~244 tokens)

Rates Reference

Signed reference rates, always as-of stamped. FX leg is the ECB euro reference rates (official, daily); crypto leg is the Binance public spot bookTicker. On a weekend or holiday the LAST BUSINESS DAY is returned with is_stale=true and the real staleness in seconds — a stale rate is never presented as live.

VALUE: What is this amount worth right now?

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `base` (string)
- `quote` (string)
- `symbol` (string)

### `signed_research_get` (~248 tokens)

Signed Research Get

Signed Research

VALUE: Paid route: $0.50 USDC on eip155:8453 (USD). An unauthenticated request is answered HTTP 402 with a machine-readable price challenge in the `Payment-Required` response header and a JSON body carrying `error`, `error_reason`, `error_message` and `x402Version`. Error codes and their remedies are published at https://x402.synthexforge.com/v1/errors.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `topic` (string)

### `social_search` (~271 tokens)

Social Search

Multi-channel social-signal search (PAID $0.02)

VALUE: Paid route: $0.02 USDC on eip155:8453 (USD). An unauthenticated request is answered HTTP 402 with a machine-readable price challenge in the `Payment-Required` response header and a JSON body carrying `error`, `error_reason`, `error_message` and `x402Version`. Error codes and their remedies are published at https://x402.synthexforge.com/v1/errors.

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `channels` (string)
- `limit` (string)
- `q` (string)

### `a2a_escrow` (~238 tokens)

A2A Escrow

Turn a deal between two agents into signed, machine-checkable release terms (PAID $0.50)

VALUE: Produce the release-terms document for a deal.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `amount_usd`
- `arbiter`
- `deadline` (string)
- `payee_wallet` (string)
- `payer_wallet` (string)
- `release_conditions` (array)
- `release_rule` (string)

### `a2a_settlement` (~246 tokens)

A2A Settlement

What does agent A owe agent B, and is the evidence sufficient to settle it? (PAID $0.25)

VALUE: Adjudicate what one agent owes another.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `acceptance`
- `amount_usd`
- `completion_evidence` (array)
- `payee` (object): One side of the obligation.
- `payer` (object): One side of the obligation.
- `task` (object): The delegated task the obligation is for.

### `reputation_lookup` (~203 tokens)

Reputation Lookup

Compute a signed agent-reputation composite from an agent id and its event list.

VALUE: Reputation scored from dated, signed behaviour events rather than self-reported claims — so you can price trust before you trade.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `agent` (string)
- `events` (array)

### `trusted_route_lookup` (~202 tokens)

Trusted Route Lookup

Compute a signed trusted-route ranking for a counterparty.

VALUE: The specific routes an agent is cleared to call, with the evidence behind each clearance — so you can enforce a least-privilege allowlist instead of trusting a name.

PRICE: $0.30 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `routes` (array)

### `agent_handoff` (~233 tokens)

Agent Handoff

Hand a task from one agent to another without losing the thread (PAID $0.10)

VALUE: Assess a handoff of task state between two agents.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `acceptance_criteria` (array)
- `context_sha256`
- `from_agent` (string)
- `state` (object): The state being handed over.
- `task_id` (string)
- `to_agent` (string)

### `agent_run` (~204 tokens)

Agent Run

Attested Agent Execution — bounded agent run (PAID $1.00)

VALUE: One audited agent execution with a cost ledger and a signed result, so the work is reproducible and the spend is attributable.

PRICE: $1.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `context` (string)
- `task` (string, required)

### `audit_evidence_package` (~242 tokens)

Audit Evidence Package

Signed self-contained audit evidence package with a Merkle root (PAID $4.00)

VALUE: A single signed package binding artifacts, assertions and attestations for a period — what an auditor asks for, without three weeks of chasing.

PRICE: $4.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `artifacts`
- `as_of` (string)
- `assertions`
- `attestations`
- `period` (string)
- `policy` (string)
- `subject` (string)

### `bestex_evidence` (~317 tokens)

Bestex Evidence

MiFID-style best-execution attestation. Returns within_tolerance | outside_tolerance | insufficient_evidence, with the implementation shortfall, the slippage, the gap to every benchmark supplied, the timing risk and a quality grade. Every bps figure is reproducible from the numbers shown. A missing arrival price returns insufficient_evidence — implementation shortfall is undefined without a decision price.

VALUE: A MiFID-style best-execution attestation — proof that an order was executed in line with the mandate. Returns the implementation shortfall, the slippage, the gap to every benchmark supplied and a quality grade, with the arithmetic written out so a reviewer can re-derive every figure. No arrival price means no verdict.

PRICE: $2.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `benchmarks`
- `fills`
- `order`

### `budget_preflight` (~200 tokens)

Budget Preflight

Budget Preflight

VALUE: Whether this call fits the budget, BEFORE you spend — turns a surprise overage into a decision you can make in advance.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `action_amount_usd`
- `agent_id` (string)
- `policy`

### `bureau_audit` (~208 tokens)

Bureau Audit

x402 Bureau — full conformance audit of any endpoint (PAID $0.25)

VALUE: A full conformance audit of any target endpoint against the x402 standard, every clause, signed and dated — the check a buyer cannot do from the outside.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `url` (string, required)

### `bureau_receipt_check` (~211 tokens)

Bureau Receipt Check

x402 Bureau — conformance-check any issuer's receipt/offer (PAID $0.05)

VALUE: Independent verification that a receipt is genuine and matches the offer it claims to settle — counterparty-side proof, not your own.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `offer` (object)
- `receipt` (object)

### `bureau_reputation` (~204 tokens)

Bureau Reputation

x402 Bureau — reputation from signed observation history (PAID $0.10)

VALUE: The Verification Bureau's standing reputation read for a subject, from its own corpus — third-party standing you cannot manufacture.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `events` (array)
- `subject` (string, required)

### `compliance_check` (~241 tokens)

Compliance Check

Compliance Check

VALUE: A specific, dated compliance verdict for one described processing activity — the artifact a regulator asks for, not a policy PDF.

PRICE: $1.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `category` (string)
- `custom_details` (string)
- `data_types` (string)
- `description` (string)
- `name` (string)
- `provider` (string)
- `purpose` (string)
- `sector` (string)
- `users` (string)

### `containment_register` (~223 tokens)

Containment Register

Containment Register

VALUE: A registered, signed containment policy with named emergency contacts — so 'what happens if this agent goes wrong' has an answer that is already signed and enforceable.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `agent_did` (string)
- `emergency_contact_did` (string)
- `policy`
- `rule_signatures`
- `rules` (array)

### `contract_term_extract` (~235 tokens)

Contract Term Extract

Signed rule-based extraction of the clauses that decide money and liability (PAID $1.50)

VALUE: The obligations in a contract as structured, dated data — so compliance is a query, not a re-read of forty pages.

PRICE: $1.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `document_b64` (string)
- `document_text` (string)
- `document_type` (string)
- `jurisdiction` (string)

### `corpus_anchor` (~217 tokens)

Corpus Anchor

Dated, signed proof that a document set existed — a Merkle root, the leaves, and a real inclusion proof (PAID $2.00)

VALUE: Anchor a document set.

PRICE: $2.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `anchored_at` (string)
- `documents` (array)
- `merkle` (string)
- `notarise` (boolean)

### `counterparty_score` (~230 tokens)

Counterparty Score

Counterparty credit & conduct score from your own observations (PAID $0.50)

VALUE: Price the risk of paying an unknown agent, endpoint or host from YOUR OWN observations — a 0-1000 credit and conduct score with the weighted factors behind it, so you price trust before you pay.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `identifier` (string)
- `observations`

### `credentials_issue` (~343 tokens)

Credentials Issue

Issue a scoped, expiring, offline-verifiable capability credential (PAID $0.05)

VALUE: A scoped, time-limited, signed credential — delegation with an expiry, so access does not have to be revoked by hand.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `issued_for` (string): Who the credential was issued to, for the record.
- `max_uses` (integer): How many uses the credential is granted (1..100000).
- `policy_ref` (string): The policy the credential is issued under. Its SHA-256 is carried in the credential.
- `scopes` (array): The scopes to grant. Every scope must be in the documented vocabulary; an unknown scope is a 400 with the vocabulary in the body. A wildcard is refused.
- `subject` (string, required): Who the credential is for, e.g. 'did:agent:abc'.
- `ttl_seconds` (integer): How long the credential is valid, in seconds (1..2592000).

### `data_c2pa_verify` (~209 tokens)

Data C2Pa Verify

C2Pa Verify

VALUE: Whether a media file carries a valid C2PA provenance manifest — the check that separates authentic media from generated media.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `content_hash` (string)
- `expected_creator` (string)
- `expected_generator` (string)
- `manifest`

### `data_freshness` (~236 tokens)

Data Freshness

Assess whether data is still fresh, undated or conflicting (PAID $0.02)

VALUE: Whether a claim's source is still fresh enough for the decision you are about to make — staleness is the failure mode nobody prices in.

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `budget_seconds` (integer)
- `claims`
- `reference_time` (string)
- `source_url` (string)

### `data_signed_snapshot` (~209 tokens)

Data Signed Snapshot

Signed Snapshot

VALUE: A tamper-evident snapshot of a series with its sources and fetch time — a data point you can defend later, not just cite.

PRICE: $0.30 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `fetched_at`
- `series` (array)
- `sources` (array)
- `subject` (string)

### `data_validate` (~274 tokens)

Data Validate

Validate, normalise and mechanically repair a payload against a declared JSON-Schema subset. Repair never fabricates data: a required property with no default is reported missing, not inserted. Keywords outside the supported subset are reported in schema_keys_unsupported rather than silently ignored.

VALUE: Coercion and repair of a payload against a schema, with the repairs itemised — malformed input becomes clean input, and every change is on the record.

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `coerce` (boolean)
- `payload`
- `repair` (boolean)
- `schema`
- `strict` (boolean)

### `decision_attest` (~244 tokens)

Decision Attest

Signed decision attestation with an assurance level and explicit unknowns (PAID $2.50)

VALUE: A signed, dated, replayable attestation of a decision and the policy that produced it — the difference between a decision and an accountable one.

PRICE: $2.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `actor` (string)
- `as_of` (string)
- `context`
- `decision` (string)
- `evidence`
- `policy` (string)
- `policy_set`

### `delivery_attest` (~247 tokens)

Delivery Attest

Proof that a digital deliverable arrived and matched what was promised (PAID $0.10)

VALUE: A paid service on the x402 rail — the result is worth the call because the same work done by hand costs more time than the price.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `acknowledged_at`
- `acknowledged_by`
- `deliverable` (object): The deliverable as it arrived.
- `delivered_at` (string)
- `promised_sha256`
- `recipient` (string)

### `dispute_ruling` (~347 tokens)

Dispute Ruling

Signed advisory dispute ruling from a deterministic rubric (PAID $2.00)

VALUE: A binding ruling on a dispute from the contract, evidence and policy — so the resolution is a signed artifact, not an argument.

PRICE: $2.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `case_id` (string): The caller's case id.
- `claim` (object): {obligation, claimed_by, against}. The obligation is a human sentence; the engine parses the required row count and the required coverage window out of it, and reports what it could not read.
- `contract` (object): {artifact_requirements, required_rows?, required_window?}. The machine-readable requirement WINS over the parsed sentence.
- `evidence` (object): {buyer: [...], seller: [...]}. Each entry is a {kind, content, manifest, sha256, tx_hash} evidence item.
- `policy` (object): {on_partial: 'pro_rata'}. The split formula is published and fixed; this records the caller's declared policy.

### `edge_prior` (~464 tokens)

Edge Prior

Prior-test registry query: what has actually been tested on an instrument/timeframe/strategy-type before, and what the prior evidence says. Every field is optional but at least one must be supplied.

VALUE: What has actually been tested on this instrument, timeframe and strategy type before, and what the prior evidence says — so you do not pay to rediscover a known result.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `family`: The strategy family, e.g. 'breakout'. Case and separator insensitive.
- `free_text`: A free-text description, matched on normalised token overlap against the entry's name, type, family and edge_type. Generic words ('strategy', 'backtest', 'using') are stopwords and carry no matching…
- `instrument`: The instrument to look up, e.g. 'USD_JPY'. NORMALISED: USDJPY, USD/JPY, usd-jpy and USD_JPY are all one instrument. Aliases: XAUUSD/gold -> XAU_USD, XAGUSD/silver -> XAG_USD, SPX500 -> SPX500_USD, NA…
- `strategy_type`: The strategy type, e.g. 'donchian_breakout'. Case and separator insensitive: 'Donchian Breakout' == 'donchian_breakout'.
- `timeframe`: The timeframe to look up, e.g. 'H1'. NORMALISED: 60m == H1, 1h == H1, 4h == H4, 1d == D1.

### `edge_replication` (~516 tokens)

Edge Replication

Is that track record real, or did you find it by looking? (PAID $3.00)

VALUE: Whether a claimed edge survives replication on your own returns — the test that separates a real edge from a curve fit.

PRICE: $3.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `claimed`: Optional: {sharpe, cagr, max_dd} — your stated figures. When supplied they are compared against the computed ones and a mismatch is a named finding.
- `frequency`: 'daily' or 'per_trade'. REQUIRED. A daily series is annualised with sqrt(252); a per_trade series is reported PER TRADE and is never annualised, because a per-trade series has no knowable trades-per-…
- `returns`: The return series, as a JSON list of numbers. EITHER this or 'returns_csv_b64' is required, never both. At most 200000 observations; a longer series is a 400 naming the limit. NaN and infinity are re…
- `returns_csv_b64`: The return series as a base64-encoded CSV, one number per row. The alternative to 'returns'. Decoded size is capped at 1 MB.
- `strategy_shape`: Optional: {type, instrument, timeframe}. 'type' is one of trend | mean_reversion | breakout | other and selects the calibration bucket; 'instrument' selects the instrument-class bucket. Instruments a…
- `trials_attempted`: How many configurations you tried before keeping this one. REQUIRED, and must be >= 2. This is the number that makes the Deflated Sharpe meaningful: a Sharpe of 2.0 found after 500 tries is priced fo…

### `forensics_ingest` (~239 tokens)

Forensics Ingest

Seal one signed-attribution / forensics evidence record into a tamper-evident vault entry.

VALUE: Sealing one evidence record into a tamper-evident vault entry — chain of custody that survives after the fact.

PRICE: $0.20 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `action` (string)
- `action_hash` (string)
- `actor_did` (string)
- `metadata` (object)
- `policy_ref` (string)
- `timestamp`

### `forensics_query` (~198 tokens)

Forensics Query

Bind sealed forensics-vault entries into ONE signed query receipt.

VALUE: Querying that vault by actor or predicate — the retrieval side of evidence you cannot quietly edit.

PRICE: $0.15 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `actor_did` (string)
- `entries` (array)

### `attested_financial_evidence` (~213 tokens)

Attested Financial Evidence

Assess and attest a financial statement or metrics payload into signed, reproducible evidence.

VALUE: Signed, dated financial evidence extracted from a statement — the figure a lender, investor or auditor can rely on without a call.

PRICE: $0.35 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `company` (string)
- `period` (string)
- `statement`

### `finance_precision` (~210 tokens)

Finance Precision

Exact-decimal financial calculation with its published convention (PAID $0.01)

VALUE: Exact decimal arithmetic under stated conventions — financial totals that do not drift by a cent when you scale them.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `conventions`
- `evaluatedAt`
- `operation` (string)
- `params`

### `fund_tearsheet` (~217 tokens)

Fund Tearsheet

The institutional tearsheet, reproducible: every ratio re-derivable from the returns series and the published formula version (PAID $5.00)

VALUE: Compute the tearsheet.

PRICE: $5.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `benchmark_returns`
- `periods_per_year` (number)
- `returns` (array)
- `risk_free` (number)

### `governance_reserve` (~244 tokens)

Governance Reserve

Agent Spend Governor — ATOMIC reserved lease (PAID $0.02)

VALUE: A leased, expiring reservation of budget for a named intent — spend that is committed before it is spent.

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `agent_id` (string, required)
- `amount` (number, required): Spend amount in USD. Must be >= 0 and <= 1e12. Values above the bound are rejected with 422.
- `intent` (string, required)
- `ttl_seconds` (integer)

### `governance_settle` (~203 tokens)

Governance Settle

Agent Spend Governor — settle a lease, idempotent (PAID $0.02)

VALUE: Closing a reservation against what was actually spent — the difference between a budget and a wish.

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `actual_amount` (number, required)
- `lease_id` (string, required)

### `identity_agent_attest` (~237 tokens)

Identity Agent Attest

Bind an agent to its operator and wallet, with the evidence and an honest grade of it (PAID $1.00)

VALUE: Bind an agent to its operator and its wallet.

PRICE: $1.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `agent_id` (string)
- `chain` (string)
- `evidence` (array)
- `operator` (string)
- `valid_from` (string)
- `validity_days`
- `wallet` (string)

### `identity_control_proof` (~210 tokens)

Identity Control Proof

Identity Control Proof

VALUE: Proof that a claimer controls an identifier, signed and dated — so an identity claim is a verification, not an assertion.

PRICE: $0.20 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `claimer` (string)
- `control_evidence`
- `control_method` (string)
- `identifier` (string)

### `index_x402` (~254 tokens)

Index X402

The signed Synthex Agentic-Commerce Index: a dated, rule-published mark (PAID $5.00)

VALUE: The Synthex Agentic-Commerce Index — a dated, signed mark on the agentic economy itself, computed from our own observation corpus of x402 settlements. The rules are published with the answer, so you can re-derive the marks.

PRICE: $5.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `date` (string)
- `methodology_version` (string)
- `top_n` (integer)
- `weighting` (string)

### `invoice_ocr` (~181 tokens)

Invoice Ocr

Invoice Ocr

VALUE: Structured line items, vendor and total from an invoice image — the manual data entry an agent removes.

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `file` (string, required)

### `latency_benchmark` (~217 tokens)

Latency Benchmark

Latency benchmark of a third-party API, measured by us (PAID $0.05)

VALUE: The latency percentiles of a vendor's API from our own probes — the number a performance-based selection is actually made on.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `samples` (integer)
- `url` (string, required)
- `window_hours` (integer)

### `licence_check` (~348 tokens)

Licence Check

Licence Check

VALUE: Whether a specific dataset licence permits a specific intended use in a specific jurisdiction — a legal question with a dated answer.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `dataset` (string, required): The dataset the question is about, e.g. 'OANDA v20 candles'.
- `intended_use` (string, required): What you intend to do with the data. One of: analyse, embed, aggregate, display, redistribute, resell, train.
- `jurisdiction`: The jurisdiction the use happens in, e.g. 'EU'. Recorded on the signed record; corpus v1 does not vary by jurisdiction.
- `licence_spdx`: The licence under which the data is held, as an SPDX id (MIT, Apache-2.0, GPL-3.0, CC-BY-NC-4.0, proprietary-vendor-tos, ...). OPTIONAL: if omitted, the dataset is matched against the corpus aliases;…

### `mandate_compliance` (~221 tokens)

Mandate Compliance

Signed compliance certificate: does this portfolio comply with this mandate (PAID $5.00)

VALUE: A signed, dated compliance certificate an allocator can actually file — replaces an analyst hour on a document, and never certifies compliance on missing evidence.

PRICE: $5.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `mandate`
- `observations`
- `portfolio`

### `market_calendar` (~215 tokens)

Market Calendar

Signed market-hours / holiday / settlement answer (PAID $0.01)

VALUE: Session hours, holidays and settlement cut-offs for a venue, DST aware — so you never settle into a closed market.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `nowEpoch`
- `operation` (string)
- `tradeDate`
- `venue` (string)

### `market_history` (~226 tokens)

Market History

Signed bar series over an explicit range (PAID $1.00)

VALUE: Historical bars for an instrument, formatted and bounded — the data a backtest needs, without hand-assembling it.

PRICE: $1.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `end`
- `format` (string)
- `instrument` (string)
- `source` (string)
- `start`
- `timeframe` (string)

### `market_history_bulk` (~215 tokens)

Market History Bulk

Signed bulk bar series, up to 20 pairs (PAID $5.00)

VALUE: The same history for many pairs in one call — the cost of a portfolio-wide study drops to a single request.

PRICE: $5.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `end`
- `format` (string)
- `pairs` (array)
- `start`

### `market_regime` (~202 tokens)

Market Regime

Is this market trending or ranging? Signed regime read from your own series (PAID $0.05)

VALUE: Return ONE signed, dated regime read.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `method` (string)
- `series` (object)

### `market_snapshot` (~231 tokens)

Market Snapshot

Signed OHLCV snapshot from our own market-data store (PAID $0.01)

VALUE: A point-in-time market snapshot for an instrument, bounded and timestamped — the 'now' you stamp a decision with.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of`
- `from_ts`
- `granularity` (string)
- `instrument` (string)
- `limit`
- `to_ts`

### `mcp_eval_judge` (~201 tokens)

Mcp Eval Judge

Judge Grade

VALUE: A rubric-scored judgement of a model response, signed and dated — evaluation you can re-check rather than re-argue.

PRICE: $0.15 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `response_pair`
- `rubric` (array)
- `subject` (string)

### `mcp_threatmodel_tool_permission` (~198 tokens)

Mcp Threatmodel Tool Permission

Tool Permission Threatmodel

VALUE: A threat model of a tool manifest with per-tool permissions and runaway protection — the analysis before you grant an agent a capability.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `manifest`
- `ownership_proof` (string)

### `mcp_verify_uptime` (~203 tokens)

Mcp Verify Uptime

Uptime Canary Probe

VALUE: Independent uptime confirmation tied to a settled receipt — proof of service that a self-report cannot manufacture.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `checks` (array)
- `last_confirmed_settlement_tx` (string)
- `service_url` (string)

### `memory_get` (~191 tokens)

Memory Get

Return the latest signed, reproducible sealed state for a key.

VALUE: Reading that durable memory back — continuity for an agent that must not forget.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `key` (string)
- `owner` (string)

### `memory_put` (~205 tokens)

Memory Put

Persist a budget-capped state version into a signed, reproducible memory vault.

VALUE: A durable, owned memory entry — a fact that survives the session and belongs to someone you can name.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `key` (string)
- `owner` (string)
- `value`

### `nav_attest` (~253 tokens)

Nav Attest

Signed NAV attestation for agent treasuries: what is this book worth, as of when, computed how (PAID $10.00)

VALUE: A signed NAV attestation for agent treasuries — the single document every allocator, auditor and counterparty asks for: what is this book actually worth, as of when, computed how.

PRICE: $10.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `cash`
- `currency` (string)
- `liabilities`
- `methodology`
- `positions`

### `output_verify` (~217 tokens)

Output Verify

Output Verify

VALUE: Whether an output actually satisfies its schema, claims and staleness budget — a check the model cannot run on itself.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `accuracy`
- `checks`
- `claimed`
- `output`
- `schema`
- `stalenessBudgetSeconds`
- `subject` (string)

### `pass_purchase` (~247 tokens)

Pass Purchase

Pass Purchase

VALUE: Prepaid capacity at a lower effective per-call price — the difference between renting and owning the cost.

PRICE: $25.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `calls_total` (integer): How many calls the pass buys. Default 1,000.
- `route_scope` (string): Which routes the pass covers. 'micro_le_0.25' = any live paid route priced at or below $0.25.
- `ttl_days` (integer): How many days the pass is valid for. Default 30.

### `pass_purchase_trial` (~199 tokens)

Pass Purchase Trial

Buy a trial prepaid capacity pass — $0.50 for 20 calls, 7 days (PAID $0.50)

VALUE: The trial tier of the same prepaid capacity — proof of the unit economics before you commit to the full pass.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

### `payment_deadline` (~238 tokens)

Payment Deadline

Will this payment settle inside my deadline? (PAID $0.05)

VALUE: Whether a payment will still settle inside your deadline, judged on the settlement times we have measured for that rail — the check that stops a slow rail from blowing a deadline.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `amount_usd` (number, required)
- `deadline` (string, required)
- `network` (string, required)
- `rail` (string, required)
- `submitted_at` (string, required)

### `payment_envelope_validate` (~213 tokens)

Payment Envelope Validate

Validate a captured x402 402 payment envelope (PAID $0.25)

VALUE: Whether a signed payment envelope is well-formed, unexpired and for the right resource — catch a bad payment before it settles.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `envelope`
- `now_epoch`
- `resource_url` (string)

### `policy_check` (~237 tokens)

Policy Check

Deterministic policy evaluation: is this action allowed under this policy given this caller state? Returns a signed allow/deny verdict with the specific rule that fired. Safe-deny on malformed input.

VALUE: Whether one action is permitted for one caller under one policy, as of one instant — enforcement you can ask a question of.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `action`
- `as_of` (string)
- `caller_state`
- `policy`

### `portfolio_risk` (~210 tokens)

Portfolio Risk

Signed exposure report under the caller's own risk model (PAID $3.00)

VALUE: Risk for a set of positions under a named model, dated — the number that decides whether a portfolio is sized right.

PRICE: $3.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `model`
- `positions`

### `preflight` (~261 tokens)

Preflight

Signed preflight verdict on a counterparty BEFORE you pay them. Returns a three-state verdict (go | caution | avoid | unknown) with dated, signed evidence. Fewer than 3 independent observations in 30 days returns `unknown` with the coverage gap named — never a guessed `go`.

VALUE: The agent's first call: a signed three-state verdict on a counterparty before you pay them, with the coverage gap named when there isn't enough evidence.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `checks` (array)
- `kind` (string)
- `target` (string, required)

### `pretrade_risk` (~245 tokens)

Pretrade Risk

Pre-trade risk gate: approve / reduce / reject an order against your own declared limits (PAID $0.25)

VALUE: The order gate: approve, reduce or reject an order against the risk limits you declared — and a `reduce` hands back a size that actually passes, so one bad order never reaches the market.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `account`
- `as_of` (string)
- `limits`
- `order`
- `positions`

### `procurement_reconcile` (~224 tokens)

Procurement Reconcile

Reconcile three ledgers — what was ordered, what was delivered, what was paid — with every variance naming its direction (PAID $0.50)

VALUE: Reconcile the three ledgers.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `amount_tolerance`
- `deliveries` (array)
- `orders` (array)
- `payments` (array)
- `quantity_tolerance`

### `provenance_overlay` (~213 tokens)

Provenance Overlay

Signed provenance for a piece of content, so a buyer can see where it came from (PAID $0.10)

VALUE: Produce a signed provenance overlay for a piece of content.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `content_sha256` (string)
- `creator`
- `sources` (array)
- `transformations` (array)

### `quant_monte_carlo` (~220 tokens)

Quant Monte Carlo

What does the equity curve look like? Seeded distribution of terminal outcomes (PAID $0.15)

VALUE: Return ONE signed, dated Monte Carlo distribution.

PRICE: $0.15 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `runs` (integer)
- `seed` (integer)
- `trade_distribution` (object)
- `trades` (integer)

### `quant_overlap` (~200 tokens)

Quant Overlap

Are these two strategies the same bet? Signed correlation matrix and clusters (PAID $0.10)

VALUE: Return ONE signed, dated overlap matrix.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `strategies` (array)
- `threshold` (number)

### `quant_risk_of_ruin` (~240 tokens)

Quant Risk Of Ruin

Can this sizing scheme bankrupt me? First-passage ruin probability with Kelly (PAID $0.05)

VALUE: Return ONE signed, dated risk-of-ruin answer.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `avg_loss_r`
- `avg_win_r`
- `capital`
- `risk_per_trade_pct`
- `seed` (integer)
- `trades`
- `win_rate`

### `quant_significance` (~224 tokens)

Quant Significance

Is this return stream distinguishable from noise? Seeded sign-flip permutation test (PAID $0.05)

VALUE: Return ONE signed, dated significance test.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `benchmark_returns`
- `null` (string)
- `returns` (array)
- `seed` (integer)
- `trials` (integer)

### `quota_preflight` (~220 tokens)

Quota Preflight

Signed quota reservation decision (PAID $0.01)

VALUE: Whether a call fits a remaining quota, before you spend it — the check that stops a quota from being discovered by exhaustion.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `agentId` (string)
- `calls`
- `quota`
- `requestId` (string)
- `target` (string)

### `readiness_attest` (~207 tokens)

Readiness Attest

Readiness Attest

VALUE: A signed readiness attestation with the evidence and policy snapshot behind it — readiness you can evidence, not assert.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `custodian` (string)
- `policy_snapshot`
- `readiness_evidence` (array)
- `target` (string)

### `attestation_receipt` (~225 tokens)

Attestation Receipt

Mint a signed typed receipt for any transaction or action.

VALUE: A signed receipt for an action, mintable as evidence of what happened — a portable 'it did that'.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `action` (string)
- `actor` (string)
- `metadata`
- `receipt_type` (string)
- `subject` (string)
- `tx` (string)

### `signed_research` (~212 tokens)

Signed Research

Generate a tamper-evident, signed research brief on a requested topic.

VALUE: A researched brief on a topic with its sources and depth stated, attested — research with a provenance you can point at.

PRICE: $2.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `context` (string)
- `depth` (string)
- `topic` (string)

### `route_execute` (~213 tokens)

Route Execute

An ADVISORY execution plan for moving money — it never moves money: no keys, no signing, no broadcast (PAID $0.05)

VALUE: Plan the route. Advisory only.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `constraints` (object)
- `intent` (object): What the caller wants to move.
- `rail_table`

### `sec_extract` (~180 tokens)

Sec Extract

Sec Extract

VALUE: Structured data extracted from a company's SEC filings — primary filings, not a data vendor's interpretation of them.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `ticker` (string)

### `security_dependency_risk` (~188 tokens)

Security Dependency Risk

Dependency Risk

VALUE: Risk analysis of a dependency set for a given ecosystem — supply chain exposure enumerated rather than assumed.

PRICE: $0.20 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `dependencies` (array)
- `ecosystem` (string)

### `security_redteam_authorized_scan` (~217 tokens)

Security Redteam Authorized Scan

Redteam Authorized Scan

VALUE: An authorized adversarial scan of a target you have evidence of permission to test — the finding, with the authorization on the record.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `authorization_evidence` (array)
- `authorized_tests` (array)
- `scope_description` (string)
- `target_url` (string)

### `security_threatmodel` (~188 tokens)

Security Threatmodel

Threatmodel Analyze

VALUE: A threat model of a tool manifest in its deployment context — attack surface before it is exploited.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `deployment_context` (string)
- `tool_manifest`

### `settlement_conditional` (~251 tokens)

Settlement Conditional

Signed conditional-release verdict — are the release conditions met? (PAID $0.25)

VALUE: A settlement that releases only if its named conditions hold — escrow logic as a single call.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of`: The evaluation instant, ISO-8601. Pinned into the evidence core so the digest is reproducible.
- `conditions` (array): The conditions to evaluate. An empty list yields verdict 'hold' — never 'release'.
- `deal_id` (string): The caller's deal id.

### `settlement_receipt` (~238 tokens)

Settlement Receipt

Signed settlement-receipt verdict for a tx hash (PAID $0.01)

VALUE: Independent confirmation that a transaction settled to the right payee for the right amount — proof of payment from the ledger, not from the payer.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `expectedAmountAtomic`
- `minConfirmations`
- `payee` (string)
- `payer` (string)
- `receipt`
- `txHash` (string)

### `settlement_route_advice` (~225 tokens)

Settlement Route Advice

Which rail should this settlement use? Fee, speed and the constraint that excluded every other rail (PAID $0.50)

VALUE: Advise on the settlement route.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `amount_usd`
- `asset` (string)
- `constraints` (object)
- `destinations` (array)
- `rail_table`
- `urgency` (string)

### `sla_breach_evidence` (~221 tokens)

Sla Breach Evidence

Evidence package for a vendor SLA breach (PAID $1.00)

VALUE: The evidence package when a vendor misses its stated SLA: measured against claimed, with the shortfall itemised — what a dispute needs and nobody has.

PRICE: $1.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `claimed_sla` (object)
- `url` (string, required)
- `window_hours` (integer)

### `sme_screen` (~507 tokens)

Sme Screen

Screen an SME sale against the house LBO structure and rules (PAID $2.50)

VALUE: A structured screen of an SME on turnover, EBITDA, structure and sector — the first pass over an acquisition candidate.

PRICE: $2.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `ebitda_eur`: Annual EBITDA in EUR. REQUIRED. Undisclosed is NOT zero — an undisclosed figure returns insufficient_data, never a model.
- `employees`: Headcount. Optional; reported in the echoed input block.
- `exit_multiple`: The exit EV/EBITDA multiple. Optional; the house base case of 4.0x is applied and the default is named in coverage_gaps.
- `location`: The location, free text, e.g. 'Lisboa'. Echoed back in the response; it is the caller's own input, not pipeline data.
- `notes`: Free text. Used only for the Rule B food-service check. It is NOT stored, NOT logged and NOT returned.
- `price_eur`: The asking price in EUR. REQUIRED.
- `sector`: The sector, free text, e.g. 'Business services — accounting & tax advisory'. Used for Rule B (food service) and for the benchmark bucket. Matching is word-boundary and accent-insensitive.
- `seller_financing_pct`: Seller financing offered, as a percentage of price. The house approach is 20-30%, so 20 or more is reported as 'preferred' and less as 'absent'.
- `structure`: The capital structure. 'house' is the ONLY supported structure in v1. Anything else is NAMED in coverage_gaps — it is never silently modelled as something it is not.
- `turnover_eur`: Annual turnover (revenue) in EUR. REQUIRED.

### `spend_anomaly` (~215 tokens)

Spend Anomaly

Is this agent's spending behaving normally? A named z-score test and the counterparty that drove it (PAID $0.05)

VALUE: Judge whether the spend is normal.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `agent_id` (string)
- `baseline` (object): The baseline the window is judged against.
- `spend_window` (array)

### `spend_ledger_attest` (~223 tokens)

Spend Ledger Attest

Signed attestation of an agent's spend (PAID $0.50)

VALUE: A signed, dated attestation of what an agent spent, for its principal — the artefact that makes an agent's spend reviewable instead of self-reported.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `agent_id` (string, required)
- `entries` (array)
- `period` (object)

### `strategy_capacity` (~316 tokens)

Strategy Capacity

How much money can this strategy actually carry? Returns capacity_computed | insufficient_input | no_capacity, with the capacity, a band, the binding constraint, the alpha after costs and a degradation curve. Capacity DECREASES as the assumed Sharpe falls. A missing adv_usd returns insufficient_input naming the field — the engine never guesses a liquidity figure.

VALUE: How much money can this strategy actually carry? The answer every allocator asks and almost nobody can give, because the cost-to-alpha term needs a graded-strategy population to calibrate — and we hold one. Returns the capacity, the binding constraint, the alpha after costs and the degradation curve. The impact model is stated with its provenance and every parameter is overridable.

PRICE: $10.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `capital`
- `market`
- `strategy`

### `strategy_verdict` (~225 tokens)

Strategy Verdict

Is this edge deployable? Deflated Sharpe with a calibrated multiple-testing threshold (PAID $2.00)

VALUE: Return ONE signed, dated strategy verdict.

PRICE: $2.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `benchmark_returns`
- `claimed_sharpe`
- `periods_per_year` (integer)
- `returns` (array)
- `trials`

### `synthesis_verdict` (~215 tokens)

Synthesis Verdict

Fold research + quant + audit inputs into ONE signed verdict.

VALUE: A signed verdict fusing audit, quant and research inputs on one subject — the answer, with the inputs that produced it.

PRICE: $0.50 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `audit` (array)
- `quant` (array)
- `research` (array)
- `subject` (string)

### `task_acceptance` (~216 tokens)

Task Acceptance

Did the work meet the spec, criterion by criterion? Per-criterion pass / fail / undetermined, with an absent observation never counted as a pass (PAID $0.25)

VALUE: Grade the observations against the spec.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `observed` (object)
- `spec` (object): The spec the work is judged against.

### `uptime_attest` (~214 tokens)

Uptime Attest

Signed uptime of a third-party API, measured by us (PAID $0.10)

VALUE: The uptime of a vendor's API, measured by us and signed, so you are not trusting their own status page when you make a procurement call.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `url` (string, required)
- `window_hours` (integer)

### `utils_code_review_brief` (~190 tokens)

Utils Code Review Brief

Utils Code Review Brief

VALUE: A structured review brief for a code block — the issues worth reading, separated from the noise.

PRICE: $0.15 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `code` (string)
- `language` (string)

### `utils_doc_convert` (~189 tokens)

Utils Doc Convert

Utils Doc Convert

VALUE: Converting a document between formats with a signed output — turning a file into something a machine can read.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `text` (string)
- `to` (string)

### `utils_invoice_extract` (~180 tokens)

Utils Invoice Extract

Utils Invoice Extract

VALUE: Structured line items from invoice text — the manual data entry an agent removes, without the image.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `text` (string)

### `utils_pii_redact` (~193 tokens)

Utils Pii Redact

Utils Pii Redact

VALUE: Redacting names and other identifiers from text, in place — compliance with a diff you can inspect.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `redact_names` (boolean)
- `text` (string)

### `utils_schema_cleanup` (~188 tokens)

Utils Schema Cleanup

Utils Schema Cleanup

VALUE: Cleaning a CSV or JSON payload against a schema — the messiness removed before it reaches your model.

PRICE: $0.05 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `csv` (string)
- `data` (object)

### `utils_translate_doc` (~195 tokens)

Utils Translate Doc

Utils Translate Doc

VALUE: Translating a document with its structure preserved — a document an agent in another language can actually use.

PRICE: $0.10 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `src` (string)
- `target` (string)
- `text` (string)

### `verdict_agent` (~188 tokens)

Verdict Agent

Dated signed verdict on a counterparty wallet (PAID $0.02)

VALUE: Is this wallet safe to transact with right now?

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `address` (string, required)
- `chain`

### `verdict_batch` (~203 tokens)

Verdict Batch

Judge a whole portfolio in one call. Batch verdict with significance, risk and overlap (PAID $5.00)

VALUE: Return ONE signed, dated batch verdict.

PRICE: $5.00 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `as_of` (string)
- `checks` (array)
- `items` (array)

### `verdict_endpoint` (~195 tokens)

Verdict Endpoint

Dated signed verdict on an endpoint (PAID $0.02)

VALUE: Will this URL pay me if I call it?

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `expected_price_usd`
- `url` (string, required)
- `window_hours`

### `verdict_service` (~187 tokens)

Verdict Service

Dated signed verdict on a listed service (PAID $0.02)

VALUE: Is this listed service alive, honest and fairly priced?

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `service_name`
- `url`

### `verdict_tool` (~189 tokens)

Verdict Tool

Dated signed verdict on an MCP tool (PAID $0.02)

VALUE: Is this MCP tool safe to grant?

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `server_url` (string, required)
- `tool_name` (string, required)

### `verify_catalog_register` (~230 tokens)

Verify Catalog Register

Register a service into the network-effect verify catalog and grow the trust index.

VALUE: Registering a service in the verification catalogue with its signature — the entry that lets others verify it too.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `claim`
- `claim_sha256` (string)
- `edges` (array)
- `service_name` (string)
- `service_url` (string)
- `signature` (string)

### `signed_attest` (~217 tokens)

Signed Attest

Create a signed, tamper-evident track-record attestation (Ed25519 + SHA-256) over any claim.

VALUE: A signed, dated attestation of a claim with a claim type — a standalone 'this is true, and here is when'.

PRICE: $0.25 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `claim` (object, required)
- `claim_type` (string)

### `x402_anchor` (~208 tokens)

X402 Anchor

Dated proof of what existed at time T (PAID $0.01)

VALUE: A dated economic anchor point for the x402 economy — the yardstick for whether activity is actually growing.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `date` (string): UTC calendar date, YYYY-MM-DD. Empty = today (UTC).

### `x402_index` (~401 tokens)

X402 Index

The queryable index of the agent economy: what is offered, what it costs, and whether it still works. An endpoint is never invented — every result exists in the corpus with a `last_seen`.

VALUE: The live index of paid x402 services, filterable by price, network and conformance — where new services are found.

PRICE: $0.02 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `limit` (integer): Maximum results. Default 25, hard-clamped to 100.
- `max_price_usd`: Price ceiling in USD. An endpoint whose price we have NOT observed is EXCLUDED from a price-filtered query — an unknown price is not a cheap price.
- `min_uptime_pct`: Uptime floor in percent. An endpoint we cannot yet score (fewer than 3 observations) is EXCLUDED — we do not guess.
- `network` (string): CAIP-2 network filter, e.g. 'eip155:8453'. Empty = any.
- `query` (string): Free-text capability match against the observed catalogue (path + summary + declared tags). Empty string = all. Supports a substring match and a token AND-match.
- `require_conformance` (boolean): When true, drop every endpoint whose conformance is 'insufficient_observations'.

### `x402_quote` (~224 tokens)

X402 Quote

Cost + landing quote for a target call (PAID $0.01)

VALUE: What a call will actually cost and whether it will land, priced from the 402 envelopes we have observed ourselves — so an agent prices a vendor before it commits instead of after.

PRICE: $0.01 USDC per call.

HOW TO PAY: USDC on eip155:8453, exact scheme, to 0xc8fF67FAE72596478599EAAcfad8656fAe1113c8. Sign an EIP-3009 transferWithAuthorization for the exact amount and put it in the `X-PAYMENT` header, then retry the same call. An unpaid call returns a `payment_required` payload with the amount, asset, network and payTo already filled in. The `synthex-x402` SDK (PyPI and npm) does the 402 -> sign -> retry loop in one call.

Input parameters:

- `request` (object)
- `target_url` (string, required)
- `urgency` (string)

### `health` (~76 tokens)

Health

Liveness and settlement-configuration probe for the x402 service. Returns the live network, receive address and whether settlement is enabled.

VALUE: Free, because an agent that cannot tell a live service from a dead one pays for nothing useful.

PRICE: FREE — no payment required.

Call it directly. No payment, no headers, no account.

### `verify_signature` (~146 tokens)

Verify Signature

Verify a signed receipt you already hold — FREE, no payment, no network call to us. Recomputes the canonical JSON digest and checks the Ed25519 signature against the published public key, so you can confirm a receipt's authenticity before you act on it.

VALUE: Free, because verifying a receipt you already paid for must never cost a second payment.

PRICE: FREE — no payment required.

Call it directly. No payment, no headers, no account.

Input parameters:

- `body` (object, required): The exact JSON body that was signed.
- `sha256` (string, required): The sha256 hex digest of the canonical body.
- `signature` (string, required): The base64 Ed25519 signature.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-synthexforge-x402-paid-agent-services/x402#diagnostics

## Score history

- 2026-10-23: 63
- 2026-10-22: 69

## Common questions

### What is the Synthex Forge — x402 Paid Agent Services MCP server?

Synthex Forge — x402 Paid Agent Services is an MCP server listed in the public MCP registry as com.synthexforge.x402/paid-agent-services. Paid agent services settled in USDC on Base via x402. Signed, verifiable, and free to verify. This page covers its hosted endpoint (https://x402.synthexforge.com/mcp).

### Is the Synthex Forge — x402 Paid Agent Services MCP server safe to use?

Synthex Forge — x402 Paid Agent Services scores 63 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Synthex Forge — x402 Paid Agent Services MCP server expose?

Synthex Forge — x402 Paid Agent Services exposes 110 tools: api_ebook_download, rates_reference, signed_research_get, social_search, a2a_escrow, and 105 more. Their descriptions and schemas cost roughly 25,326 tokens of context every time the server is loaded.

### Does the Synthex Forge — x402 Paid Agent Services MCP server require authentication?

No. We connected to Synthex Forge — x402 Paid Agent Services without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Synthex Forge — x402 Paid Agent Services MCP server still maintained?

Synthex Forge — x402 Paid Agent Services is still listed as active in the MCP registry. We last reached this channel on 23 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://x402.synthexforge.com/mcp
- Repository: https://github.com/hermeschoosenone-debug/synthex-x402
- Website: https://synthexforge.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-synthexforge-x402-paid-agent-services/x402.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-synthexforge-x402-paid-agent-services/x402.json
- HTML version of this page: https://verifymcp.io/servers/com-synthexforge-x402-paid-agent-services/x402