> For the complete documentation index, see [llms.txt](/llms.txt).

Hardware Hunter sells trusted price intelligence per query using the [Machine Payments Protocol (MPP)](https://mpp.dev) — an open standard co-authored by Stripe and Tempo for autonomous machine-to-machine commerce. HTTP 402, native challenge/credential authentication, no account registration, and no API key on the paid path. If you're an AI agent with a funded Tempo wallet, you can buy cohort medians for about a cent.

## What you're buying

Cohort price statistics (p25 / median / p75) for flagship PC hardware components, computed from distinct marketplace listings in a rolling 90-day window and **gated on provider-established evidence**:

- currency provenance (provider-stated or storefront-locale-derived, never assumed)
- condition evidence from the listing source (used / new / refurbished / open box)
- one comparable price per distinct listing — repeated fetches never inflate the sample
- minimum sample thresholds before anything is published

Benchmarks are per exact SKU: capacity is part of the identity (a 980 Pro 2TB and 1TB are different products at different prices), so every catalog entry and paid response carries a `capacity` field and a capacity-qualified `name`. Match on those, not the model name alone.

Every paid response carries `benchmark_trust` metadata stating the policy version and basis. **Insufficient components are served free, never charged** — you only pay when trusted data is returned.

## The two endpoints

### `GET /api/x402/pricing/catalog` — free discovery

No payment, no key. Lists every trusted component with its capacity, status, available condition strata, payment rails (`x402`, `mpp_tempo`), and the live per-query price. Read this first: price before you pay.

```bash
curl -s https://hardwarehunter.io/api/x402/pricing/catalog
```

### `GET /api/x402/pricing/component/{id}` — the paid query

Takes a component `id` from the catalog. Payment is demanded **only when trusted data exists**; unknown or insufficient components return free (404 / truthful insufficient body).

## The payment flow

1. `GET` the paid endpoint. A trusted benchmark returns **402 Payment Required** with a standard MPP challenge:
   `WWW-Authenticate: Payment id="<challenge_id>", method="tempo", intent="charge", realm="hardware-hunter", ...`
   accompanied by an RFC 9457 `application/problem+json` envelope detailing the challenge parameters.
2. Build and sign a payment credential against those requirements (method: `tempo`, currency: USDC/pathUSD, amount matching the per-query price).
3. Retry the request with the `Authorization: Payment <credential>` header (or `Payment-Authorization: Payment <credential>`).
4. The server verifies and settles the transaction on the Tempo network, logs the settlement to our audit ledger, and returns **200 OK** with the data payload and a `Payment-Receipt: <receipt>` header containing the on-chain settlement receipt.

## Client example (Python)

The official [pympp SDK](https://github.com/tempo-run/mpp-python) handles the 402 challenge negotiation, payment signing, and settlement receipt cycle automatically:

```python
from mpp.client import Client
from mpp.methods.tempo import ChargeIntent, TempoAccount
from mpp.methods.tempo.client import tempo

# Configure the Tempo payment method with an agent private key
method = tempo(
    account=TempoAccount.from_key(PRIVATE_KEY),
    intents={"charge": ChargeIntent()},
)

# Client negotiates 402 challenge, signs credential, and settles automatically
async with Client(methods=[method]) as client:
    response = await client.get(
        "https://hardwarehunter.io/api/x402/pricing/component/"
        "242957af-a870-4f47-912b-d04c1dd6f464"
    )
    data = response.json()
    print(data["summary"]["median_price"])
```

## Networks and pricing

| Item | Value |
|---|---|
| Protocol | Machine Payments Protocol ([MPP](https://mpp.dev), IETF draft) |
| Method | `tempo` |
| Intent | `charge` |
| Network | Tempo (`chain_id=4217` mainnet, `chain_id=42431` testnet) |
| Asset | USDC or pathUSD |
| Price | ~$0.01 per paid query (reported live in the catalog) |
| Free allowance | None on trusted component queries; catalog and insufficient-data responses remain free |

The catalog is the free preflight for the configured rails and advertised USD price. The 402 challenge is authoritative for payment parameters: method, intent, recipient address, and amount.

## Dual-rail interoperability

Hardware Hunter endpoints support dual-rail machine payments. The paid endpoint (`/api/x402/pricing/component/{id}`) responds with challenge headers for both [x402](/docs/paying-with-x402) (`PAYMENT-REQUIRED`) and [MPP](/docs/paying-with-mpp) (`WWW-Authenticate: Payment ...`). Agents can pay using either standard:

- **x402**: EVM EIP-3009 transfer authorization via Coinbase CDP / Base.
- **MPP**: Tempo charge intent via `pympp`.

Both rails settle into the same unified audit ledger and return the exact same trusted benchmark data.

## Honest limits

- The paid surface covers the components in the catalog — currently a curated flagship set (GPUs, high-capacity storage), expanding as evidence accumulates.
- Condition-stratified medians (used vs new vs refurbished) appear per component as their evidence crosses publication thresholds; the catalog shows which strata each component currently publishes.
- We do not publish trends, forecasts, or "market verdicts" — medians over verified comparable listings only. See [how scoring works](/docs/how-scoring-works) for what a hunt match means.

## Free-tier notes

The [catalog](https://hardwarehunter.io/api/x402/pricing/catalog) is always free, and insufficient-data responses are never charged. Every docs page also has a `.md` mirror. For bulk or commercial access, [talk to us](mailto:hello@hardwarehunter.io).