_ registry / mcp streamable-http · checked 16h ago

tollnode

https://tollnode.com

Registry code: 75e2cd4453547c0f

api record

TollNode runs AI models (images, video, voice, music) and live data lookups (web, maps, social, shopping, business and public data) for a fixed price per call, charged only when the call returns a usable result. Work in three steps: search_tools to find the tool for the task, get_tool to read its inputs and price, run_tool to run it. search_tools, get_tool, get_call, list_calls, get_balance and upload_file are free. Calls finish inside their request and can't be cancelled; after a dropped connection, get_call returns the result. A tool request is capped at 4.5 MB in total, inline base64 files…

endpoint
https://tollnode.com/mcp
protocol
streamable-http ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
10 · newcomer
_ is it live, free and safe measured by this hub
Is tollnode live?
Yes — it answered the hub's last check (checked 16h ago). It answered 100% of checks over the last 30 days.
Is tollnode free to use?
Partly — some of its tools are open, others need a key or payment.
What tools does tollnode have?
7 tools: get_tool, run_tool, get_balance, upload_file, get_call, search_tools, list_calls.
Is tollnode safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
541ms

last good check

priced tools
0

of 7 tools

_ answered our checks, 90 days 3 checks · signed record
  • unknown → live
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts, and USDC settlements on base into the address this listing's priced doors name, read off the chain. Every caller and every payer counts the same; the chain total is counted from three payers. The address stands behind 30 doors on this origin, so the chain figures are the operator's. How it is counted.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

payers on base
5

distinct

settlements
6

last 2026-11-18

received on chain
0.03 USDC

no flags

_ what it can do 7 tools
1 open1 auth-required 5 never probed 2 of 7 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • search_tools open 16h ago

    Free; reads only. Finds the TollNode tools for a task and returns each match's name, title, one-line purpose, category and price per call, best matches first. Use it first whenever you need a capability (make an image or video, a voice or song, read a web page, search Google or Maps, get LinkedIn, YouTube, Amazon or other platform data, check a domain, weather or public data). Then call get_tool with the name you pick, then run_tool. With no query it lists everything in the category, or the whole catalog.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "limit": {
          "type": "integer",
          "default": 20,
          "maximum": 50,
          "minimum": 1,
          "description": "Most results to return, 1 to 50. Default 20"
        },
        "query": {
          "type": "string",
          "maxLength": 200,
          "description": "The task, model or platform in plain words, e.g. 'remove background', 'video with sound', 'linkedin company', 'gpt image'. Leave out to list all."
        },
        "category": {
          "type": "string",
          "description": "Only this category, e.g. Image, Video, Audio, Search, Social, Shopping, Business, Travel, Lookup, Document."
        }
      },
      "additionalProperties": false
    }
    arguments 22 lines
  • list_calls auth-required 16h ago

    Free; reads only. Lists your recent account calls, newest first: the tool, whether it succeeded, failed, was rejected (refused before running) or is still running, what it was charged (failed and rejected calls cost $0), the error code and message of a failed or rejected call, the name of the API key that made it, and its request id, plus the total charged on the page. Use it to review spending or find a request id for get_call. Filter by status, page back with before (the next value from the previous page). Needs an account API key on the connection; x402 calls are paid from your own wallet and show in its history instead.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "limit": {
          "type": "integer",
          "maximum": 50,
          "minimum": 1,
          "description": "How many calls to return, 1 to 50. Default 20."
        },
        "before": {
          "type": "string",
          "description": "Only calls made before this time (ISO 8601). Use the createdAt of the last call on the previous page."
        },
        "status": {
          "enum": [
            "succeeded",
            "failed",
            "rejected",
            "running"
          ],
          "type": "string",
          "description": "Only calls with this status (rejected = refused before running, e.g. a rate limit). Leave out for all."
        }
      },
      "additionalProperties": false
    }
    arguments 26 lines
  • get_tool unknown never probed

    Free; reads only. Returns everything needed to run one tool: what it does, when to use it and when not, its full JSON input schema with limits, its price per call and price options, its actions (for platform tools such as linkedin or google), an example input and its web page. Call it after search_tools and before run_tool so the input is right the first time.

    mcp-tool

    {
      "type": "object",
      "required": [
        "name"
      ],
      "properties": {
        "name": {
          "type": "string",
          "description": "The tool's name from search_tools, e.g. 'gpt-image-2-5-sunburst', 'linkedin' or 'weather'."
        }
      },
      "additionalProperties": false
    }
    arguments 13 lines
  • run_tool unknown never probed

    Runs one TollNode tool and returns its result: text, data, or links to the files it made. Spends money: the tool's price (see get_tool) is charged only when the call returns a usable result; a refused input, a failure or an empty result costs nothing. Every successful call is charged again, so do not repeat one that worked; send idempotency_key to make a retry safe. Pay from an account balance (API key on the connection) or with x402: the first call answers with the payment requirements as an error result; sign them and call again with the payment in params._meta["x402/payment"]. Account results end with the amount charged and a request id for get_call. The whole request is capped at 4.5 MB: send photos, audio and video as https links, or call upload_file first for anything over about 3 MB and pass its fileUrl.

    mcp-tool

    {
      "type": "object",
      "required": [
        "name",
        "input"
      ],
      "properties": {
        "name": {
          "type": "string",
          "description": "The tool's name from search_tools, e.g. 'weather'."
        },
        "input": {
          "type": "object",
          "description": "The tool's input fields, exactly as get_tool's inputSchema describes them, e.g. {\"action\": \"current\", \"location\": \"Lisbon\"}."
        },
        "idempotency_key": {
          "type": "string",
          "maxLength": 200,
          "description": "Optional, any unique text. Repeating an account call with the same key returns the first successful result without charging again. A call that was refused (rate limit, bad input, low balance) or failed does not use the key up: retrying with the same key is safe and runs the call."
        }
      },
      "additionalProperties": false
    }
    arguments 23 lines
  • get_balance unknown 16h ago

    Free; reads only. Returns your prepaid account balance in US dollars, so you can check a batch is affordable before running it. Needs an account API key on the connection (Authorization: Bearer tn_live_…). With x402 there is no balance: each call is paid from your own wallet.

    mcp-tool

    {
      "type": "object",
      "properties": {},
      "additionalProperties": false
    }
    arguments 5 lines
  • upload_file unknown never probed

    Free. A tool request is capped at 4.5 MB in total, and inline base64 files count toward it (base64 adds a third). For a bigger file, or any local file you would rather not inline (a long voice track, a full-size photo, a video), call this first: it returns a one-time uploadUrl and the fileUrl the file will have. PUT the file's raw bytes to uploadUrl within 15 minutes with the returned content-type header (the response includes a ready curl command; up to 100 MB), then pass fileUrl in the tool's file field (for example image or audio) with run_tool. One file per link. The file is deleted once a call that used it succeeds, so upload again for each new call; if no call succeeds with it, it is deleted after 6 hours.

    mcp-tool

    {
      "type": "object",
      "properties": {
        "filename": {
          "type": "string",
          "description": "Optional instead of content_type: the file's name, e.g. 'voice.mp3'; its extension sets the type."
        },
        "content_type": {
          "type": "string",
          "description": "The file's media type: image/jpeg, image/png, image/webp, image/gif, audio/mpeg, audio/wav, audio/flac, audio/ogg, audio/mp4, video/mp4, video/webm, video/quicktime or application/pdf."
        }
      },
      "additionalProperties": false
    }
    arguments 14 lines
  • get_call unknown never probed

    Free; reads only. Looks up one of your earlier account calls by its request id (given after every charged run_tool result and in errors): whether it is running, succeeded, failed or was rejected, what it was charged, the error code and message if it failed, the API key that made it, and its result again. Use it to recover a result after a dropped connection instead of paying twice: a call can't be cancelled and keeps running to the end even if you disconnect. list_calls finds request ids. Needs an account API key on the connection; x402 calls are not looked up here.

    mcp-tool

    {
      "type": "object",
      "required": [
        "request_id"
      ],
      "properties": {
        "request_id": {
          "type": "string",
          "pattern": "^[0-9a-fA-F-]{36}$",
          "description": "The request id, a UUID such as 3f2b6c1e-8d4a-4f7e-9a1b-2c3d4e5f6a7b."
        }
      },
      "additionalProperties": false
    }
    arguments 14 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id 75e2cd4453547c0f.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/75e2cd4453547c0f/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/75e2cd4453547c0f/badge.svg)](https://brick.blue/agent/75e2cd4453547c0f?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.