x402 · Algorand · Base · Polygon · Solana · USDC per call

An adversarial second opinion
for AI agents.

An independent adversarial agent tries to break your claim before you act on it. Pay a few cents per verdict — in USDC on any of 4 chains (Algorand · Base · Polygon · Solana). No account, no API key, no subscription — just HTTP 402.

Try it free — no wallet needed

The identical engine the paid tier runs — same model, same calibration — so what you try is what you buy. Trial verdicts are unsigned; paid verdicts add the offline-verifiable receipt.

3 free checks a day · no wallet
Same endpoint from a terminal
curl -s -X POST https://secondopinionx402.com/v1/try \
  -H 'content-type: application/json' \
  -d '{"claim":"Ed25519 signatures can be verified offline using only the public key"}'

Why agents call this

Agents fail worst when they are most confident, and self-checking shares the same blind spots as the original reasoning. Second Opinion is a different model instance with fresh context, live web access, and one paid incentive: refute the claim if it can be refuted. Call it at the moment of irreversible commitment — before code, money, publication, or a promise:

01
Before code ships

A coding agent, before building a day's work on "library X v3 supports streaming natively" — 20¢ against a wasted day.

02
Before research ships

A research agent, before a blog-sourced stat ships in a client report — the verdict's citations become the footnotes.

03
Before a promise

A support agent, before promising "the warranty covers water damage" — a 2¢ reasoning check on its reading of the policy.

04
Before paying another agent

An agent that hired another agent, spot-checking the deliverable's load-bearing claims before accepting and paying.

Every verdict doubles as an audit receipt: independent check, timestamped, payment on-chain — something self-verification can never produce.

Endpoints & pricing

Quick
$0.02

Reasoning-only check, no web research — the habit tier. Honest "needs research" escalation.

Verify
$0.20

One independent skeptic, live web research, structured verdict with citations.

Panel
$0.75

Three skeptics — evidence · logic · currency — majority verdict with per-seat breakdown.

EndpointPriceWhat you get
POST /v1/tryfreeTrial: the quick check, 3/day per caller, no wallet — unsigned verdict
POST /v1/verify/quick$0.02Reasoning-only check, no web research — the habit tier. Honest "needs research" escalation
POST /v1/verify$0.20One skeptic, live web research, structured verdict
POST /v1/verify/panel$0.75Three skeptics (evidence · logic · currency), majority verdict
POST /v1/verify/async$0.20Async variant: instant job id, poll free result_url. Required for Solana payers
POST /v1/verify/panel/async$0.75Async panel
GET /v1/schemafreeMachine-readable version of this page

Verdicts are refuted, supported, or inconclusive, each with calibrated confidence, findings, and the URLs actually consulted. Failed sync requests (5xx) are never settled, and failed async jobs retry free — you only pay for delivered verdicts.

Chains: pay on Algorand · Base · Polygon · Solana — same price, same product. Algorand is the preferred rail (listed first in every 402). Solana payers must use the /async routes: Solana transactions expire in ~1 minute, so the async flow settles your payment in seconds and serves the verdict via the free result URL.

Call it

Client libraries for JS/TS and Python handle the payment, polling, and receipt verification for you — keys sign locally and never leave your process:

npm install secondopinion-x402   # Node — pays on Base, Algorand or Solana
pip install secondopinion-x402   # Python — pays on Base; LangChain + CrewAI tools
import { SecondOpinion } from "secondopinion-x402";

const so = new SecondOpinion();   // wallet key from env; freeTry() needs none
const verdict = await so.verify("Library X v3 supports streaming responses natively", {
  context: "About to migrate our retry logic to rely on this",
});
if (verdict.verdict === "refuted") { /* stop and re-plan */ }
await so.verifyReceipt(verdict);  // Ed25519 receipt, verified offline

Or wire any x402 client yourself

import { wrapFetchWithPayment, x402Client } from "@x402-avm/fetch";
import { toClientAvmSigner, ALGORAND_MAINNET_CAIP2, NETWORK_TO_ALGOD } from "@x402-avm/avm";
import { ExactAvmScheme } from "@x402-avm/avm/exact/client";

// signer: your Algorand account (holds a little USDC on algorand mainnet)
const signer = toClientAvmSigner(process.env.PAYER_SK_B64);
// Pin the scheme to the network's algod node — an unconfigured wildcard
// registration silently builds testnet transactions and fails verification.
const client = new x402Client().register(
  ALGORAND_MAINNET_CAIP2,
  new ExactAvmScheme(signer, { algodUrl: NETWORK_TO_ALGOD[ALGORAND_MAINNET_CAIP2] }),
);
const payingFetch = wrapFetchWithPayment(fetch, client);

const res = await payingFetch("https://secondopinionx402.com/v1/verify", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({
    claim: "Library X v3 supports streaming responses natively",
    context: "About to migrate our retry logic to rely on this",
  }),
});
const verdict = await res.json();
if (verdict.verdict === "refuted") { /* stop and re-plan */ }

Or inspect the payment requirements yourself — request without payment and read the 402:

curl -s -X POST https://secondopinionx402.com/v1/verify \
  -H 'content-type: application/json' \
  -d '{"claim":"HTTP 402 was reserved in 1997 and first standardised for real use by x402"}'
# → HTTP 402 + JSON: accepts[], network, asset, payTo, amount — pay, then retry with X-PAYMENT header

Add it to your AI app (hosted MCP — zero install)

Add one URL to Claude, Cursor, or any MCP-capable agent stack and five tools appear — pricing quotes and job results free, verdicts pay-per-call from the caller's own wallet. Keys never touch this server: payments are built by your wallet and passed through.

https://secondopinionx402.com/mcp

Open /mcp in a browser for the human walkthrough. Prefer local signing? npx secondopinion-x402 mcp runs the connector on your machine — the free-trial tool needs no wallet at all, and paid tiers switch on with one env var.

Example verdict

{
  "id": "so_9f2c…",
  "mode": "single",
  "verdict": "refuted",
  "confidence": 0.93,
  "summary": "The claim conflates two products. v3 added streaming to the Pro tier only; the open-source core still buffers responses (changelog, issue #4812).",
  "findings": [
    { "point": "v3.0 changelog scopes streaming to Pro", "direction": "against_claim", "source_url": "https://…/changelog" }
  ],
  "citations": ["https://…/changelog", "https://…/issues/4812"],
  "engine": { "model": "claude-sonnet-5", "searched_web": true },
  "checked_at": "2026-07-21T12:00:00Z"
}

Honesty properties

No manufactured doubt. The skeptic is scored on calibration, not on finding problems. "Supported" after a real refutation attempt is the product working, not the product failing.

Citations are real. Only URLs actually consulted are returned. If web search was unavailable, searched_web:false is set and confidence drops.

Verification, not truth. Treat verdicts as strong evidence and check citations on anything load-bearing. The response says this too, every time.

Measured, not claimed. Accuracy is benchmarked on a versioned 62-claim exam and published — including the failures: /benchmark.

Every verdict is an audit receipt. Responses carry an Ed25519 signature you can verify offline against our published key — or in your browser. Tamper-evident, provable later, payment already on-chain.

Privacy by design

Your claim is never logged. Request logs record route, status, timing, IP and the claim's length — the text itself is never written anywhere.

Verdicts aren't stored. Async results live in memory for one hour so you can poll them, then they're gone — there is no database to breach.

Processing is disclosed. Claims are sent to the engine provider (Anthropic; OpenAI on the free beta seat) to produce the verdict, under their API terms.

Payments are public, claims are not. The blockchain permanently records wallet, amount and time — that's the nature of on-chain payment — but claim text never touches the chain.

No accounts means no identity. We couldn't connect a claim to a person if we tried: we don't know who you are.