DEV Community: M M

I built an API that roasts your code for $0.02

M M — Wed, 25 Mar 2026 10:40:11 +0000

I wanted to show that API monetization for AI agents actually works. Not in theory — with a live endpoint that takes money and returns results.

So I built Roast my Code: an API that accepts a code snippet, charges $0.02 in USDC, and returns a brutal but technically accurate code review powered by an LLM.

It's live right now: roast.monapi.dev

How it works

Send code to the API without paying:

curl -X POST https://roast.monapi.dev/api/roast \
  -H "Content-Type: application/json" \
  -d '{"code": "function add(a,b) { return a - b; }", "language": "javascript"}'

You get back:

HTTP 402 Payment Required

The response body contains everything an x402-compatible agent needs: price ($0.02), token (USDC), network, wallet address. The agent pays, retries, and gets the roast.

What a roast looks like

I fed it this classic:

function isEven(n) {
  if (n === 0) return true;
  if (n === 1) return false;
  return isEven(n - 2);
}

The response:

"Recursion: because why use modulo when you can make the call stack suffer?"

Call isEven(1000000) and watch your browser weep. This will crash faster than a crypto startup. The iterative n % 2 === 0 exists for a reason.

Negative numbers are your kryptonite — isEven(-5) triggers infinite recursion into the shadow realm.

Performance theater — O(n) time complexity for something that should be O(1). It's like taking a helicopter to the mailbox.

Brutal, but every point is technically correct.

The entire server

The whole thing is ~40 lines. Here's the core:

import express from "express";
import { monapi } from "@monapi/sdk";
import { generateRoast } from "./llm.js";

const app = express();
app.use(express.json());

app.use("/api/roast", monapi({
  wallet: process.env.MONAPI_WALLET!,
  price: 0.02,
  network: "base-sepolia",
}));

app.post("/api/roast", async (req, res) => {
  const { code, language } = req.body;

  const roast = await generateRoast(code, language);

  res.json({
    roast,
    language,
    linesAnalyzed: code.split("\n").length,
  });
});

That's it. The monapi() middleware handles the entire payment flow — 402 response, payment verification, settlement. The route handler only runs after payment is confirmed.

Why this exists

This isn't just a toy. It demonstrates a real problem and a real solution:

The problem: AI agents are becoming major API consumers. They can call your endpoint, but they can't sign up for an account or enter a credit card. Today, you either block them or serve them for free.

The solution: HTTP 402. The agent hits your API, gets a price, pays in USDC, gets the data. No signup, no API keys, no invoicing. Fully automated.

The Roast API is a proof of concept — but the pattern works for any API. Weather data, financial feeds, code analysis, search results. Anything an AI agent would pay for.

The economics

LLM cost is ~$0.001 per roast
I charge $0.02
That's a 95% margin
Network fees on Base are < $0.01 (sponsored by the x402 facilitator)

If an agent roasts 1,000 code snippets, that's $20 in revenue vs ~$1 in LLM costs. The math works even at micro-scale.

Try it

The API is live on Base Sepolia (testnet). Hit the root endpoint to see pricing:

curl https://roast.monapi.dev

{
  "name": "Roast my Code",
  "pricing": { "POST /api/roast": "$0.02 USDC" },
  "network": "base-sepolia",
  "poweredBy": "monapi.dev"
}

To actually pay and get a roast, you need an x402-compatible client (like Coinbase AgentKit or the @x402/fetch wrapper).

Build your own

Want to build something like this? The SDK is open source:

npm install @monapi/sdk

Full docs: monapi.dev | GitHub | npm

This is part 3 of a series on monetizing APIs for AI agents. Part 1: One line of code · Part 2: Paid MCP tools

How to build a paid MCP tool that AI agents pay to use

M M — Tue, 24 Mar 2026 11:49:31 +0000

MCP is everywhere right now. Everyone is building MCP servers — for search, for databases, for file systems. But there's one thing nobody is talking about: how do you get paid when an AI agent uses your MCP tool?

Today we'll build a complete MCP server with a paid tool. An AI agent calls your tool, pays per use, and gets the result. No API keys, no subscriptions, no signup.

This isn't theoretical. We'll build it, run it, and test it.

What we're building

A code review MCP server. An AI agent sends a code snippet, pays $0.05, and gets a structured review back — issues found, suggestions, severity ratings.

Why code review? Because it's expensive to run (it calls an LLM under the hood), so charging for it makes sense. And it's a tool that AI agents actually want — coding agents like Cursor, Windsurf, and Claude Code could use a second opinion on the code they write.

How payment works in MCP

Quick primer if you haven't seen this before.

MCP tools normally work like this: agent calls tool → tool returns result. Free.

With x402 payment, there's one extra step: agent calls tool → server says "pay $0.05 first" → agent pays in USDC → server runs the tool → agent gets the result.

This happens automatically. x402-compatible agents (Coinbase AgentKit, Cloudflare Workers, Vercel AI SDK) handle payment without any human intervention. The agent has a wallet, sees the price, decides if it's worth it, pays, and gets the data.

Prerequisites

Node.js 18+
A wallet address (Coinbase Wallet or MetaMask — free, takes 2 minutes)

Step 1: Set up the project

mkdir code-review-mcp && cd code-review-mcp
npm init -y
npm install @modelcontextprotocol/sdk @monapi/sdk @x402/mcp zod
npm install -D tsx typescript @types/node

Add "type": "module" to your package.json.

Step 2: Build the MCP server

Create server.ts:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { monapiMcp } from "@monapi/sdk/mcp";
import { z } from "zod";

const server = new McpServer({
  name: "code-review",
  version: "1.0.0",
});

const paid = monapiMcp({
  wallet: process.env.MONAPI_WALLET!,
  price: 0.05,
  network: "base-sepolia",
});

This sets up the MCP server and creates a payment wrapper. Every tool wrapped with paid() will cost $0.05. We're using base-sepolia (testnet) for development.

Step 3: Add a free discovery tool

server.tool(
  "list_capabilities",
  {},
  async () => ({
    content: [
      {
        type: "text",
        text: JSON.stringify({
          name: "code-review",
          description: "Automated code review for any language",
          tools: {
            review_code: {
              price: "$0.05",
              description: "Analyze code for bugs, security issues, and style",
            },
          },
        }, null, 2),
      },
    ],
  })
);

No paid() wrapper means no payment required. This tool is free.

Why does this exist? An AI agent connecting to your MCP server for the first time has no idea what you offer or what it costs. The discovery tool answers both questions in machine-readable JSON. The agent can parse this, decide if review_code is worth $0.05, and proceed.

This is the equivalent of a storefront window. If you lock everything behind a paywall, agents will disconnect and move on.

Step 4: Add the paid tool

server.tool(
  "review_code",
  {
    code: z.string().describe("The code snippet to review"),
    language: z.string().describe("Programming language"),
  },
  paid(async (args) => {
    const review = analyzeCode(args.code, args.language);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(review, null, 2),
        },
      ],
    };
  })
);

The paid() wrapper is doing all the work. When an agent calls review_code:

monapi checks if the request includes a valid payment
No payment → the agent gets a 402 response with the price ($0.05), token (USDC), network (Base), and wallet address
The agent pays and retries
Payment verified → your handler runs and returns the review

You write the handler. monapi handles everything else.

Step 5: The analysis logic

function analyzeCode(code: string, language: string) {
  const issues: Array<{
    severity: "error" | "warning" | "info";
    line: string;
    message: string;
    suggestion: string;
  }> = [];

  const lines = code.split("\n");

  for (const line of lines) {
    if (line.includes("eval(")) {
      issues.push({
        severity: "error",
        line: line.trim(),
        message: "Use of eval() is a security risk",
        suggestion: "Use JSON.parse() for data, or a sandboxed interpreter",
      });
    }

    if (/password\s*=\s*["']/.test(line)) {
      issues.push({
        severity: "error",
        line: line.trim(),
        message: "Hardcoded password detected",
        suggestion: "Use environment variables: process.env.PASSWORD",
      });
    }

    if (line.includes("catch") && line.includes("{}")) {
      issues.push({
        severity: "warning",
        line: line.trim(),
        message: "Empty catch block swallows errors silently",
        suggestion: "Log the error or re-throw",
      });
    }

    if (line.includes(".forEach") && line.includes("await")) {
      issues.push({
        severity: "warning",
        line: line.trim(),
        message: "await inside forEach doesn't work as expected",
        suggestion: "Use for...of for sequential, or Promise.all() for parallel",
      });
    }
  }

  return {
    language,
    linesAnalyzed: lines.length,
    issues,
    summary:
      issues.length === 0
        ? "No issues found. Code looks clean."
        : `Found ${issues.length} issue(s): ${issues.filter((i) => i.severity === "error").length} errors, ${issues.filter((i) => i.severity === "warning").length} warnings, ${issues.filter((i) => i.severity === "info").length} info.`,
  };
}

This is deliberately simple — pattern matching for common issues. In production, you'd call an LLM (OpenAI, Anthropic, etc.) to do the actual review. That's exactly why charging $0.05 makes sense: if you're spending $0.02 on an LLM call under the hood, you need to charge more than that.

Step 6: Start the server

const transport = new StdioServerTransport();
await server.connect(transport);

Run it:

MONAPI_WALLET=0xYourWalletAddress npx tsx server.ts

In production, you'd register it in an MCP client config:

{
  "mcpServers": {
    "code-review": {
      "command": "npx",
      "args": ["tsx", "/path/to/server.ts"],
      "env": {
        "MONAPI_WALLET": "0xYourWalletAddress"
      }
    }
  }
}

Go to production

One change for real payments:

const paid = monapiMcp({
  wallet: process.env.MONAPI_WALLET!,
  price: 0.05,
  network: "base", // was "base-sepolia"
});

Same code, real money. Payments settle in under 2 seconds on Base. USDC is always $1.

What makes this different from a regular paid API

An Express API with monapi works for HTTP clients — agents that make web requests. But MCP is a different protocol. MCP tools are discovered and called by AI assistants directly, inside their runtime. Claude, GPT, Cursor — they all speak MCP.

By building a paid MCP tool instead of (or in addition to) a paid HTTP API, you're available where agents already are. They don't need to know your URL. They discover you through their MCP configuration.

Pricing your MCP tools

Some rules of thumb:

Discovery/metadata tools: Free. Always. Agents need to evaluate you before paying.
Cheap lookups (cached data, simple transforms): $0.001–$0.01
Moderate work (API calls, database queries): $0.01–$0.05
Expensive operations (LLM calls, heavy compute): $0.05–$0.50

Price based on your cost, not your value. Agents are cost-optimizing machines. If your tool costs $0.50 and a competitor does the same for $0.10, the agent picks the cheaper one every time. Race to the best cost/quality ratio, not the highest margin.

Full source

Everything in this post is a complete, runnable project.

GitHub — full SDK with MCP support
monapi.dev — docs and quickstart
npm — npm install @monapi/sdk

Or use the CLI to scaffold it:

npx monapi init

It auto-detects MCP from your package.json and generates the boilerplate.

This is part 2 of a series on monetizing APIs for AI agents. Part 1: How to monetize your API with one line of code

How to monetize your API for AI agents (with one line of code)

M M — Mon, 23 Mar 2026 12:47:14 +0000

You built an API. It's good. Developers use it. But there's a new type of customer knocking on your door — and they can't sign up.

AI agents are the fastest-growing consumer of APIs right now. They discover endpoints, try to call them — and hit your signup page. Account creation, email verification, credit card form. They can't continue. They leave. You never know they were there.

This isn't a future problem. It's happening today.

The opportunity you're missing

AI agents already spend millions on API calls every month. Coinbase's x402 protocol has settled over 75 million transactions. The agent economy is real.

Quick math: 10,000 agents call your API once a day at $0.01 each. That's $100/day — or $36,500/year. From traffic you're currently losing.

The solution: HTTP 402

HTTP 402 means "Payment Required." It's been in the HTTP spec since 1997. Nobody used it — until now.

Here's how it works:

An agent sends a request to your API
Your server responds with 402 Payment Required (price, token, wallet)
The agent pays in USDC and retries
Your API responds with 200 OK and the data

No accounts. No API keys. No invoices. Just HTTP.

Add it to your API in 5 minutes

Install:

npm install @monapi/sdk @x402/express

Add one function call:

import express from "express";
import { monapi } from "@monapi/sdk";

const app = express();

app.use(monapi({
  wallet: process.env.WALLET,
  price: 0.01, // $0.01 per request
}));

app.get("/api/weather", (req, res) => {
  res.json({ temp: 22, city: "Berlin" });
});

app.listen(3000);

Test it:

$ curl -i localhost:3000/api/weather

HTTP/1.1 402 Payment Required
X-Payment-Price:    0.01
X-Payment-Token:    USDC
X-Payment-Network:  base
X-Payment-Wallet:   0x83...913

Any x402-compatible agent reads this, pays automatically, and retries. Your API responds normally.

Per-route pricing

Not every endpoint is worth the same:

app.use(monapi({
  wallet: process.env.WALLET,
  routes: {
    "/api/weather":  0.01,   // simple lookup
    "/api/forecast": 0.05,   // more compute
    "/api/search":   0.10,   // expensive query
  },
}));

Also works with Next.js and MCP (Model Context Protocol). Same SDK, different entry points.

What happens under the hood

Request — Agent calls your endpoint
402 — monapi intercepts, returns payment terms
Payment — Agent signs USDC transfer via EIP-3009 and retries
200 — Facilitator verifies, settles on-chain, your API responds

Key details:

Gas fees are sponsored. Agents only need USDC — no ETH, no MATIC. The x402 facilitator covers gas.
Settlement in under 2 seconds. On Base, Arbitrum, or Polygon.
Non-custodial. Payments go directly to your wallet. monapi never touches your funds.
Free and open source. MIT licensed. No monapi fees.

Who's already paying?

Agents built with Coinbase AgentKit, Cloudflare Workers, and the Vercel AI SDK already support x402 payments. The infrastructure exists today.

Get started

Three options:

Interactive CLI: npx monapi init — detects your framework, configures your wallet, generates code
Copy the code above — install, add middleware, deploy
Read the full docs — every config option, every framework

Your API is already getting traffic from agents. The only question is whether you're getting paid for it.

Links:

monapi.dev — Website
GitHub — Source code
npm — @monapi/sdk
Full article with sources — on monapi.dev