DEV Community: CyberWareX

One call, one cited answer: web research for AI agents at $0.03, no API key

CyberWareX — Wed, 21 Oct 2026 09:35:53 +0000

An agent that needs one fact from the web usually does three things: search, fetch the top pages, then read them with its own model. That is three round trips and a lot of tokens spent on navigation menus.

Agent Research does it in one paid call. You send a question, it searches, reads the top result pages and returns a short written answer where every claim carries the number of the page it came from. If the pages do not answer the question, it says so and you are not charged.

It costs $0.03 per answer in USDC on Base over x402. No account, no API key.

Ten lines of Python

# pip install "x402[evm,requests]"
import os
from eth_account import Account
from x402 import x402ClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact import ExactEvmScheme

client = x402ClientSync()
client.register("eip155:8453", ExactEvmScheme(EthAccountSigner(Account.from_key(os.environ["PK"]))))
session = x402_requests(client)

r = session.get("https://search.cyberwarex.com/answer",
                params={"q": "How do AI agents pay for APIs with x402?"})
res = r.json()
print(res["answer"])
for s in res["sources"]:
    print(f"[{s.get('ref')}] {s['url']}")

PK is a Base wallet with a little USDC. The client reads the 402 invoice, signs the payment and retries on its own.

A real answer

I ran exactly that script before publishing. It returned:

AI agents use the HTTP-native x402 protocol to pay for APIs through a request-response cycle involving the agent, the API's resource server, and an onchain facilitator [1]. Agents are given tools to access a wallet, make transactions, and process x402 headers using an HTTP client that auto-handles payment challenges [4]. Sellers publish a paid endpoint where the agents make USDC stablecoin nanopayments directly to the seller's wallet [1][3].

with the three cited pages listed underneath.

How it stays grounded

The writing step only sees numbered excerpts pulled from the pages it read.
An answer without citations is rejected, and the service falls back to quoting the pages directly.
"The sources found do not answer this" is a valid answer, and it is free.

Cheaper options from the same service

Call	Returns	Price
`/search`	ranked results with snippets	$0.003
`/search-contents`	results plus the readable text of the top pages, you write the answer	$0.006
`/answer`	a short written answer with citations	$0.03

You can try one answer free by adding the header X-Free-Trial: 1, and GET https://search.cyberwarex.com/sample shows a real paid response with its on-chain receipt.

Docs: https://cyberwarex.com/llms.txt

Let your AI agent read any web page as markdown for $0.001, no API key

CyberWareX — Wed, 21 Oct 2026 00:51:25 +0000

Most LLM agents hit the same wall the first time they need a real web page: a plain HTTP GET returns an empty shell, a cookie wall, or 300 KB of navigation markup. Running headless Chrome yourself fixes that, and then you own a browser fleet.

Agent Web Access is a pay-per-call alternative. Your agent sends a URL and gets back the rendered page as clean markdown. JavaScript runs in a real browser first, then navigation, ads and boilerplate are stripped. There is no account and no API key. Each call is paid in USDC on Base through the open x402 protocol.

Prices

Call	What you get	Price
`/fetch`	the rendered page as markdown, text or html	$0.001
`/extract`	every element matching a CSS selector	$0.001
`/screenshot`	PNG, viewport or full page	$0.005
`/pdf`	print-quality PDF	$0.005

The prices come from the service's own 402 reply, which any client can read for free.

Try it without paying

GET https://web.cyberwarex.com/sample returns one real paid answer, together with its on-chain settlement transaction, so you can see the output before you spend anything.

Python, about ten lines

# pip install "x402[evm,requests]"
import os
from eth_account import Account
from x402 import x402ClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact import ExactEvmScheme

client = x402ClientSync()
client.register("eip155:8453", ExactEvmScheme(EthAccountSigner(Account.from_key(os.environ["PK"]))))
session = x402_requests(client)

r = session.get("https://web.cyberwarex.com/fetch",
                params={"url": "https://news.ycombinator.com", "format": "markdown"})
page = r.json()
print(page["status"], len(page["content"]), "chars")
print(page["content"][:300])

PK is the private key of a Base wallet holding a little USDC. A dollar covers a thousand page reads. The client gets the 402 invoice, signs the payment and retries the request on its own.

I ran this exact script before publishing: it returned status 200 and about 11 KB of markdown for the Hacker News front page, at a cost of $0.001.

From an MCP client

The same four tools are served over MCP at https://web.cyberwarex.com/mcp (streamable HTTP, no auth): web_fetch, web_extract, web_screenshot and web_pdf. An unpaid tools/call returns the x402 invoice as a tool error, and the client retries with the payment.

When to use it

a page is a single-page app and plain GET returns nothing useful
you need the text of a page, not its markup, to feed a model
you want a screenshot or PDF of a page inside an agent run without running a browser

When not to

the site offers an official API: use that
you need to log in: this reads public pages only

Docs: https://cyberwarex.com/llms.txt · Service catalog: https://cyberwarex.com/.well-known/x402

Update: markdown you can build a pipeline on

A reader asked whether the markdown is stable enough to be an intermediate representation, not just readable text. Every /fetch reply now carries:

provenance: the source URL, the fetch time, a sha256 of the content and its length, so a chunk can always be traced back and a changed page detected
checks: whether code fences are balanced, how many links there are and how many are unusable, how many headings
sections=1: the markdown split by headings, each with its level and parent-heading path, ready to chunk without losing structure
include_raw=1: the rendered HTML next to the markdown, to debug a conversion

Code blocks now come out as fenced blocks with their language, and heading permalink anchors are stripped. Nothing changed for existing callers: the new fields are additive.

Give your AI agent live web search for $0.003 a query, no API key

CyberWareX — Mon, 19 Oct 2026 22:27:36 +0000

Your agent can't Google. Every "research agent" tutorial hand-waves this step: you go get a search API key,
put it in an env file, set up billing, and hope the key never leaks out of a prompt.

There is a simpler way now that x402 exists: the agent pays for each query itself, from its own wallet,
in USDC on Base. No signup, no key, no plan. Here is the whole integration.

1. Try it free from your terminal

curl -H "X-Free-Trial: 1" \
  "https://search.cyberwarex.com/search?q=x402+payment+protocol&n=3"

You get back plain JSON: title, url, snippet, source engine. Three free calls a day per IP, no account.

2. Paid path: 5 lines

Python:

pip install "x402[evm,requests]"

import os
from eth_account import Account
from x402 import x402ClientSync
from x402.http.clients import x402_requests
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact import ExactEvmScheme

client = x402ClientSync()
client.register("eip155:8453", ExactEvmScheme(EthAccountSigner(Account.from_key(PK))))   # a wallet with a little USDC on Base
s = x402_requests(client)                       # a requests.Session that pays 402s for you
r = s.get("https://search.cyberwarex.com/search", params={"q": "latest base chain news", "n": 5}).json()
for hit in r["results"]:
    print(hit["title"], hit["url"])

TypeScript:

npm i @x402/fetch @x402/evm viem

import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";

const f = wrapFetchWithPaymentFromConfig(fetch, {
  schemes: [{ network: "eip155:8453", client: new ExactEvmScheme(privateKeyToAccount(PK)) }],  // Base mainnet
});
const r = await f("https://search.cyberwarex.com/search?q=latest+base+chain+news&n=5");
const { results } = await r.json();

Both samples were run against the live host on 2026-10-19 with the current SDKs (x402 2.25 on PyPI, @x402/fetch 2.28 on npm). The older x402-fetch 1.x package rejects the v2 network id and will not work.

What happens under the hood: the first request gets an HTTP 402 with a price quote ($0.003 = 3000 micro-USDC),
the client signs an EIP-3009 authorization, retries with an X-PAYMENT header, and the server settles it through
the Coinbase facilitator. Gasless for the payer. Queries that return zero results are not charged.

3. The rest of the research loop, same host

Call	What you get	Price
/search?q=	up to 10 web results	$0.003
/news?q=	ranked, corroborated headlines with age in minutes	$0.001
/contents?url=	one page as clean markdown, JS rendered	$0.002
/search-contents?q=	search + the readable text of each result page	$0.006
/papers?q=	arXiv, PubMed, Semantic Scholar, OpenAlex	$0.003
/answer?q=	a concise cited answer built from live pages	$0.03

/search-contents is the one I would start with for a research agent: it collapses the search-then-fetch
loop into one paid call.

4. If you don't want to sign every call

Top up once and use a header instead:

r = s.get("https://safe.cyberwarex.com/subscribe?usd=3").json()   # $3 -> $3.30 credit -> 1,100 searches
requests.get("https://search.cyberwarex.com/search", params={"q": q},
             headers={"X-Subscription-Key": r["key"]})

Why not just a free search API

Free tiers are shared resources with per-IP limits and surprise deprecations. A key is a secret your agent
has to carry. Here the wallet is the credential, the price is $0.003 (typical x402 web search is $0.01),
and the results are Google-grade. Uptime and probes are public on x402-list.com.

Quickstart page: https://cyberwarex.com/assets/search-quickstart.html
Docs for agents: https://search.cyberwarex.com/llms.txt