DEV Community: Toolstem Team

How an AI Agent Pays $0.01 for Live SEC Data — Without an API Key

Toolstem Team — Mon, 22 Jun 2026 18:21:51 +0000

How an AI Agent Pays $0.01 for Live SEC Data — Without an API Key

AI agents need real-world data to be useful. The problem: most data providers require API keys, monthly billing accounts, and rate-limit agreements negotiated by a human. That model breaks down when agents are autonomous — no human to sign up, no process to rotate keys, no budget owner to approve a subscription. There's a better pattern.

What x402 Is

x402 is an HTTP-native micropayment protocol built on Base mainnet. Instead of an API key in a header, a client sends a signed USDC authorization using EIP-3009 transferWithAuthorization. The server verifies the signature on-chain, releases the data, and the payment settles — all within a single HTTP round-trip.

The key detail: the agent's own wallet pays, not a developer's credit card. The agent holds a small USDC balance, signs a one-time authorization scoped to that exact call, and the data arrives. No API key. No subscription. No human involved.

This is what "pay-per-call" actually means at the protocol level.

The Toolstem SEC EDGAR MCP Server

Toolstem runs an MCP server at https://mcp.toolstem.com/mcp/sec that exposes five SEC EDGAR tools over x402. Pricing is tiered by data richness:

Tool	What it returns	Price per call
`get_company_filings_summary`	Filing counts, types, recency for a ticker	$0.005
`get_insider_signal`	Insider buy/sell activity with net direction	$0.05
`get_institutional_signal`	13F institutional ownership changes	$0.05
`get_material_events_digest`	8-K material event summaries, last 90 days	$0.50
`compare_disclosure_signals`	Side-by-side disclosure comparison across tickers	$0.50

The server speaks standard MCP protocol — any MCP-compatible client connects without modification. Payment is handled transparently by the client library; the agent sees a normal tool call.

The server is also listed in the Coinbase x402 Bazaar under payTo wallet 0xB009DA692cF3EFF7567bF727b8B2F3b5BFc3383E, which matters for autonomous discovery (more on that below).

Code Walkthrough

Install the package:

# TypeScript / Node
npm install langchain-toolstem

# Python
pip install langchain-toolstem

Here's a complete working agent in TypeScript that calls get_insider_signal for NVDA. The agent pays automatically — no API key anywhere in the code.

import { ChatOpenAI } from "@langchain/openai";
import { AgentExecutor, createOpenAIToolsAgent } from "langchain/agents";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { createSecTools } from "langchain-toolstem";

async function main() {
  // Your agent's wallet — holds a small USDC balance on Base mainnet
  const walletPrivateKey = process.env.AGENT_WALLET_PRIVATE_KEY!;

  // Initialize the SEC EDGAR tools
  // Payment is handled by the x402 client internally — no API key needed
  const tools = await createSecTools({
    privateKey: walletPrivateKey,
    mcpEndpoint: "https://mcp.toolstem.com/mcp/sec",
  });

  const llm = new ChatOpenAI({ model: "gpt-4o", temperature: 0 });

  const prompt = ChatPromptTemplate.fromMessages([
    ["system", "You are a financial research agent. Use the available tools to answer questions about SEC filings."],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
  ]);

  const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
  const executor = new AgentExecutor({ agent, tools });

  const result = await executor.invoke({
    input: "What is the insider trading signal for NVDA over the last 30 days?",
  });

  console.log(result.output);
  // Payment: ~$0.05 USDC deducted from agent wallet, settled on Base mainnet
}

main();

What happens under the hood when get_insider_signal is called:

langchain-toolstem constructs an HTTP request to the MCP server
The x402 client signs a transferWithAuthorization using EIP-3009 — a one-time USDC transfer authorization scoped to $0.05
The authorization is attached to the request header
The server verifies the signature, fetches the SEC data, and returns the result
The $0.05 settles on Base mainnet

The Python equivalent uses createsectools from the same package (v0.1.0 on PyPI). The pattern is identical — wallet key in, tools out, payment automatic.

How Agent Discovery Works

The x402 Bazaar is a registry where x402-compatible servers list their endpoints, pricing, and payTo addresses. An autonomous agent can query the Bazaar to discover available data providers without any human configuration — the same way a browser discovers a webpage.

For Toolstem specifically: an agent searching the Bazaar for SEC or financial disclosure tools will find the Toolstem entry, read the tool manifest, fund its wallet with a few dollars of USDC, and start making paid calls — end-to-end autonomous, no developer intervention.

This closes the loop. The agent's wallet is its identity and payment method. The Bazaar is its service registry. No API keys, no SaaS accounts, no human standing in the middle.

Where to Go Next

Try the tools interactively at the Toolstem playground before writing any code. The npm package (langchain-toolstem@0.1.4) is on npm; the Python package (langchain-toolstem@0.1.0) is on PyPI. Both connect to the same MCP endpoints at https://mcp.toolstem.com/mcp/finance and https://mcp.toolstem.com/mcp/sec.

I built an MCP server that charges AI agents per call using x402 micropayments

Toolstem Team — Tue, 16 Jun 2026 03:43:35 +0000

I built an MCP server that charges AI agents per call using x402 micropayments

By Toolstem

You built an MCP server. Agents call it. You pay the API costs. They pay nothing. Every tools/call invocation burns a few cents of your budget while the agent that triggered it has no idea — and no incentive to care. The standard answer is "wrap it in a SaaS subscription," but that requires a human in the loop to sign up, enter a card, and manage a billing relationship. Most agents don't have humans watching every call. What if the agent just paid for its own data, automatically, without a human anywhere in the loop?

That's what I built. Here's what I learned.

What x402 actually is

HTTP 402 — "Payment Required" — has existed since 1996. It was reserved for future use and then essentially forgotten for 28 years. The x402 protocol revives it as a machine-to-machine payment standard built on EIP-3009.

The flow looks like this:

Agent hits your endpoint with a normal request
Server returns HTTP 402 with a JSON body: payment amount, recipient address, network, token, nonce
Agent signs an EIP-3009 transferWithAuthorization — a pre-authorized USDC transfer that the server can submit on behalf of the agent
Agent retries the request with an X-Payment header containing the signed authorization
Server verifies the signature on-chain, submits the transfer, and responds with data
Settlement confirmed in under 2 seconds on Base mainnet; gas is roughly $0.001

No Stripe account. No OAuth flow. No human sign-up. No waiting for a monthly invoice. The agent pays exactly what it used, settled atomically, without ever needing ETH for gas (the server submits the transfer, so only the server needs a small ETH float for gas — the agent only needs USDC).

This is the "HTTP + payment" primitive that should have existed all along. It's pre-product-market-fit, but the underlying mechanic is sound.

The architecture

The core infrastructure is a Cloudflare Worker acting as a paywall proxy. It sits between the public internet and your upstream MCP server, intercepting every request before forwarding it.

Agent → Cloudflare Worker (x402 paywall) → Upstream MCP Server → Data sources

The Worker handles the payment lifecycle:

Receives request
Checks for a valid X-Payment header
If absent: returns 402 with payment details
If present: verifies the EIP-3009 signature, checks nonce freshness and amount, submits the on-chain transfer
Forwards to upstream MCP only on successful verification

One non-obvious constraint: initialize and tools/list must be free. Agents need to discover your tool surface before they can decide whether to pay. If you charge for discovery, you never get called at all. Any directory health-check probe (Glama, mcp.so, PulseMCP) also expects a free tools/list response — paywall those and you fall off the listings. The Cloudflare Worker routes those two MCP message types to an unmetered path.

Per-tool pricing is where the model gets interesting. Our SEC EDGAR server runs three tiers:

Tool	Tier	Per call
`getCompanyFilingsSummary`	Cheap	$0.005
`getInsiderSignal`	Standard	$0.05
`getInstitutionalSignal`	Standard	$0.05
`getMaterialEventsDigest`	Premium	$0.50
`compareDisclosureSignals`	Premium	$0.50

A filings summary is one EDGAR lookup. compareDisclosureSignals cross-references insider trades, 13F institutional moves, and 8-K clusters across multiple companies. The compute difference is roughly 100x — so the price difference is 100x. Flat pricing treats them identically, which means you're subsidizing every expensive call with revenue from cheap ones.

The Finance MCP server (our first server) launched at a flat $0.005 across all tools. Six weeks in, we had $0 revenue. That table above is the lesson.

Code: agent side

The LangChain integration wraps the payment layer into a custom fetch function. Everything else is standard agent code.

TypeScript / LangChain.js:

import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { createFinanceTools } from "langchain-toolstem/finance";
import { createX402Fetch } from "langchain-toolstem/x402";

// fetch that auto-signs USDC payments on HTTP 402
const fetchPay = await createX402Fetch({
  privateKey: process.env.X402_PRIVATE_KEY!,
  maxPaymentUsd: 0.05, // per-call safety cap
});

// discovers tools live via MCP tools/list (free)
const tools = await createFinanceTools({ fetch: fetchPay });

const agent = createReactAgent({ llm, tools });
// each tools/call costs $0.01 USDC, settled on Base mainnet

The createX402Fetch wrapper intercepts any 402 response, signs the EIP-3009 authorization using the agent's private key, and retries transparently. The maxPaymentUsd cap is a safety rail — the agent refuses to sign any authorization above that threshold, protecting against a misconfigured or malicious server quoting an unexpected price.

Tools are discovered live via tools/list on startup (free, not metered), so the agent always sees the current tool surface without anything hardcoded into the package.

Python / LangChain:

from langchain_toolstem import create_finance_tools, create_x402_httpx_client

client = create_x402_httpx_client("0xYOUR_PRIVATE_KEY")
tools = await create_finance_tools(client=client)
# same pattern — agent signs payments, settles on Base

For environments where you need a plain http:// URL rather than a custom fetch (e.g., MultiServerMCPClient), createX402Proxy spawns a local reverse proxy at localhost:4021 that handles payment signing, so you can point any standard MCP client at it directly.

The package is langchain-toolstem on npm (~1,400 installs/month) and langchain-toolstem on PyPI.

What we learned shipping this

Flat pricing was wrong. The Finance server ran flat $0.005 per call for six weeks. Zero meaningful revenue. The math is brutal: even if you hit the plateau of ~1,400 monthly active users typical for popular Apify actors, $0.005 flat yields ~$7/month. The ceiling is too low for a server with real API costs underneath it. Tiered pricing maps price to actual compute — it was the right call, and we should have done it from day one.

The free discovery layer is non-negotiable. Agents must be able to call tools/list without triggering a payment. This isn't just good UX — it's a technical requirement for every MCP directory that health-checks your listing. We had one bug early on where an unbilled discovery path was missing, and the server briefly vanished from Glama's listings because the probe got a 402 instead of a tools manifest.

The heartbeat problem is real. Coinbase's x402 Bazaar delists your endpoint if it goes 30 days without a confirmed paid call. For a server that's still building an audience, that's a serious risk — you could drop off the directory just as someone is about to discover you. We solved this with a GitHub Actions cron that runs every 6 hours, makes a real paid call from a funded heartbeat wallet, and posts the result to a log. Cost: roughly $0.06/day in USDC. Insurance against delisting: worth it.

The heartbeat revealed another bug: our initial implementation was calling tools/call without first completing the MCP initialize handshake. The server was rejecting the call silently. Fixing it required tracing the raw MCP message sequence. A reminder that the protocol has state — it's not a stateless REST API.

One external paying customer. $0.01. I want to be direct about this. The payment rail works end-to-end — 49 self-test transactions confirmed on Base mainnet, and one external payment from wallet 0x9CC4 on 2026-06-03 for $0.01. That's the full external revenue picture. The mechanism is proven; adoption is the open question.

We're self-audited on the security side (no third-party audit yet), and we've run independent AI reviewer passes on the codebase. The x402 verification logic, nonce handling, and private key isolation are the parts that matter most and got the most scrutiny.

Where this is going

x402 is a protocol looking for a distribution moment. The primitive is correct: HTTP-native, cryptographic, machine-to-machine, no humans required. What it lacks is the agent wallet layer becoming standard.

That moment is approaching. Coinbase AgentKit and CDP wallets are building the infrastructure for agents to hold and spend funds natively. When agent wallets are as common as agent LLM clients, x402 becomes the obvious way to monetize any agent-facing API — a single fetch wrapper is all the integration a developer needs.

Until then, the pattern is in early-adopter territory. The agents that can use it today are ones whose operators have explicitly provisioned a funded wallet and a private key in their environment. That's not zero — it's the population of developers actively building agentic systems who care about cost attribution.

The server is live at mcp.toolstem.com. Try it with a funded Base wallet. initialize and tools/list are always free — you can inspect the full tool surface before committing a cent.

The Finance and SEC EDGAR MCP servers are listed in Coinbase's x402 Bazaar. Source: github.com/toolstem/toolstem-mcp-server and github.com/toolstem/toolstem-sec-mcp-server. Walletless demo at toolstem.com/playground.

I built the MCP server Greg Isenberg recommends in his 2026 distribution playbook. Here's day 7.

Toolstem Team — Mon, 27 Apr 2026 23:32:52 +0000

Last week Greg Isenberg dropped an episode of The Startup Ideas Podcast about distribution in 2026. The thesis: AI commoditized code; the moat is now distribution. His Strategy #1 — out of seven — was "MCP servers as your sales team."

I'd started building one a week before the episode dropped. So instead of theorizing, here's the worked example: what a finished commercial-grade MCP server looks like, what shipping one costs, and what's actually happening on day 7.

What I built

Toolstem is a financial-data MCP server. It exposes three tools to AI agents:

get_stock_snapshot(ticker) — current quote, key ratios, recent performance
dcf_analysis(ticker, assumptions) — discounted cash flow with full assumption transparency
compare_stocks(tickers[]) — side-by-side valuation across N tickers

It's hosted as a paid actor on Apify Store at $0.005 per tool call. No subscription. No contracts. No human sales calls. An agent discovers it, calls it, gets billed per call. The agent's caller (a human or another agent) eventually pays the agent's pass-through.

The whole thing is faceless. There is no founder photo. There is no founder LinkedIn. The brand is a deep-blue mark and a stock typeface. This is the operating model: AI buys from AI.

Why MCP is the real distribution play

Here's the part Greg got exactly right and most takes don't.

A typical SaaS company spends a third or more of revenue on go-to-market — sales reps, content marketing, conferences, paid ads. That's the cost of fighting for human attention.

When the buyer is an AI agent, you don't fight for attention. The agent's framework points to a directory. The directory exposes a list of tools. The tool description and schema are the entire pitch. There is no awareness funnel, no SDR, no demo, no email sequence. It is among the most frictionless distribution surfaces ever built for software — if you can actually be in those directories with a clean spec.

Greg's framing in the episode: building an MCP server in 2026 is like building for mobile in 2010 — early movers own the directory real estate.

This is correct, with two caveats.

Caveat 1: Many MCP directories exist; the directory game is real. Smithery, Glama, mcp.so, PulseMCP, the official modelcontextprotocol/servers registry, awesome-mcp-servers, the Apify Store. Each has different submission requirements, different ranking signals, different audiences. Listing your server in 6 of them takes a week. This is a real cost.

Caveat 2: The "vibe coded in a weekend" ad copy is misleading. A demo MCP can be vibe-coded in a weekend. A commercial one — with PPE billing wired correctly, a smoke test that actually catches regressions against the live deploy, a release pipeline that doesn't ship broken builds, a default-demo for the empty-input probes that directory health-checks fire at you — takes longer. Not weeks. But not a weekend either.

Architecture in three sentences

The MCP server is a TypeScript actor running on Apify. Tools wrap Financial Modeling Prep's free API tier (250 calls/day cap, 512MB/30d bandwidth). Apify's Pay-Per-Event billing fires on every successful tool call; the platform handles billing, charges the caller, and pays out monthly.

Source: github.com/toolstem/toolstem-mcp-server. Examples: github.com/toolstem/toolstem-mcp-examples.

Day-7 numbers, honestly

This is the section every launch post conveniently skips.

Metric	Day 7
Apify Store users	1
Apify Store MAU	3
Apify revenue	$0
npm downloads	1,084 (mostly registry indexers — collapsing now)
GitHub stars / forks	0 / 0
GitHub unique views	9
External Apify runs	2 (both confirmed Microsoft Azure datacenter probes from directory health checks — not real users)

Greg's episode uses an example of a fintech MCP that hit "150 installs in 30 days, $0 ad spend, vibe coded." If that's true, the creator did something right that I have not done yet. I'm spending this week trying to figure out what.

What I think the gap is

Distribution is exactly what Greg said it is: the work. Building was the easy part. The build took ~2 days of vibe-coding plus ~5 days of hardening (smoke tests, release pipeline, OIDC publishing, default-demo for probes). Distribution is going to take longer than the build did.

Here's the work, ranked by what I think will move the needle most:

1. Be in every directory. Smithery and Glama are live. mcp.so, PulseMCP, modelcontextprotocol/servers, awesome-mcp-servers all in flight this week. This is mostly clerical.

2. Answer-engine-optimize the README. The episode mentions this as Strategy #4. AI agents reading the README to decide whether to call the tool need clear, structured, citation-ready prose. Not marketing copy. Direct semantics.

3. Programmatic SEO on the docs. Episode Strategy #2. Each tool gets a dedicated page targeting [tool name] for AI agents. Each ticker comparison gets a page. Build once, compounds forever. (Peter Levels, per the same episode: AI referrals went from 4% to 20% in one month.)

4. Ship the second vertical fast. First-mover advantage in directories is per-vertical. SEC filings MCP next; weather and sports odds after that.

5. Karma in the right communities. r/mcp, r/LocalLLaMA, the Anthropic Discord. Not posting links — answering questions substantively over weeks. This is slow distribution. It's also the most durable.

I'm not paying for ads. I'm not buying a newsletter (yet — that's Strategy #6 from the episode and I'll revisit at $1K MRR). I'm not running a viral artifact play. The plan is directories + AEO + community presence + shipping a second vertical.

What I'd tell anyone building one this week

Three things.

One: Build for the agent reader, not the human reader. Tool names, descriptions, parameter schemas — the agent has to decide whether to call your tool from text alone. No marketing. No cleverness. Direct functional language. Read it back as if you were Claude trying to pick between three tools that all look similar.

Two: Get billing right or it doesn't matter. Apify's PPE event ID in your config has to match the eventName in your Actor.charge() call exactly. I shipped a version where these mismatched and discovered it via smoke test, not user complaint. Test the billing path before you market the listing.

Three: Default-demo on empty input. Directory health-checks fire empty-input runs at your actor. If those produce no useful output, every directory probe is a wasted conversion opportunity. Make empty input run a representative tool call (cached so probes don't hammer your upstream API) and you've turned the probes into demos.

Where this goes

If Greg is right — and I think he is — the next 12 months are when the MCP directory landscape solidifies. Whoever has clean, monetized, multi-vertical MCPs in every directory by mid-2027 owns a tollbooth.

I'm going to keep posting actual numbers. If you're building something similar, the Github repos are public and the issues are open. The whole point is AI-to-AI distribution; I don't have a sales team, just a scoreboard.

Toolstem: apify.com/toolstem/toolstem-mcp-server · github.com/toolstem · @toolstem on Bluesky

Source for the strategy framing: Greg Isenberg, The Startup Ideas Podcast — "Making $$ with AI Marketing", Mar 30 2026.