Intro
Yes — AlgoVault exposes get_trade_call over x402. An autonomous agent POSTs to the endpoint, receives an HTTP 402 challenge naming the price and resource, pays USDC on Base L2, retries with the x-payment header, and receives a composite { verdict, confidence, regime, factors } response. No API key. No subscription. No seat license. Just a Base wallet and a request.
The record it is paying against is independently verifiable: 91.8% PFE win rate across 417,025+ verified calls, Merkle-anchored on Base L2. That combination — machine-payable rails on the request side, Merkle-anchored accuracy on the record side — is why this post exists. Agent builders searching for a metered, keyless trade-call API rarely find a direct answer. This is one.
How does x402 pay-per-call work for a crypto trade-call API?
The x402 protocol turns the long-idle HTTP 402 Payment Required status into a working machine-payments rail. The flow is simple. The client POSTs to the resource. The server responds with a 402 body that names the accepting network (Base L2), the settlement asset (USDC), the exact price, and a resource identifier. The client's wallet signs an x-payment header. The client retries. The server verifies settlement on-chain, executes the request, and returns the response body.
There is no account. There is no bearer token stored in a vault. The agent's Base wallet is the credential, the meter, and the receipt. That is the whole point: an autonomous process can transact for data or decisions without a human ever provisioning it.
Here is the 402 challenge an agent sees on the first unpaid POST to get_trade_call. The exact field names should be reconciled against the live route at integration time — the shape below is illustrative of x402Version 2 semantics.
{
"x402Version": 2,
"error": "Payment Required",
"accepts": [
{
"scheme": "exact",
"network": "base",
"asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
"maxAmountRequired": "10000",
"resource": "https://api.algovault.com/x402/get_trade_call",
"description": "Composite trade-call verdict, one call",
"mimeType": "application/json",
"payTo": "0x0000000000000000000000000000000000000000",
"maxTimeoutSeconds": 60
}
]
}
For deeper protocol reading, the Model Context Protocol specification covers the tool-invocation contract, and the x402 protocol specification covers the payment envelope. Both are neutral, authoritative references — the answer here is not "x402 is a marketing shell", it is "x402 is a standard, and get_trade_call implements it."
How do I wire the x402 trade-call endpoint into my agent? (an implementation walkthrough)
Below is a minimal client wrapper. The wallet client is a viem account on Base with a USDC balance. The x402-fetch-style wrapper intercepts the 402, signs the x-payment header, retries the request, and returns the paid response as a normal Response.
// Illustrative — verify the exact client library + request/response shape against the live route.
import { wrapFetchWithPayment } from "x402-fetch";
import { createWalletClient, http } from "viem";
import { base } from "viem/chains";
const wallet = createWalletClient({ chain: base, transport: http() /* account: ... */ });
const pay = wrapFetchWithPayment(fetch, wallet);
const res = await pay("https://api.algovault.com/x402/get_trade_call", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ coin: "BTC", timeframe: "1h" }),
});
const call = await res.json();
// composite call: { verdict, confidence, regime, factors }
console.log(call.verdict, call.confidence, call.regime);
// No wallet yet? The keyless free tier (100 calls/month) serves the same shape:
// POST https://api.algovault.com/mcp (get_trade_call, no x-payment header)
The retried, paid response is a composite verdict. The top-level call names the direction, _receipts carries the audit envelope (verdict, factor breakdown, and a live track-record snapshot), and also_see surfaces higher-conviction adjacent calls the agent can consider without a second POST. A real response looks like this.
{
"content": [
{
"type": "text",
"text": "{\n \"call\": \"HOLD\",\n \"confidence\": 15,\n \"price\": 63177.7,\n \"indicators\": {\n \"funding_rate\": 0.00000599,\n \"funding_state\": \"NORMAL\",\n \"oi_change_pct\": -1.67,\n \"trend_persistence\": \"HIGH\"\n },\n \"regime\": \"RANGING\",\n \"reasoning\": \"Ranging regime, no clear direction. Funding pressure mild. No actionable setup at this snapshot.\",\n \"coin\": \"BTC\",\n \"timeframe\": \"15m\",\n \"_algovault\": {\n \"version\": \"1.24.1\",\n \"tool\": \"get_trade_call\",\n \"exchange\": \"BINANCE\"\n },\n \"_receipts\": {\n \"verdict\": \"HOLD\",\n \"conviction_pct\": 15,\n \"regime\": \"RANGING\",\n \"factors\": [\n { \"factor\": \"trend_persistence\", \"direction\": \"neutral\", \"value\": \"HIGH\" },\n { \"factor\": \"funding_state\", \"direction\": \"neutral\", \"value\": \"NORMAL\" },\n { \"factor\": \"oi_change_pct\", \"direction\": \"bearish\", \"value\": \"-1.7%\" }\n ],\n \"verification_uri\": \"https://algovault.com/track-record\"\n },\n \"closest_tradeable\": { \"coin\": \"SOL\", \"timeframe\": \"1h\", \"confidence\": 62 }\n}"
}
]
}
Dropped into an agent loop, the response fits any orchestration shape: LangGraph, a custom MCP client, a plain scheduled worker. The agent gates its own execution on confidence and the factor breakdown; AlgoVault provides the thesis, the agent decides execution. A DRYRUN pass against the shipped example looks like this.
# AlgoVault MCP example — coins=BTC confidence_threshold=70
[BTC] {
"call": "HOLD",
"confidence": 3,
"price": 63177.7,
"indicators": {
"funding_rate": 0.00000599,
"funding_state": "NORMAL",
"oi_change_pct": -1.67,
"trend_persistence": "HIGH"
}
}
# DRYRUN_MODE=1 — example complete
The keyless free tier serves the identical response shape from POST https://api.algovault.com/mcp with no x-payment header at 100 calls/month. That is the on-ramp for agents that do not yet hold a Base wallet.
Why pay-per-call instead of an API key or subscription?
An API key is a human-provisioned credential. Someone signs up, receives the key, pastes it into a vault, rotates it on a cadence, and pays a monthly bill for a seat that may or may not be used. That workflow is designed for humans building integrations. It is a poor fit for a fleet of autonomous agents that spawn, act, and terminate on their own schedule.
Pay-per-call inverts the model. The agent is the payer. The unit of billing is the unit of work. There is no monthly commitment to right-size, no seat to reclaim, no key to rotate, no vault to breach. When the agent stops calling, the meter stops.
Machine-payable rails also compose. Because settlement is on-chain USDC, the same wallet the agent uses to pay for a trade-call can pay for compute, storage, or another data source, and the aggregate ledger is the agent's own transaction history. This is what x402 unlocks — not a novel pricing gimmick, but the credential-and-billing surface autonomous processes actually want. For AlgoVault it aligns with the suite lock-in moat: every additional AlgoVault primitive an agent adopts pays the same way, into the same wallet, with the same audit trail.
How do I verify the trade calls are actually accurate?
Every completed call's outcome is aggregated into a public accuracy record and Merkle-anchored on Base L2. The public accuracy field is PFE win rate — the proportion of directional calls that touched their predicted move before the invalidation criterion. It is a single, aggregated, auditable number.
The live number is 91.8% PFE win rate across 417,025+ verified calls, Merkle-anchored on Base L2. You can audit any individual call and confirm it belongs to a Merkle root written on-chain at algovault.com/verify. That is what "verifiable" means in this stack: not a screenshot of a dashboard, not a signed PDF, but a root on a public chain that the buyer can independently recompute.
For an agent, this matters because the thing it is paying for — the composite verdict — has a public accuracy prior. The agent can weight its own execution by both the per-call confidence and the aggregate track record. It does not have to trust the vendor. It can check.
What pitfall should I avoid with x402 trade-call payments?
Three honest ones.
First, do not treat get_trade_call as a microsecond execution feed. It is a decision endpoint on the timeframe the caller selects — the same call at 1m and 1d returns different verdicts because the composite runs against different windows. Wire it into your interpret step, not your microsecond execute loop. If your agent trades on tick data, x402's HTTP round-trip plus on-chain settlement is not the right rail for the fill decision — it is the right rail for the setup decision that precedes it.
Second, fund the wallet with USDC on Base — not Ethereum mainnet, not another L2. The 402 challenge names the accepting network in its accepts array; a wallet holding USDC on the wrong chain will fail the retry silently as far as the agent is concerned (the request gets another 402, not a paid response). Log the 402 body during development so this is obvious.
Third, this is analytics, not investment advice. The response includes a disclaimer field in _receipts for a reason. An agent consuming the verdict is choosing to act on it; AlgoVault provides the thesis, the agent decides execution.
What's Next?
- Audit the live accuracy record at the track record — every call, every Merkle root, every outcome.
- Read the endpoint contract and the full response schema in the docs.
- Fork the reference client from the GitHub repo and wire it into your agent loop.
Run get_trade_call free — 100 calls/month →
FAQ
Is there an x402 pay-per-call crypto trade-call API for agents? Yes — AlgoVault exposes get_trade_call over x402Version 2, priced per call, settled in USDC on Base L2.
How does the call settle? The first POST returns HTTP 402 with the price and resource. The client signs an x-payment header, retries, and settlement is verified on Base L2 before the response body is returned.
Do I need an API key? No. The Base wallet paying the x-payment header is the credential. The keyless free tier at https://api.algovault.com/mcp also serves the same response shape at 100 calls/month with no wallet.
How is accuracy verified? Aggregated PFE win rate is Merkle-anchored on Base L2 and any individual call can be audited at algovault.com/verify.
What does a single call return? A composite { verdict, confidence, regime, factors } on the timeframe the caller selects, plus a _receipts envelope with the factor breakdown and a live track-record snapshot.
⭐ Star the repo to follow new exchanges and signals: https://github.com/AlgoVaultLabs/crypto-quant-signal-mcp
Top comments (0)