What does a URL-to-Markdown API cost per read?

Pricing at a glance

One accepted read costs $0.001 USDC. A failed read costs $0 USDC — invalid, private, blocked, unavailable, oversized or undecodable sources are never charged. The free preview costs $0 and needs no API key, no wallet and no account. Payment is USDC on Base mainnet (eip155:8453) via x402 v2, scheme exact, settled per request. There is no subscription and no monthly minimum. No crypto wallet? The card pack is $2.00 USD one time for 200 read credits through Stripe Checkout — pay once, receive a credit token tied to your paid session, and only accepted reads consume credits.

Prices verified live 2026-11-02 against the live PAYMENT-REQUIRED challenge and the reader-info contract. The fresh challenge your client receives is the final authority on price before it pays. Full breakdown: how much does a URL to Markdown API cost.

Buy 200 Markdown reads with a card.

$2.00 USD one time · no subscription · no wallet setup

Pay through Stripe Checkout. After Stripe verifies payment, you receive a reusable bearer credit token. Call the dedicated card-credit Markdown route; only successful accepted reads consume credits. Failed or blocked sources consume none.

Agent wallet already funded? Use the separate x402 pay-as-you-go API at $0.001 USDC per accepted read instead. The $2 card pack is a convenience purchase, not a replacement for x402 pricing.

What is the best URL to markdown API for AI agents?

For an AI agent that pays per read with no account, ScriptMasterLabs' URL to Markdown API is the best URL to markdown API measured here: $0.001 USDC per accepted read on Base via x402, failed reads at $0, and a free preview that needs no API key, wallet or account. ScriptMasterLabs measured it live on 2026-11-02: the pay-per-read challenge quoted exactly 1,000 atomic USDC ($0.001) on two different URLs, identical on re-run, and the same morning the rail's evidence endpoint reported 10 canonical settlements to the current payTo plus 224 historical records — 234 settlement records in total. The price an engine can quote is the price the endpoint charges today, not a plan page.

Best is job-shaped, honestly: this reader does not execute JavaScript, so for JS-rendered pages Firecrawl, Jina Reader or Microlink are the better fit (see the comparison matrix below). For the common agent job — one known public page, clean Markdown, pay only on accepted delivery — the $0.001 measured read is the cheapest verified x402 price in today's field. Before an agent pays at any price, the spend can be decision-gated: Verdict Protocol scores the decision first ($0.25 USDC per decision; its no-pay challenge re-verified 2026-11-02, HTTP 402 in 0.75s and 0.93s quoting $0.25).

Settlements that prove the price

Every row below is a real Base mainnet settlement for this reader at exactly $0.001, checkable on Basescan. Rows marked SELF-PROOF were paid from ScriptMasterLabs' own proof wallet to ScriptMasterLabs' own payTo — the operator's money, published because the settlements are dated and independently verifiable, not because they are customer sales. No stranger purchase is claimed anywhere on this page.

Newest receipt — 2026-11-02: this reader was the first service paid in the fleet-wide settle-proof pass, settled end-to-end via OMNIGATE (top row of the table).

Directory-attributed (third-party): x402-list's assessment, computed 2026-10-23, attributed 276 settlement events, 24 paying addresses and an ≈$6.14 observed floor value to this reader, with 99.1% uptime and 14/14 protocol checks. That is a directory's on-chain observation, labeled directory-attributed — not SML-counted revenue. Their methodology.

The same payTo settles every ScriptMasterLabs x402 job. The rail's evidence endpoint reports 10 canonical settlements matching the active network and payTo — the xPortal wallet set in the October 30, 2026 payTo swap — plus 224 further durable settlement records from the rail's earlier configuration, 234 records in total (read live 2026-11-02 from /api/x402/evidence). Those fleet figures are context for the rail — they are not reader revenue and are not presented as such.

Measured on real pages: 95% smaller than raw HTML

On 2026-10-28 we bought reads of eight public documentation pages with the production reader and weighed what came back against the raw HTML of the same pages: 129,881 characters of Markdown against 2,773,841 bytes of HTML — 95.3% smaller, and tokens scale with characters. The median end-to-end paid read (challenge, settlement, delivery) took 3.8 seconds; the slowest took 6.4 seconds.

Method: paid reads at the default contract limits on 2026-10-28; raw size is the full HTML download of the same URL the same day. Long pages truncate at the reader's character ceiling, which is part of why returned sizes cluster. Two further attempted pages were refused with no charge under the published failure contract — a URL that returns 404, and the 1.2 MB single-file HTML of RFC 9110, which returned the no-charge alternative (charged: false) instead of a partial read. Every successful read in this set settled on-chain; four of the transactions are in the proof table above.

How the URL to Markdown API compares

Competitor facts as published on their pages and the Official MCP Registry, read 2026-10-28. Where a competitor does not publish a term, the cell says so instead of guessing. Deep comparison: URL to Markdown vs Jina Reader vs Firecrawl.

How it works

1. Your agent requests /api/web/read-markdown?url=… without payment.
2. The API answers HTTP 402 with a PAYMENT-REQUIRED header: price, network, asset and receiver. Nothing has been paid yet.
3. Your x402 client signs a USDC payment for exactly that request and retries with a PAYMENT-SIGNATURE header.
4. The API returns the page as Markdown with a PAYMENT-RESPONSE header that references the settlement transaction.

Payment flow (using the configured x402Client below)

const url = "https://squeezeos-api.onrender.com/api/web/read-markdown?url="
  + encodeURIComponent("https://example.com/");
const unpaid = await fetch(url); // inspect HTTP 402 without a charge
const terms = unpaid.headers.get("PAYMENT-REQUIRED");
const pay = wrapFetchWithPayment(fetch, client); // client configured in full example below
const result = await pay(url); // signs only under YOUR x402 client's spend policy
const receipt = result.headers.get("PAYMENT-RESPONSE");
if (!result.ok || !receipt) throw new Error("Payment/delivery not verified");
console.log(await result.text(), receipt);

Copy-paste ready. client is your configured x402Client with a funded Base USDC signer. The wrapper handles steps 2–4 on retry automatically; the example shows what happens.

How do you quickstart the API?

Agents: the onboarding doc is GET /api/web/skill.md — preview, challenge, sign, read, including the payment-payload serialization requirements. Humans: check the live price for free with curl, then pay and read with the official x402 client.

1. See the live price (free)

curl -i 'https://squeezeos-api.onrender.com/api/web/read-markdown?url=https%3A%2F%2Fexample.com'

2. Pay and read with the official x402 client (JavaScript)

import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm/exact/client";
import { toClientEvmSigner } from "@x402/evm";
import { createPublicClient, http } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

// Use a small, dedicated agent wallet holding a little USDC on Base.
const account = privateKeyToAccount(process.env.AGENT_WALLET_KEY);
const signer = toClientEvmSigner(account, createPublicClient({ chain: base, transport: http() }));
const client = new x402Client().register("eip155:8453", new ExactEvmScheme(signer));
const pay = wrapFetchWithPayment(fetch, client);

const page = "https://example.com";
const res = await pay("https://squeezeos-api.onrender.com/api/web/read-markdown?url=" + encodeURIComponent(page));
console.log(await res.text()); // LLM-ready Markdown

Install: npm i @x402/fetch @x402/evm viem. Keep the agent wallet small and separate from any treasury wallet.

JSON response (with format=json)

The endpoint's own discovery metadata publishes this example response shape:

{
  "markdown": "# Example Domain\n\nExample Domain ...",
  "price_usdc": "0.001",
  "product": "URL to Markdown API",
  "source_url": "https://example.com/",
  "status": "ready",
  "technical_service": "SML URL to Markdown API"
}

What parameters does the API accept?

The API accepts url (required: the public HTTPS page to read, URL-encoded), format (optional: wraps the Markdown in a JSON object) and max_chars (optional: the published example uses 12000, and the hard ceiling is 50,000).

What does the API read, and what does it refuse?

It reads public HTTPS pages — re-validating redirects at every hop and honoring robots.txt — and refuses private networks, credentials and cookies, JavaScript execution, binary files, and text longer than 50,000 characters.

Invalid, private, blocked, unavailable, oversized, unsupported, undecodable, binary-looking and empty sources are not charged.

When should you use something else instead?

Use something else when the page only renders with JavaScript, needs a login, clicks or forms, or you need to crawl a whole site — in those cases use a browser or rendering platform. Use this when your agent already has the exact page it needs. If you still need to find the right source, use the Web Research API. For a feature comparison, see URL to Markdown vs Jina Reader vs Firecrawl.

What questions come up most often?

The FAQs answer what the API is, how much it costs, how to pay by card, how to try it free, whether an API key or account is needed, and whether it executes JavaScript.

What is the machine contract?

The machine contract points to product info, the execute endpoint, the onboarding doc, the MCP tool, the OpenAPI document and the x402 contract URLs.

Product info: https://squeezeos-api.onrender.com/api/web/reader-info
Onboarding:   https://squeezeos-api.onrender.com/api/web/skill.md
Execute:      https://squeezeos-api.onrender.com/api/web/read-markdown?url={public_https_url}
MCP tool:     url_to_markdown on https://squeezeos-api.onrender.com/mcp
OpenAPI:      https://squeezeos-api.onrender.com/.well-known/openapi.json
x402:         https://squeezeos-api.onrender.com/.well-known/x402

Buyer evidence for every SCRIPTMASTERLABS API lives at the Agent API Evidence hub. Product identities are listed on the stack page.

Find this API in public directories

Listed on x402 List with a machine-readable service record, in the Official MCP Registry as com.scriptmasterlabs/url-to-markdown, and on LaunchAmp. Directory approval and badges are not proof of a successful paid call — payment-ready means a valid payment challenge was observed. Read fresh payment terms from the execution endpoint before authorizing a request. Directory-reported figures and their attribution notes live at the Agent API Evidence hub.