Skim — Clean Web Reader (URL to Markdown)

Turn any URL into clean, agent-ready Markdown — no ads, no nav, no boilerplate — in about a second.

This Actor is the official Apify integration for Skim, the canonical x402 clean reader API. Give it a list of URLs; it returns each page as clean Markdown plus structured metadata (title, byline, published date, language, excerpt).

See it before you wire it: try Skim free in your browser — 10 free skims a day, no wallet, no signup. Paste a URL, see exactly what you get back.

Why this Actor

• Fast. Skim returns most pages in about a second — it reads and cleans, it doesn't spin up a browser farm. In production tests it ran 2.3x faster than Firecrawl on the same pages (benchmarks).
• Clean. Output is readable Markdown roughly 4x smaller than the raw HTML — ideal for feeding LLMs without paying token costs for junk.
• Simple. One URL in, one clean document out. No crawling configuration, no selectors, no proxies to manage.

If you need deep multi-page crawling with browser rendering, a heavyweight crawler is the right tool. If you need this page, clean, now — that's Skim.

Input

{
  "urls": [
    "https://en.wikipedia.org/wiki/HTTP_402",
    "https://example.com/article"
  ],
  "includePlainText": false
}

• urls — up to 500 URLs per run.
• includePlainText — also include a plain-text version of each page.

Output

One dataset item per URL:

{
  "url": "https://en.wikipedia.org/wiki/HTTP_402",
  "ok": true,
  "markdown": "# HTTP 402\n\n...",
  "metadata": {
    "title": "HTTP 402",
    "byline": null,
    "lang": "en",
    "excerpt": "..."
  },
  "elapsedMs": 1050
}

Failed URLs come back with ok: false and an error message — you are only charged for successful reads.

Use it from your stack

Call the Actor from anywhere Apify runs — your own code, n8n, Make, Zapier, or LangChain via the Apify integration.

Python:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("jessiejanie/skim-clean-reader").call(run_input={
    "urls": ["https://en.wikipedia.org/wiki/HTTP_402"]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["metadata"]["title"])
    print(item["markdown"][:500])

JavaScript:

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "<YOUR_APIFY_TOKEN>" });
const run = await client.actor("jessiejanie/skim-clean-reader").call({
  urls: ["https://en.wikipedia.org/wiki/HTTP_402"],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].markdown);

FAQ

Does it render JavaScript? Not in this Actor — it reads server-rendered HTML, which covers most articles, docs, and blog pages, and is why it is fast and cheap. If a page returns nearly empty content, it is likely a client-rendered app.

Can I feed the output straight to an LLM? Yes — that is the point. The Markdown is boilerplate-free and roughly 4x smaller than the raw HTML, so you stop paying token prices for nav bars and cookie banners.

What happens on a failed page? You get the item back with ok: false and an error message, and you are not charged for it.

How many URLs per run? Up to 500. URLs are processed one at a time, most in about a second each — a 100-page run typically finishes in a couple of minutes.

Is there a way to try it without paying? Yes — freeskims.skim402.com runs the same engine in your browser, 10 free skims a day, no signup.

Pricing: one flat number, nothing else

$4.00 per 1,000 successful page reads. That is the entire bill.

• No per-run start fees.
• No separate compute, memory, or proxy charges — platform usage is included in the price.
• Failed pages are never charged.
• No subscription, no rental, no minimum.

Most tools in this niche look cheap until you read the fine print. Here is what the fine print typically adds:

Cost	Skim	Typical alternatives in this niche
Per page read	$4.00 / 1,000	$3–$50 / 1,000
Per-run start fee	none	$0.0015–$0.09 every run
Compute / memory billing	included	"free" actors bill raw platform usage — commonly $0.50–$4+ / 1,000 pages, varies with settings
Monthly rental	none	some charge a flat monthly fee on top
Failed pages	free	often billed like successes

Start fees are the quiet one: agent workloads are typically many small runs, and a $0.09 start fee makes a 10-page run cost roughly three times what the per-page price suggests. With Skim, a 10-page run costs $0.04 — exactly what the headline says.

Built on a real API, not just an Actor

Skim is a standalone product with its own infrastructure at skim402.com — a production clean-reader API serving AI agents directly, with public docs, published benchmarks, an MCP server, and connectors for LangChain, LlamaIndex, CrewAI, and Haystack. This Actor is its official Apify integration: the same engine, the same clean output, with normal Apify billing.

You can try it free in your browser before running a single paid read.

Agents that carry their own crypto wallets can also call Skim directly over the x402 protocol — pay per call in USDC, no account: skim402.com/docs. This Actor exists so Apify users get the same reads with no wallet required.