One request, in under a minute
Send your key in the x-api-key header. Every response is a small, stable envelope: metadata plus the engine's full report under result.
Request
# Scan a wallet for risky token approvals across 5 EVM chains
curl -s "https://veriql.app/api/v1/scan?address=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045" \
-H "x-api-key: vq_live_your_key_here"
Response
{
"version": "1",
"endpoint": "scan",
"requestId": "req_2b1e0c…",
"result": {
"address": "0xd8da…6045",
"score": { "score": 49, "grade": "D", "label": "At risk",
"drivers": [{ "label": "1 dangerous approval", "points": -51 }] },
"dangerCount": 1, "warnCount": 0,
"findings": [{ "chainId": 1, "chainName": "Ethereum",
"approval": { "tokenSymbol": "USDC", "spender": "0x…",
"risk": "danger", "isUnlimited": true,
"riskReasons": ["spender on GoPlus blacklist"] } }],
"totalExposureUsd": 1240.55
},
"disclaimer": "Read-only, best-effort risk signal. Detects known patterns; may miss novel attacks. Not financial advice."
}
API keys
Pass your key as the x-api-key request header (or a ?key= query param for quick tests). Keys look like vq_live_…. Grab one from the pricing section below.
1 credit per call
Each successful (2xx) response spends one credit. Malformed requests and errors are always free.
Live balance headers
Every response carries X-Credits-Remaining and X-RateLimit-Remaining, so you always know where you stand.
Instant, no signup
Grab a free key in one click, or buy a credit pack in USDT/USDC and your key is provisioned automatically.
Endpoints
Ten paid endpoints under /api/v1 (nine GET, one POST), plus a free denylist and a free balance check. Each returns the uniform envelope with the engine's full, auditable report under result. Agents paying someone should start with payee, send and signature. Trading bots watching new tokens want launches and deployer.
/api/v1/scanWallet approval-risk scan across 5 EVM chains (Ethereum, BNB Chain, Polygon, Arbitrum, Base). Returns a 0-100 Security Score with itemised drivers, every risky approval, and a best-effort USD value-at-risk.
| Parameter | Required | Description |
|---|---|---|
| address | yes | The public EVM address to scan (0x…). |
/api/v1/tokenToken / contract security check (honeypot, taxes, mintable supply, hidden owner, proxy, and more) with each finding surfaced as a plain-English flag. EVM chains and Tron.
| Parameter | Required | Description |
|---|---|---|
| address | yes | The token contract address. |
| chainId | no | Chain id or key (e.g. 1, base, tron). Defaults to Ethereum. |
/api/v1/launchA rigorous, transparent 0-100 launch-safety score built from contract, holder, liquidity and trading signals. Returns the score, a band, the full metrics, and every penalty as an itemised driver, so you can show your users exactly why. EVM chains, Tron and Solana.
| Parameter | Required | Description |
|---|---|---|
| address | yes | The token contract / mint address. |
| chainId | no | Chain id or key (e.g. 1, base, solana). Defaults to Ethereum. |
/api/v1/payeeBefore you pay an address. One call answers whether the recipient is on the US Treasury OFAC SDN list, on Drain Watch (known drainer, phishing and scam addresses), and, for EVM and Tron, whether Tether or Circle has frozen it, read from the issuer's own contract. A frozen address is do_not_pay too: stablecoins sent there can never be moved out. no_known_risk is only returned when every check that applies answered; otherwise the verdict is incomplete and the check that did not answer is named. Built for agents that pay addresses they found minutes ago.
| Parameter | Required | Description |
|---|---|---|
| address | yes | The recipient: an EVM, Bitcoin, Solana or Tron address. |
Request
# Check a recipient before paying it
curl -s "https://veriql.app/api/v1/payee?address=0x0330070fd38ec3bb94f58fa55d40368271e9e54a" \
-H "x-api-key: vq_live_your_key_here"
Response
{
"endpoint": "payee",
"result": {
"verdict": "do_not_pay",
"reasons": ["Address is OFAC-sanctioned. Paying it is a sanctions violation for a US person or business."],
"checks": [
{ "check": "ofac_sanctions", "state": "flagged" },
{ "check": "drain_watch", "state": "clear" },
{ "check": "stablecoin_freeze", "state": "clear" },
{ "check": "frozen_counterparty", "state": "clear" }
],
"warnings": []
}
}
One hop back. For Ethereum and Tron addresses, frozen_counterparty says whether the address ever received USDT directly from an address Tether froze. A match is a warnings entry naming the sender and the transaction, never a do_not_pay: it describes where money came from, not what the recipient did. A sender Tether later unfroze is stated, not warned about. While frozen senders remain unread the state is unknown and the verdict incomplete. An address an explorer labels as an exchange, router, bridge or pool gets not_applicable and a service field, because strangers send to those all day. A label says what the address is, not whether to trust it, and it does not clear a sanction, a listing or a freeze. No other free or paid check we know of answers this.
/api/v1/sendBefore you send USDT. One call answers both questions an agent has before a USDT transfer on Tron or Ethereum. Will it go through: a frozen sender, a Tron account that was never activated, too little USDT, too little TRX or ETH for the fee, or a contract that refuses the transfer, all read off the chain, with the exact fee. Should it go there: the recipient checked against OFAC, Drain Watch and Tether's freeze list. Tether checks the sender, not the recipient, so USDT sent to a frozen address confirms on chain and can never leave it. No transaction simulation shows that; this call does.
The answer is one of do_not_send (the recipient is sanctioned, listed or frozen), will_fail, may_fail, goes_through or incomplete. A recipient finding wins over everything else. goes_through is only returned when every check on both ends answered, and it is not a guarantee about the recipient. will_fail and do_not_send stand even when another check could not run.
| Parameter | Required | Description |
|---|---|---|
| from | yes | The sending address: Tron (T…) or Ethereum (0x…). |
| to | yes | The recipient, on the same chain. |
| amount | no | USDT to send, like 250 or 12.5 (up to 6 decimals). Leave it out to check the whole balance. |
Request
# Check a USDT transfer before sending it
curl -s "https://veriql.app/api/v1/send?from=TJCo98saj6WND61g1uuKwJ9GMWMT9WkJFo&to=TACcFecYGH2sfsSJcjoYcXCdZFebv2ZKyi&amount=250" \
-H "x-api-key: vq_live_your_key_here"
Response (abridged, recipient frozen)
{
"endpoint": "send",
"result": {
"chain": "tron",
"decision": "do_not_send",
"partial": false,
"reasons": ["Frozen by Tether: USDT sent here can never be moved out again."],
"sender": { "verdict": "goes_through", "feeAsset": "TRX" },
"recipient": { "verdict": "do_not_pay" },
"ranChecks": ["sender_chain_read", "ofac_sanctions", "drain_watch", "stablecoin_freeze"],
"warning": "Only Tether or Circle can unfreeze USDT or USDC. Anyone charging to do it is a scammer."
}
}
The free version for people is the USDT freeze checker: put in a recipient and an amount and it reads the sender side and whether Tether froze the recipient. The sanctions and Drain Watch checks on the recipient are in this paid call.
/api/v1/signatureBefore you sign. Send the signing request your agent was handed: raw calldata, an eth_sendTransaction or eth_signTypedData_v4 request, or the typed-data object. We decode it (approve, increaseAllowance, setApprovalForAll, Permit, Permit2, EIP-7702 delegation, transfer, revoke), check whoever gains the power against OFAC and Drain Watch, and answer block, warn or allow. A payload we cannot decode is block, because an agent must not sign what nobody could read, and that call is not charged.
| Body field | Required | Description |
|---|---|---|
| payload | yes | Hex calldata, a typed-data object, or a JSON-RPC signing request (object or string). |
Request
# An unlimited approval, as calldata
curl -s -X POST "https://veriql.app/api/v1/signature" \
-H "x-api-key: vq_live_your_key_here" -H "content-type: application/json" \
-d '{"payload":"0x095ea7b3000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"}'
Response
{
"endpoint": "signature",
"result": {
"decision": "warn",
"headline": "Read this before you sign",
"action": { "kind": "approve", "isUnlimited": true },
"counterparty": { "role": "spender", "sanctioned": false, "drainWatch": false },
"ranChecks": ["decode", "counterparty_lists"]
}
}
/api/v1/blocklistDrain Watch lookup: is this a known drainer/scam address? Answered entirely from Veriql's own in-memory blocklist (no upstream call), so it's fast and cheap. A hit returns its category, a computed confidence, and every contributing source; a miss means no known listing found: not "safe". Covers EVM, Bitcoin, Solana and Tron.
| Parameter | Required | Description |
|---|---|---|
| address | yes | The address to check, in the format native to chain. |
| chain | no | One of evm, btc, solana, tron. Defaults to evm. |
Request
# Look up an address against the Drain Watch blocklist
curl -s "https://veriql.app/api/v1/blocklist?address=0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045&chain=evm" \
-H "x-api-key: vq_live_your_key_here"
Response
{
"version": "1",
"endpoint": "blocklist",
"requestId": "req_9f3a1d…",
"result": {
"listed": false,
"category": null,
"confidence": null,
"first_seen": null,
"sources": []
},
"disclaimer": "Read-only, best-effort risk signal. Detects known patterns; may miss novel attacks. Not financial advice."
}
Metered like the other endpoints: 1 credit per successful call, with a generous free allowance. The same list also ships free, unauthenticated, as a public feed and an open JSON export.
/api/denylistFree, no key, for an agent wallet’s policy engine. A managed agent wallet checks a policy on every signing request, and a DENY rule there reads a list of addresses. This is that list: OFAC SDN plus Drain Watch, refreshed daily, with items already in the [{"value": "<address>"}] shape a condition set loads. Load it in chunks of 100.
The Solana detail. A Solana token transfer rule matches the destination token account, not the owner’s wallet, so a list of wallet addresses never matches a USDC payment to a listed wallet. The Solana feed therefore also lists every token account each listed address owns, read from the chain. A token account created in the same transaction as the payment cannot be on any list; check the recipient per payment with /api/v1/payee for that case.
| Parameter | Required | Description |
|---|---|---|
| family | yes | One of evm, solana, tron, btc. EVM addresses are lowercased and deduplicated. |
Request
curl -s "https://veriql.app/api/denylist?family=solana"
Response
{
"family": "solana",
"asOf": "2026-10-26T04:11:00.000Z",
"count": 113,
"items": [{ "value": "…" }],
"entries": [{ "value": "…", "kind": "token_account", "owner": "…", "category": "sanctioned", "sources": ["ofac-sdn"] }],
"tokenAccountsComplete": true,
"limits": ["…"]
}
Sync it on a schedule and replace your set from items. The feed never answers with an empty list: a 503 means keep your previous copy and retry, so a bad minute on our side cannot wipe your rule. tokenAccountsComplete: false means some Solana token accounts could not be read this time; the owners are still listed.
/api/v1/outcomesThe track record, as data. Every token we judged that later had a measured liquidity collapse, and every token we watched for at least a day without measuring one. Each row carries the verdict we published before the label, with its timestamp, its sha256 digest and a public record you can recompute it from, so nothing here was labelled with hindsight. Built for backtesting a token filter or training a classifier.
Our misses ship exactly like our hits. A collapse names a cause only where the pool’s reserves were measured: withdrawn (both sides left: someone pulled liquidity) or sold_off (holders sold into the pool). Otherwise it is unclassified. A partial check that found nothing carries no score, as everywhere else on Veriql.
| Parameter | Required | Description |
|---|---|---|
| label | no | all (default), collapsed or no_collapse_observed. |
| limit | no | Rows per page, 1 to 100. Default 100. |
| cursor | no | The nextCursor from the previous page. Rows are ordered oldest first by a key that never moves, so paging neither skips nor repeats. |
Request
curl -s "https://veriql.app/api/v1/outcomes?label=collapsed&limit=100" \ -H "x-api-key: vq_live_your_key_here"
Response (one real row: a token we called safe, then measured someone withdrawing its pool)
{
"endpoint": "outcomes",
"result": {
"items": [{
"label": "collapsed",
"chain": "solana", "symbol": "tylee",
"verdict": { "record": "https://veriql.app/v/Mzn6mgzLP4M", "score": 82, "band": "safe" },
"outcome": { "cause": "withdrawn", "liquidityBeforeUsd": 1084.13, "liquidityAfterUsd": 0.21, "hoursAfterVerdict": 50.9 }
}],
"nextCursor": "…"
}
}
One credit (or one x402 payment) per page of up to 100 rows. An empty page is not charged.
/api/v1/launchesNew Solana tokens, already checked. Our engine finds new and trending Solana tokens on its own every few minutes, scores each one and keeps re-reading its pool. This feed hands you what it recorded, newest first: when we first saw the token, our latest verdict, the share of supply in the ten largest accounts, the LP lock, and the pool’s liquidity at our first reading against our latest one. If the pool later collapsed, the row says by how much, and why where the reserves were measured.
These are measurements, not a forecast. The score describes the token’s structure read off the chain, not where its price goes. Both liquidity figures come from the same source, because one provider’s “before” against another’s “after” can show a collapse that never happened. A partial check that found nothing carries no score. No provider is called: it is one read of our own ledger, so it answers fast.
| Parameter | Required | Description |
|---|---|---|
| since | no | Only tokens first seen at or after this time, ISO 8601 or unix seconds. Default 24 hours ago, at most 7 days back (result.window says what was served). To poll, pass the newest firstSeenAt you already hold. |
| limit | no | Rows per page, 1 to 100. Default 50. |
| cursor | no | The nextCursor from the previous page, with the same since, for older rows. |
Request
curl -s "https://veriql.app/api/v1/launches?limit=50" -H "x-api-key: vq_live_your_key_here"
Response (one real row from 15 November)
{
"endpoint": "launches",
"result": {
"items": [{
"chain": "solana", "symbol": "GTA6CRAB",
"firstSeenAt": "2026-11-15T21:30:20.654824Z",
"verdict": { "score": 64, "band": "caution", "metrics": { "top10Percent": 82.48, "lpLockedPercent": 100 } },
"liquidity": { "source": "engine", "readings": 3, "firstUsd": 12725.13, "latestUsd": 12725.13, "changePercent": 0 },
"outcome": null
}],
"nextCursor": "…"
}
}
One credit (or one x402 payment) per page of up to 100 rows. An empty page is not charged, so polling for new tokens costs nothing until there is something new.
/api/v1/deployerWho created this token, and what happened to their other launches? Pass a Solana pump.fun mint or a creator wallet. The creator is read off the token’s bonding curve on chain, not bought from a vendor: it is the address pump.fun names when the token is created and pays the creator fees to, which is not necessarily the wallet that paid for the launch. You get every other token of that creator we recorded a verdict on, newest first, each with our verdict and, where its pool later collapsed, by how much and why.
Our ledger starts on 30 September 2026 and covers the launches our engine found, so the history is a floor. A creator with nothing else on record is unknown, not clean: a fresh wallet per launch is the cheapest trick there is. A past collapse is a measurement of a past token, not a forecast of this one. Every row of launches already carries the counts, so a bot polling the feed only calls this for the full list.
| Parameter | Required | Description |
|---|---|---|
| address | yes | A Solana token mint or a creator wallet, base58. |
| limit | no | Tokens to list, 1 to 100. Default 25. The counts always cover every token. |
Request
curl -s "https://veriql.app/api/v1/deployer?address=CYGdfVpm8My54T1A3bD44fRmLdZtFaEYyj1czkx9pump&limit=1" -H "x-api-key: vq_live_your_key_here"
Response (a real answer, 16 November 2026)
{
"version": "1",
"endpoint": "deployer",
"result": {
"queryKind": "token",
"status": "found",
"deployer": "5ZuV8eqkvzYFVEKbLvGBdexL2tFv7E5BCd2HZpjqbdg",
"launches": 27,
"otherLaunches": 26,
"firstSeenAt": "2026-10-06T05:35:40Z",
"outcomes": { "withdrawn": 1, "soldOff": 0, "unclassified": 0 },
"tokens": [{
"address": "4JhX8T75P9z4gk91SBnQeAb7h7qCe7iWAiVgucVypump",
"symbol": "Dollar",
"score": 41,
"band": "caution",
"outcome": null
}],
"summary": "This creator has 27 tokens in our ledger since 2026-10-06. After our verdicts, liquidity was withdrawn from 1. A record of past tokens, not a forecast of the next one."
}
}
One credit (or one x402 payment) only when a creator is identified. Not a pump.fun token, a curve that names nobody, a chain that did not answer, or nothing on record: not charged.
/api/v1/keys/rotateThink your key leaked? Rotate it yourself, immediately. You get a new key, your remaining credits move across, and the old key stops working the moment the new one exists. Present the current, working key in the POST body, never in the URL: a key in a query string ends up in your shell history and in every proxy log on the way, which is the exposure this endpoint exists to help you escape.
There is deliberately no “email me my key” recovery. Veriql keys are account-less on purpose, with no signup and no password, which is what lets an agent become a customer in one call. There is no identity to authenticate a recovery against, and adding one would mean collecting an email a security product has no business holding. A key you have lost entirely cannot be recovered, so store it when it is shown.
Request
# The key goes in the body, never in the URL
curl -s -X POST "https://veriql.app/api/v1/keys/rotate" -d "key=vq_live_your_current_key"
Response
{
"version": "1",
"endpoint": "key_rotated",
"result": {
"key": "vq_live_the_new_one",
"credits": 120,
"note": "Your previous key is revoked. Store this one now: it is shown once and cannot be recovered."
}
}
/api/v1/usageWhat is left on your key: the rate limit, the monthly quota where your tier has one, and the remaining prepaid credits. It costs nothing. It is not metered and not counted, because charging a credit to ask the balance would make the answer wrong the moment you read it. Before this existed the figure was only available in the response headers of a call that had already spent one.
Request
# Check what is left, without spending anything
curl -s "https://veriql.app/api/v1/usage" -H "x-api-key: vq_live_your_key_here"
Response
{
"version": "1",
"endpoint": "usage",
"requestId": "req_9f3a1d…",
"result": {
"scope": "starter",
"ratePerMin": 60,
"rateRemaining": 59,
"quota": null,
"quotaRemaining": null,
"creditsRemaining": 24180
}
}
A null means the field does not apply to your key: a prepaid-credit key has no monthly quota, and a quota key has no credit balance. Never cached, so the number is the number.
Machine-readable: the full contract is published as an OpenAPI 3.1 spec, and an llms.txt is provided for AI agents and coding assistants.
We show the math
Most risk APIs hand you an opaque number. Veriql returns the drivers behind every score, the exact deductions, flags and metrics, so you can display an auditable breakdown to your users and defend the verdict.
Scores with drivers
The wallet Security Score and the launch-safety score each ship an itemised drivers array: every penalty, labelled, with its point cost.
Honest by design
We never label an asset "safe". A clean result means no known risks were found, not a guarantee. Every response carries that disclaimer.
Read-only, non-custodial
Public on-chain data only. Nothing to connect, nothing to sign, no key to your users' funds ever touches the API.
Call Veriql from Claude & Cursor
Veriql ships a Model Context Protocol server, so an AI agent can run the risk checks itself: veriql_scan, veriql_token, veriql_launch, veriql_payee, veriql_send (the USDT pre-send check), veriql_signature and veriql_freeze. Add it with your key:
claude_desktop_config.json · .cursor/mcp.json
{
"mcpServers": {
"veriql": {
"command": "npx",
"args": ["-y", "veriql-mcp"],
"env": { "VERIQL_API_KEY": "vq_live_your_key" }
}
}
}
Every agent call runs through your metered credits. Start with a free key. Same read-only engine, same "shows-the-math" output. Published on npm as veriql-mcp, so npx fetches it for you; nothing to clone and nothing to build.
Pay per call, with no account at all
An agent cannot complete a checkout, read a claim page or keep a key it was never issued. So the metered endpoints also speak x402: call one with no key, get a 402 describing exactly what to pay, retry with the payment attached. USDC on Base or Solana. No signup, no invoice, no human. $0.01 per call.
The handshake
$ curl -i "https://veriql.app/api/v1/launch?address=0x…&chainId=1"
HTTP/1.1 402 Payment Required
payment-required: <the same terms, base64>
{ "x402Version": 2,
"accepts": [{ "scheme": "exact", "network": "eip155:8453",
"asset": "0x8335…2913", "amount": "10000", "payTo": "0x…" },
{ "scheme": "exact", "network": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
"asset": "EPjF…Dt1v", "amount": "10000", "payTo": "3DX4…" }] }
// Pay on either row: Base or Solana, USDC on both. 10000 is atomic USDC: six decimals, so $0.01 a call.
$ curl "https://veriql.app/api/v1/launch?address=0x…&chainId=1" -H "PAYMENT-SIGNATURE: <signed authorisation>"
// 200, plus a PAYMENT-RESPONSE receipt naming the settlement tx
A client that actually runs
$ npm i @x402/fetch @x402/evm viem // The curl handshake above shows the protocol. It is not runnable: // nobody can hand-craft the signed authorisation. This is. import { wrapFetchWithPayment, x402Client } from "@x402/fetch"; import { registerExactEvmScheme } from "@x402/evm/exact/client"; import { privateKeyToAccount } from "viem/accounts"; // Any account holding USDC on Base. A few cents is a few calls each. // Holding USDC on Solana instead? Register @x402/svm's exact scheme the same way. const account = privateKeyToAccount(process.env.PRIVATE_KEY); const client = new x402Client(); registerExactEvmScheme(client, { signer: account }); const pay = wrapFetchWithPayment(fetch, client); // One call. The 402, the signature and the retry all happen inside. const r = await pay("https://veriql.app/api/v1/launch?address=So11111111111111111111111111111111111111112&chainId=solana"); console.log(await r.json()); // -> { endpoint: "launch", result: { score: 96, band: "safe", … } }
You are charged only for an answer. A call where no check could run is served without taking payment, the same rule the credit path follows. If our payment facilitator is unreachable you get a 503 and nothing is taken: a 402 always means the payment itself was refused, never that we had an outage. Prepaid credits remain much cheaper per call if you can hold a key, and a free one takes a few seconds.
Prepaid credits, priced under the incumbents
1 credit = 1 successful call. Buy a pack in USDT/USDC, get your key instantly, top up anytime. Start free: no card, no signup.
Starter
- 20,000 credits
- top up anytime
- 60 requests / minute
Pro
- 100,000 credits
- top up anytime
- 120 requests / minute
Scale
- 500,000 credits
- top up anytime
- 300 requests / minute
How metering works: one credit per successful (2xx) response; failed requests are free; each key also has a per-minute rate limit. Every response carries X-Credits-Remaining and X-RateLimit-Remaining. Paid keys are provisioned automatically once the payment confirms on-chain, then shown on the claim page.
Status codes
Errors share the envelope shape: { "version": "1", "error": { "code", "message" } }.
| Status | Code | Meaning |
|---|---|---|
| 400 | invalid_request | Missing or malformed address, or an unsupported chain. |
| 401 | unauthorized | Missing, invalid, or revoked API key. |
| 402 | quota_exhausted | Out of credits (or monthly quota reached). Top up to keep calling. |
| 429 | rate_limited | Per-minute rate exceeded. Back off and retry. |
| 501 | not_enabled | The API is not enabled on this deployment. |
Questions
Where does the data come from?
Some is ours and some is resold, and the difference matters when you are buying it. Ours: Ethereum approvals replayed from Approval logs on our own RPC pool, the honeypot and tax simulator (one eth_call with state overrides), Solana liquidity read straight from pool accounts, the Market Integrity score computed from raw swap logs, and Drain Watch. Resold: GoPlus Security for token traits and for approvals on the other four chains, DexScreener and GeckoTerminal for prices and trading data, and the OFAC SDN list for sanctions. Veriql adds the transparent 0-100 scoring and the auditable driver breakdown on top of both.
Is a clean result a guarantee?
No. A clean result means none of the automated checks tripped, no known risks were found. Contracts can be upgraded and liquidity can be pulled. Treat it as a signal, not a promise.
How do I get a key?
Click "Get a free key" for an instant key with 250 credits, or buy a credit pack in USDT/USDC. Your key is provisioned automatically and shown on the next page. Top up anytime by pasting your key above.
What chains are covered?
The wallet scan covers 5 EVM chains. Token checks cover EVM chains and Tron. The launch-safety score adds Solana.