Your agent can already search. Marrow is for the next step — get the data, watch it, and know exactly what changed. Section-level change tracking, flat-rate monitoring.
$ npx -y marrow-setup --email you@example.com
Search can't tell you what changed. Marrow can. Tracks additions, modifications, moves and removals — section by section.
Marrow returns clean markdown — humans can read it, and so can your AI.
Scout → read: marrow_scout maps a page's links and structure, then marrow_read deep-reads it — fewer tokens burned. Cache is standard,
so the second read is fast and cheap. Monitoring is flat-rate.
Building RAG pipelines? Each section gets a stable id — vector DB upsert works out of the box.
Say "search with Marrow" and marrow_scout + marrow_read pull clean markdown.
Ask your AI to check a URL for updates and get a section-level diff versus your last read — the diff is free.
Keep a watchlist in a skill and just tell your AI "do today's rounds."
Most crawlers bulldoze through the whole rendered page — navs, ads, footers, related-product carousels and all. Marrow goes for the marrow: it pulls the essence from the page's backend (the source JSON) and uses the rendered frontend only to verify. You get the nutritious core, not the bone. That's the whole point of the name.
| Page | Tokens vs Firecrawl — same URL |
|---|---|
| Clean article (Wikipedia) | On par — little chrome to strip |
| News article (BBC) | ~30% fewer |
| Heavy e-commerce (Shopify product) | ~75% fewer |
| The product feed behind that page | up to 26× smaller |
The more clutter, the bigger the win. Measured head-to-head between
Firecrawl and Marrow on the same URLs. And that's per page — scout → read
saves even more tokens by skipping pages you don't need. (When a page exposes no backend JSON, Marrow falls
back to markdown from the rendered frontend.)
Firecrawl bills monitoring per check — 1 credit per page, every time, so the bill climbs with every URL and every interval. Marrow is flat-rate. Check as often as you want — it costs nothing.
Do my morning rounds — only tell me what changed.
Checked the 5 pages in your watchlist. Two moved:
The other three are unchanged since yesterday.
Your watchlist lives in a skill and you just ask. Each read is one credit; checking a few times a day barely touches your plan.
Register a URL and Marrow checks it on schedule — fires a webhook when something changes. No dashboard, no wiring. Flat-rate; checks don't count.
Worked example: monitoring 100 pages every 30 min = ~144,000 checks/month.
| Item | Firecrawl | Marrow |
|---|---|---|
| Billed as | per-check (1 / page / check) | flat — checks don't count |
| Plan you need | Growth (Standard's 100k credits won't cover it) | Pro — 100 monitors |
| Cost | $333 / mo | $29.99 / mo — ~11× cheaper |
Crank the interval to every 5 minutes — same price. Webhooks are signed and Firecrawl-compatible. (Firecrawl prices are their listed plans.)
The URLs you watch are your strategy — competitor prices, hiring pages, policy changes. That's not for a crawler to know. Marrow is built so there's nothing to leak.
Your API key is your identity — like gh auth or
stripe login. Nothing to sign up for, nothing to phish. Throw the key away and
you're gone.
Card details go straight to Stripe — Marrow never sees them, and never stores your name or address. All we hold is an email handle and a credit balance.
The extraction worker is stateless and the cache is content-addressed — it records that a page exists, not who asked for it. There's no dashboard of every URL you've ever pulled.
Most crawlers keep exactly that dashboard. Your watchlist is a trade secret — Marrow doesn't hold it.
One command — it gets you a free key and wires Marrow into every agent you use.
$ npx -y marrow-setup --email you@example.comclaude mcp add marrow \
-e MARROW_API_KEY=mrw_xxx \
-- npx -y @marrowdev/mcp{
"mcpServers": {
"marrow": {
"command": "npx",
"args": ["-y", "@marrowdev/mcp"],
"env": { "MARROW_API_KEY": "mrw_xxx" }
}
}
}# ~/.codex/config.toml
[mcp_servers.marrow]
command = "npx"
args = ["-y", "@marrowdev/mcp"]
env = { MARROW_API_KEY = "mrw_xxx" }Tools: marrow_scout · marrow_read · marrow_search ·
marrow_crawl · marrow_screenshot · marrow_monitor_*
Plain HTTP with a Bearer key. The REST API is Firecrawl-compatible.
import requests
BASE = "https://api.marrow.navii.online"
H = {"Authorization": "Bearer mrw_xxx", "Content-Type": "application/json"}
# Scrape + change tracking → also get a chunk-level diff vs last time
r = requests.post(f"{BASE}/v1/scrape", headers=H, json={
"url": "https://example.com/pricing",
"formats": ["markdown", "changeTracking"],
})
ct = r.json()["data"]["changeTracking"]
print(ct["changeStatus"]) # new / same / changed
for c in ct["chunks"]: # the delta
print(c["status"], c["anchor"])
# Watch it: flat-rate monitor → webhook on change
requests.post(f"{BASE}/v1/monitor", headers=H, json={
"url": "https://example.com/pricing",
"interval_minutes": 30,
"webhook_url": "https://you.example/hook",
})const BASE = "https://api.marrow.navii.online";
const H = { Authorization: "Bearer mrw_xxx", "Content-Type": "application/json" };
// Scrape + change tracking
const res = await fetch(`${BASE}/v1/scrape`, {
method: "POST", headers: H,
body: JSON.stringify({
url: "https://example.com/pricing",
formats: ["markdown", "changeTracking"],
}),
});
const { data } = await res.json();
console.log(data.changeTracking.changeStatus); // new / same / changed
for (const c of data.changeTracking.chunks) {
console.log(c.status, c.anchor); // the delta
}
// Watch it
await fetch(`${BASE}/v1/monitor`, {
method: "POST", headers: H,
body: JSON.stringify({
url: "https://example.com/pricing",
interval_minutes: 30,
webhook_url: "https://you.example/hook",
}),
});# Scrape + change tracking
curl -X POST https://api.marrow.navii.online/v1/scrape \
-H "Authorization: Bearer mrw_xxx" -H "Content-Type: application/json" \
-d '{"url":"https://example.com/pricing","formats":["markdown","changeTracking"]}'
# Watch it
curl -X POST https://api.marrow.navii.online/v1/monitor \
-H "Authorization: Bearer mrw_xxx" -H "Content-Type: application/json" \
-d '{"url":"https://example.com/pricing","interval_minutes":30,"webhook_url":"https://you.example/hook"}'The REST API is drop-in compatible — point your client at Marrow,
keep your code. changeTracking works the same.
| Capability | Firecrawl | Marrow |
|---|---|---|
| Cache | None | Standard — re-reads ~free (0.1 cr) |
| Change tracking | Page-level diff | Chunk-level + stable ids → vector upsert |
| Monitoring | Per-check credits | Flat-rate — check as often as you want |
| Token use | Full markdown dump | 30–75% fewer tokens — measured (back-of-page extraction + scout→read) |
| Privacy | Account + activity dashboard | No account — key is identity, queries not logged |
| Migration | — | Drop-in: change the base URL |
Free key, no card — start testing with npx marrow-setup in seconds.
| Plan | Monthly credits | Concurrent monitors | Daily rate | |
|---|---|---|---|---|
| Free · $0 | 500 | 1 | 100 / day | Start free |
| Developer · $9.99 | 5,000 | 10 | 2,000 / day | Subscribe |
| Pro · $29.99 | 50,000 | 100 | 20,000 / day | Subscribe |
scrape/search 1 · scout 0.5 · crawl 2/page · screenshot 2 · Cache-hit 0.1 credits. Failed requests are free. Monitoring is flat — no per-check charge.