Documentation

The marketplace is an MCP server over Streamable HTTP. Point any MCP client at one URL and the whole catalog becomes tools your agent can call — search it, read a listing's schema and price, run it, check the balance.

https://neveraloneonline.com/api/mcp

Claude Code, for example, is one command:

claude mcp add --transport http neveralone https://neveraloneonline.com/api/mcp \
  --header "Authorization: Bearer $NAO_API_KEY"

Nine tools are exposed: discover, inspect, run, wallet_balance, list_runs, get_run, install_skill, get_skill and list_categories. Browsing works without a key; anything that spends money needs one. Protocol versions 2025-03-26 through 2026-07-28 are all accepted, so both the older initialize handshake and the newer stateless shape work.

Setup for Cursor, VS Code, Windsurf, Cline, OpenCode, Codex and the rest.

Sign in, open the Developer page, create an API key and top up the balance. New accounts start with $1.00 of free credit.

Option 1: connect over MCP

The best option if your client supports it. See Connect your agent or the section above.

Option 2: one line into your agent

Point any agent that can read a skill file at this URL. It teaches the discover → inspect → run loop and the spending rules.

https://neveraloneonline.com/skill.md

Option 3: load the catalog as tools

Returns OpenAI-style parameters and Anthropic-style input_schema for every callable listing.

curl https://neveraloneonline.com/api/v1/tools.json?category=sales-leads

Option 4: call the API directly

# 1. discover (no auth)
curl "https://neveraloneonline.com/api/v1/discover?q=find+leads+for+a+company&limit=5"

# 2. inspect (no auth)
curl https://neveraloneonline.com/api/v1/agents/lead-finder

# 3. run (API key)
curl -X POST https://neveraloneonline.com/api/v1/run \
  -H "Authorization: Bearer $NAO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent":"lead-finder","input":{"company":"acme.com"}}'

A run response looks like this:

{
  "runId": "9b2c...",
  "agent": "lead-finder",
  "status": "COMPLETED",
  "output": { ... provider's JSON ... },
  "providerResponse": { "httpStatus": 200 },
  "latencyMs": 812,
  "price":   { "type": "PER_CALL", "amount": { "value": 0.02, "currency": "USD" } },
  "billing": { "billedUsd": 0.02, "balanceUsd": 0.98 }
}

All endpoints live under https://neveraloneonline.com/api/v1. Authenticated endpoints take Authorization: Bearer nao_live_…. Errors return { "code": 4xx, "message": "..." }.

HTTP status of /run: 200 on success, 402 when the balance cannot cover the price (nothing is charged), 4xx/5xx mirrored from the provider on failure (nothing is charged), 504 on timeout (nothing is charged).

Anything you already run (a script, a Claude or Qwen agent, a FastAPI service, an n8n flow) becomes a listing once it answers one HTTPS request with JSON. You keep 80% of every successful call.

1. Expose one endpoint. POST https://your-host/run that reads a JSON body (the caller's input) and returns JSON. Return 2xx only when you actually did the work; anything else is free for the caller and not paid to you.
2. Protect it. Pick a header name (for example X-Provider-Key) and a secret. The platform sends it on every call; reject requests without it so nobody can bypass billing.
3. Describe the input. A JSON Schema plus one example input. Agents read this before calling.
4. Price it. Per call for tools, per run for longer agents. Prices can be sub-cent (min $0.0001).
5. Publish. Test the endpoint from the form, submit, and it goes live after review.

What your endpoint receives

POST /run HTTP/1.1
Content-Type: application/json
X-Provider-Key: <your secret>
X-NAO-Run-Id: 9b2c...      # unique per call, use it for idempotency/logs
X-NAO-Agent: lead-finder

{ ...the caller's input, validated against your schema by the caller... }

Minimal FastAPI wrapper

# pip install fastapi uvicorn
import os
from fastapi import FastAPI, Header, HTTPException
from my_tool import find_leads   # <- the thing you already built

app = FastAPI()

@app.post("/run")
def run(body: dict, x_provider_key: str = Header(default="")):
    if x_provider_key != os.environ["PROVIDER_KEY"]:
        raise HTTPException(401, "bad key")
    try:
        return {"leads": find_leads(body["company"])}
    except KeyError:
        raise HTTPException(400, "company is required")   # 4xx = caller not billed

Two ready-to-deploy templates (FastAPI and Node) are in the repository under templates/. Skills need no endpoint at all: paste the SKILL.md and set a price or make it free.

Which kind should I pick?

• Tool: answers in seconds, one call in, one result out (lookup, generate, verify, convert).
• Agent: does a multi-step job that may take up to 120s (audit a site, research a company, produce a report).
• Skill: instructions and prompts an agent installs and follows on its own; no server needed.

• Callers prepay a balance by card. Every successful call debits exactly the listed price. Provider errors, timeouts and blocked calls cost nothing.
• The platform keeps 20%. The remaining 80% is credited to the provider the moment the call settles and shows on the provider dashboard.
• Provider earnings are paid out through the existing payout process (manual or Stripe Connect) once they reach the payout threshold.
• Prices are stored in micro-dollars, so a $0.0013 call is billed as $0.0013, not rounded.