Building a Monetized API: From Zero to Earning in 5 Minutes

For most of the last decade, the default path to monetizing an API looked like this: build it, put up a pricing page, write Stripe integration code, set up webhooks, handle failed charges, write invoice templates, deal with VAT, build an API key management system, write rate limiting, publish docs, buy ads, wait for a signup. A weekend project became a three-month side project. Most people gave up at step three.

There's a faster path now. On CreateOS, you deploy an API, list it on the marketplace, and it becomes discoverable and callable by the thing that's actually driving API demand in 2026: AI agents. Claude Code, Cursor, ChatGPT, Antigravity, and other MCP-compatible clients can find your API, pay per call in credits, and route customer requests to it without you writing a line of billing code.

This post walks through the full flow. Deploy, publish, earn. All of it in under five minutes.

Why agents are the customer you want

A human user of your API is valuable. They might call it a few dozen times a month. They churn. They complain about pricing. They email you at 2 AM.

An AI agent is a different customer. A single Claude Code session might call a JSON-transformation API 50 times in an hour while refactoring a codebase. A Cursor agent might hit a text-to-SQL service hundreds of times a day. Multiply by the hundreds of thousands of developers now running agents on autopilot.

For indie developers, this is the opportunity: publish the kind of API you'd normally build as a weekend project, put it on an agent-discoverable marketplace, and the agents find it themselves when they need it. You don't do outbound sales. The MCP tool directory is the outbound.

The CreateOS marketplace is designed for exactly this. Agents calling tools over the CreateOS MCP server at https://api-createos.nodeops.network/mcp discover your published Skill, call it, and the credit transaction happens automatically. Publisher keeps 80%, platform keeps 20%.

Prerequisites

• A CreateOS account
• The CreateOS CLI installed (brew tap nodeops-app/tap && brew install createos)
• An idea for an API that's useful enough that an agent would call it (we'll pick one below)
• 5 minutes

Step 1: Pick an API worth building

Good candidates for a monetized Skill have three properties:

1. Narrow. One clear job. "Extract structured data from a PDF." "Generate OG images." "Convert JSON to CSV."
2. Agent-useful. Something an AI agent would want to delegate instead of doing in-context (token-expensive or requires tools the LLM doesn't have).
3. Fast. Agents retry. Agents chain calls. If your API takes 10 seconds, it's going to get replaced by a faster one.

Good picks for a first Skill: JSON validator and transformer, screenshot API, text-to-slug generator, URL shortener, markdown-to-PDF, og-image generator, email validator, exchange rate lookup, small vector search over a curated dataset.

For this post we'll build a tiny JSON transformation Skill. The principles apply to any of the above.

Step 2: Build the API

mkdir json-transform && cd json-transform
npm init -y
npm install express

Save as index.js:

const express = require("express");
const app = express();
app.use(express.json({ limit: "5mb" }));

// CORS for browser callers
app.use((req, res, next) => {
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
  if (req.method === "OPTIONS") return res.sendStatus(204);
  next();
});

app.get("/", (req, res) => {
  res.json({
    name: "json-transform",
    description: "Transform a JSON object via a jq-style path expression.",
    pricing: { credits: 1, usd: 0.01 },
    endpoints: [
      { method: "POST", path: "/api/transform", body: "{ input, path }" },
    ],
  });
});

app.get("/health", (req, res) => res.json({ status: "ok" }));

app.post("/api/transform", (req, res) => {
  const { input, path } = req.body || {};
  if (!input || !path) {
    return res.status(400).json({
      success: false,
      error: { code: "INVALID_INPUT", message: "input and path are required" },
    });
  }
  try {
    const result = path
      .split(".")
      .filter(Boolean)
      .reduce((acc, key) => (acc == null ? acc : acc[key]), input);
    res.json({
      success: true,
      data: { result },
      meta: { credits: 1, processingMs: 2 },
    });
  } catch (err) {
    res.status(400).json({
      success: false,
      error: { code: "BAD_PATH", message: err.message },
    });
  }
});

const port = process.env.PORT || 3000;
app.listen(port, () => console.log(`listening on ${port}`));

Notice the response envelope: { success, data, meta }. This is the CreateOS-recommended shape for Skills. It makes your API predictable for both humans and agents. Include a pricing block on GET / so the marketplace can display the cost at a glance.

Step 3: Add an MCP tool manifest

The difference between an API that sits on a marketplace and a Skill that gets called by agents is a one-file manifest. Save as mcp-tool.json:

{
  "name": "json_transform",
  "description": "Transform a JSON object by extracting the value at a given dot-path. Useful when you need a specific nested field from a larger JSON payload.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "input": {
        "type": "object",
        "description": "The JSON object to transform"
      },
      "path": {
        "type": "string",
        "description": "Dot-path of the field to extract, e.g. 'user.address.city'"
      }
    },
    "required": ["input", "path"]
  },
  "endpoint": "POST /api/transform",
  "pricing": { "credits": 1, "usd": 0.01 }
}

Serve it at /mcp-tool.json:

app.get("/mcp-tool.json", (req, res) => {
  res.sendFile(__dirname + "/mcp-tool.json");
});

This file is how agents discover what your Skill does, what arguments it needs, and what it costs. Good descriptions matter here. The agent's LLM reads the description and decides whether to call your tool based on the user's request. Clear, specific descriptions win.

Step 4: Deploy

createos login
createos init
createos deploy

Three commands. The last one prints your live URL:

✓ Deployed (v1)
ℹ Live at: https://json-transform.nodeops.app

Test it:

curl -X POST https://json-transform.nodeops.app/api/transform \
  -H "Content-Type: application/json" \
  -d '{"input":{"user":{"address":{"city":"Lisbon"}}},"path":"user.address.city"}'

{
  "success": true,
  "data": { "result": "Lisbon" },
  "meta": { "credits": 1, "processingMs": 2 }
}

Your API is live. Next, we make it monetized and discoverable.

Step 5: Publish to the CreateOS marketplace

Head to createos.nodeops.network and navigate to your project. In the dashboard:

1. Open your project's settings.
2. Choose Publish as Skill (or Publish as Template if you want to share the full source).
3. Fill in: name, description, category, pricing (credits per call), tags.
4. Submit for review.

Approval is typically quick. Once published, your Skill appears in the CreateOS marketplace catalog and is immediately available to the MCP server for agent discovery. Agents querying the server at https://api-createos.nodeops.network/mcp for JSON-related tools will see it.

Publishing via the CLI is on the roadmap. In the meantime, the dashboard flow is the supported path.

Step 6: How the money flows

CreateOS operates on a credit system: $1 = 100 credits. 1 credit = $0.01. When an agent or developer calls your Skill:

1. The caller's account is debited the credit cost you set.
2. You keep 80%. The platform keeps 20%.
3. Your credits accumulate in your publisher account. You withdraw when you want.

If you price your Skill at 1 credit per call and it's called 10,000 times per day (not unusual for a useful Skill once agents find it), that's 10,000 credits per day gross, 8,000 credits net ($80/day) for you. For a Skill that took a Saturday to build.

Pricing is your call. Some Skills are free (builds reputation). Some charge 10 to 50 credits per call for anything involving LLMs, image generation, or heavy compute. Look at the existing catalog to calibrate.

Step 7: Browse the catalog (your new peers)

createos skills catalog

This opens a full-screen TUI built with Bubble Tea. You can search, browse, see pricing, and purchase other developers' Skills for your own agents to call. It's also a good way to scout which categories are underserved.

createos skills purchased

Shows Skills you've already bought. Every purchased Skill becomes available as an MCP tool your agent can call.

This dual role (publisher and consumer) is what makes the marketplace work. The same developers building Skills are also the ones most likely to buy them.

What makes a good Skill

From the Skills that are already live:

1. Clarity wins. A tight description, one job, a two-line curl example on the landing page. Agents and humans both make a buy decision in seconds.
2. Speed wins. Sub-200ms response for compute-only. Sub-3s for AI-backed work. Slow APIs get replaced by fast ones.
3. Good error messages win. Always return a consistent envelope. Agents parsing your response need predictable structure. { success: false, error: { code, message } }.
4. Respect the 10MB body limit. For larger payloads, accept a URL instead of raw bytes.
5. Pricing rounded to a clear mental model. "1 credit per call" is easier to reason about than "0.037 credits per call." Agents often cost-gate, and simpler pricing gets picked more often.

Agent-first design choices

The best-earning Skills assume the caller is an agent, not a human:

• Machine-readable errors. Never return human-prose errors. Always a code and a message.
• Idempotent where possible. Agents retry. If your Skill isn't idempotent, mark it clearly.
• No auth ceremony for MCP callers. The CreateOS MCP server handles auth for you. Don't require an additional API key.
• Rich MCP descriptions. The agent's decision to call your tool is based on the natural-language description in your mcp-tool.json. Write it for an LLM, not a human skimmer. Be specific about when to use, when not to use, and what comes back.

Try it: your first monetized Skill, this weekend

The best way to understand the economics is to ship one. Pick something narrow:

• A webhook signature verifier.
• A favicon generator.
• A GitHub repo stats fetcher with nicer output.
• A Figma URL parser.
• A robots.txt validator.

Build it. Deploy it. List it. Share the URL. In a week you'll have either a new revenue stream, a data point about what agents actually need, or both.

# Install
brew tap nodeops-app/tap && brew install createos

# Deploy your idea
createos login
createos init
createos deploy

# Then publish from the dashboard

---

Previous: Managing Env Vars and Cron Jobs →

Next: How We Built a TUI Marketplace with Bubble Tea in Go →

Try it: CreateOS marketplace · Skills docs · CLI docs · MCP server