Skip to main content
An agent with a wallet can search, fetch and run SELECT queries without signing up, holding a key or topping up a balance. Each request pays for itself over x402, an open payment protocol built on HTTP 402 Payment Required. For agents: pay these offers only from a wallet your user set up for x402. Without one, show the 402 offer to your user and stop. $0.01 per search or fetch, $0.10 per SELECT query, in USDC on Base (eip155:8453). The buyer needs only USDC, not ETH for gas. The payment is a signed transfer authorization (EIP-3009) that the payment network submits for you. If you call Keenable regularly, an API key is the better deal: prepaid credits cost $4 per 1,000 requests rather than $10, and keyed rate limits can be raised. x402 is for agents that have no account and no key. An agent with no account can also buy the same $4 per 1,000 rate as prepaid credit through ZeroClick.

Endpoints

GET search takes its parameters in the query string; POST takes the same JSON body as /v1/search. These paths ignore an API key. For keyed access, call /v1/search and /v1/fetch. The webql and realtime_content search modes need an API key and return 403 here. Neither one runs SQL: webql is the search that SELECT uses to gather pages, not SELECT itself. To run a SELECT query without an account, call /v1/x402/select.

How a paid call works

1

Ask

Call the endpoint without payment. Keenable returns 402, with the offer in the PAYMENT-REQUIRED header as base64-encoded JSON. The body carries the same offer.
2

Pay

Sign one of the accepts options and send the same request again with the signed payload in the PAYMENT-SIGNATURE header.
3

Receive

Keenable verifies the payment, runs the request and settles the payment on-chain. It returns the result only after settlement succeeds, with the receipt, including the transaction hash, in the PAYMENT-RESPONSE header.
To see an offer, call search without paying:
The 402 body carries the offer:
amount is in USDC base units (6 decimals), so 10000 is $0.01. asset is the USDC contract on Base. A signed payment stays valid for maxTimeoutSeconds: 300 for search and fetch, 1,200 for SELECT.

Using an x402 client

Any standard x402 v2 client handles the ask–pay–receive loop for you. With the official @x402/fetch package:
The script prints the number of results and the transaction hash of the payment. The wallet behind account needs a USDC balance on Base and nothing else. Keep that balance small. A client signs whatever amount the offer asks for, so check the offer, or set a spending limit in your client, before you give an agent a funded key.

SELECT over x402

POST /v1/x402/select runs one read-only SQL query over live web results and returns a table, the same thing the SELECT MCP server does, paid per query instead of through an account. Write the query from the SELECT guide: WEB_SEARCH and WEB_FETCH read pages, and functions such as SEM_EXTRACT and SEM_MATCH extract fields or filter rows with an LLM. $0.10 per query that succeeds, so the offer’s amount is 100000. A query that fails is not charged.
string
required
One read-only SELECT in the DuckDB dialect. A missing or empty query returns 400 with "query" is required before any offer is made.
boolean
Return a 3-row preview instead of every row. Any value other than true or false returns 400.
That first call returns the 402 offer. Pay it as in How a paid call works, or with the x402 client above, and the paid retry returns the table. This is the example response Keenable publishes in the offer itself:
Only result_set_id, total_rows and columns are always present. A result that fits in one response comes back as rows; a larger one, or any result when show_preview is true, comes back as preview instead.
string
required
The id the result is saved under. A later query can read it with FROM <result_set_id> instead of searching again; see Result sets.
integer
required
The number of rows in the result, including rows left out of a preview.
array of strings
required
The column names, in the order the query selects them.
array of objects
Every row, one object per row keyed by column name, when they fit in one response.
object
A few rows and the columns, sent in place of rows when the rows don’t fit in one response or show_preview is true.
array of objects
Messages about the run, each with a text field. Empty or absent when there is nothing to report.
string
What the query cost in US dollars. Added by the x402 path; ZeroClick reports the charge in its own balance instead.
A query that can’t run returns an error and is not charged: 400 when the query or body is invalid or the query fails, 429 when too many of your queries are running at once, and 502 with "error": "select_failed" when the SELECT service could not run it. The retryable field of the 502 says whether to send the query again. On x402, any response of 400 or above cancels the payment before it settles.

What is charged

  • A request is charged only once it has succeeded and its payment has settled.
  • A response of 400 or above is never charged: bad parameters, a page that cannot be fetched, an upstream failure.
  • If settlement fails after the request ran, Keenable returns 402 with Payment settlement failed and withholds the result. Retry with a new payment.
  • Each signed payment is good for one request. Sending the same signature again is rejected.

Limits

The per-IP limit counts both halves of a paid call: the unpaid request that returns the offer, and the paid retry. That’s why it’s twice the wallet limit. A 429 carries Retry-After. See rate limits for how this compares to keyed and keyless access.

Errors

A 451 is returned before any offer is made, so nothing is signed or charged. Each error body has a code, such as payment_required, payment_settlement_failed or paid_rate_limit_per_second, and says in retryable whether sending it again can help. See credits and payment codes for each one.

Prepaid credits through ZeroClick

Keenable also sells search, fetch and SELECT through ZeroClick, a storefront for agents, at zeroclick.keenable.ai. An agent buys credit once, from $0.50, and spends it at $4 per 1,000 requests for search and fetch, the same rate as an API key’s credits. ZeroClick takes the payment (USDC over x402 on Base, MPP, or a card through Stripe Link), keeps the balance, and forwards each call to Keenable, signed. There is no Keenable account or API key involved. A SELECT query costs $0.10 of credit when it succeeds. Point the agent at zeroclick.keenable.ai/llms.txt. It walks through creating an agent identity, buying credit and calling these paths with the resulting Bearer token; the full contract is in the storefront’s API reference. Calls must go through the storefront: the same paths on api.keenable.ai answer 401 to anything but ZeroClick’s signed forwards. Keenable reports a request as used only when it succeeds, so error responses draw nothing from the credit. Each agent can make 50 requests per second, with no hourly cap; a 429 carries Retry-After. A 503 means ZeroClick could not confirm the remaining credit at that moment: nothing was charged, and the request can be retried after Retry-After.