Freemium strategies for MCP servers in the agent economy.
Leave the cheap tools open, put the expensive ones behind x402. Because agents pay per call without signup friction, freemium for machines works differently — and better — than it did for humans.
Human freemium is a conversion funnel: free users tolerate limits until they're annoyed into entering a credit card. Agent freemium skips the psychology. An agent that hits an x402 gate doesn't churn or grumble — if the call is worth the quoted price, its wallet signs a USDC authorization and the call proceeds, often in the same second.
That changes the design goal. You're not nurturing free users toward a subscription; you're using free calls as a zero-friction demonstration that makes the paid call an easy yes. Two patterns cover nearly every server.
Pattern one: free tools beside paid tools
The simplest split is by tool. On one server, the cheap-to-serve tools — a status check, a basic lookup, a small search — stay ungated, while the tools that consume real resources answer with HTTP 402 and a price. The free tools earn trust and tool-selection familiarity; the paid ones earn revenue.
This works because the free tools are genuine, not crippled demos. An agent that has successfully used your free lookup is already connected and already trusts your schema when its task escalates to the paid bulk variant. There's no second integration step standing between you and the upgrade.
Pattern two: a free quota, then the gate
When you have one tool rather than a portfolio, meter it: the first N calls per caller per day pass free, after which the endpoint starts returning 402. Track callers by wallet address — it's the identity x402 already gives you, no API keys needed.
Keep the quota small and honest. Its job is evaluation, not subsidy: enough calls for an agent builder to verify quality and wire up their workflow, not enough to run production on. Daily quotas beat lifetime ones because they reset evaluation for new use cases without ballooning your serving costs.
The gate in code
Both patterns reduce to one decision per request: does this call pay? Everything below the gate — the x402 handshake, USDC settlement on Base in about two seconds, the Ed25519-signed receipt — is handled for you, and the handler never runs on an unpaid metered call.
import { requirePayment } from "@loomal/sdk";
// Free: cheap lookup, no gate
export async function lookup(req: Request) {
return Response.json(await basicLookup(await req.json()));
}
// Paid: enrichment costs you real compute — gate it
export const enrich = requirePayment(
{ price: "$0.02" },
async (req) => Response.json(await deepEnrich(await req.json())),
);What belongs behind the gate
Gate where your marginal cost or your differentiated value lives: bulk operations, fresh or licensed data, heavy compute, anything that calls a paid upstream API. Leave open whatever is cheap and builds habit. A scraping server might give away single-page fetches and charge for full-site crawls; a data server might give away yesterday's snapshot and charge for live queries.
On Loomal, paid tools price from $0.01 per call — there is no $0 price on a listing; 'free' simply means a tool you choose not to gate. The floor is low enough that you can put a token price on borderline tools instead of agonizing: at one cent, the agent barely notices and you learn what demand looks like. The 5% fee on settled transactions is currently waived.
Watch the boundary, then move it
The free/paid line is a hypothesis, and your console data grades it. Heavy free usage with no paid calls suggests the free tier covers too much of the job — tighten the quota or move a capability across the line. Paid calls with no free warm-up means your free tier isn't part of the adoption path and may be costing you serving budget for nothing.
Repricing and re-drawing the line are one-field, one-deploy changes respectively, so iterate on real traffic rather than designing the perfect tier structure up front.
FAQ
Can one MCP server really mix free and paid tools?
Yes — gating is per route, not per server. Ungated tools respond normally; gated ones return HTTP 402 with a price and run only after USDC payment settles. Agents see one server, one connection, one tool list, with prices varying by tool.
How do I give a free quota without API keys?
Meter by wallet address, the identity the x402 flow already carries. Count calls per wallet per day and start returning 402 past the threshold. No signup, no key issuance, and the same identity later appears on paid receipts.
Can I list a tool at $0 on Loomal?
No — priced calls start at $0.01. A free tier is implemented as tools or quota you simply don't gate, which lives in your server, not in the listing's price field. The one-cent floor also makes 'almost free' a real option for borderline tools.
Won't agents just stay on the free tier forever?
Only if the free tier does the whole job — which is a sizing problem, not a freemium problem. Scope free access to evaluation (small quotas, lightweight variants) and put the production-scale capability behind the gate. Agents pay reflexively when the task requires it; there's no human reluctance to overcome.
Draw your free/paid line.
Gate the expensive tools and price them from the Loomal console.