Send a URL. Get clean data back.
One API to scrape pages, search, crawl sites, drive browsers and extract JSON. Siftzo handles the proxies, browsers, retries and blocks, runs in the EU and only bills requests that work.
No card needed. Failed requests are never billed.
Read https://www.siftzo.com/llms.txt and set up Siftzo for this project.Paste it into Claude Code, Cursor or any coding agent. It reads llms.txt and does the rest.
Example: a POST to /v1/scrape for a product page with render auto and format markdown. The first attempt over HTTP is blocked by a challenge page, the second attempt in a browser with a new IP succeeds, and the page comes back as Markdown. Only the successful browser attempt is billed.
Connects to the AI tools you already use
Products
One API for every way you get web data
One key, one set of credits and the same proxies and browsers underneath, whether you need a page, a search result, a whole site or a record.
- POST /v1/scrape
Scraper API
Any public page as HTML or Markdown, with proxies, rendering and retries handled.
Learn more - POST /v1/serp
SERP API
Google, Bing and DuckDuckGo results as structured JSON.
Learn more - wss://…/v1/browser
Browser API
A fresh cloud Chrome for your Playwright or Puppeteer code, over CDP.
Learn more - POST /v1/crawls
Crawl API
Follow the links of a site up to 10,000 pages, always within robots.txt.
Learn more - GET /v1/data/{source}
Data API
Products, articles and page metadata as records with fixed fields.
Learn more - POST /v1/extract
AI extraction
Describe the data with a JSON Schema or a prompt and get JSON that matches.
Learn more - proxy.siftzo.com:8443
Proxy access
Siftzo's residential network in your own client, billed per MB.
Learn more
Works with every product
Coming soon
Not available yet. We'll say so when they are.- Official SDKsComing soonTypeScript, Python and Go clients.
- free credits every month
- 1,000
- credits for failed requests
- 0
- URLs in one batch request
- 1,000
- pages in one crawl
- 10,000
For AI tools
Connect Claude, Cursor or your own agent
Siftzo is a remote MCP server. Your AI logs in with OAuth and gets web data as tools, so it can read pages, pull out fields and compare prices without you wiring up an API.
- One URL, no keyAdd the server to your tool. It registers itself and opens a Siftzo login page.
- You stay in controlPick the organization it may use, and disconnect it any time in the dashboard.
- Tools for the webScrape to Markdown, extract JSON, read products and articles, check usage, run feeds.
claude mcp add --transport http siftzo https://app.siftzo.com/mcpRun it once, then type /mcp in Claude Code and choose siftzo to log in.
https://app.siftzo.com/mcpSettings, Connectors, Add custom connector. Paste the URL and log in.
{
"mcpServers": {
"siftzo": {
"url": "https://app.siftzo.com/mcp"
}
}
}Add it to ~/.cursor/mcp.json, then log in when Cursor asks.
{
"servers": {
"siftzo": {
"url": "https://app.siftzo.com/mcp",
"type": "http"
}
}
}Add it to .vscode/mcp.json, or run MCP: Add Server from the command palette.
codex mcp add siftzo --url https://app.siftzo.com/mcpThen run codex mcp login siftzo to log in.
grok mcp add --transport http siftzo https://app.siftzo.com/mcpLog in when Grok asks. grok mcp doctor siftzo checks the connection.
{
"mcp": {
"siftzo": {
"type": "remote",
"url": "https://app.siftzo.com/mcp",
"enabled": true
}
}
}Add it to opencode.json. OpenCode starts the login when the server asks for it.
https://app.siftzo.com/mcpAny client with remote MCP and OAuth works: give it this URL. It registers and logs in on its own.
How it works
One request, four steps you don't have to build
Each request takes the cheapest route that works. You see which tier answered, how many attempts it took and what it cost in every response.
01 · Fetch
A plain HTTP request that looks like Chrome
Most pages need no browser. Siftzo sends the request with Chrome's TLS and HTTP/2 fingerprint through a residential IP in the country you ask for. That costs 1 credit.
tier: http · exit: residential · de- GETexample.com/products?page=1200412 ms
- GETexample.com/products?page=2200388 ms
- GETexample.com/products?page=3200455 ms
02 · Render
A real browser for pages built in JavaScript
With render=always, or when auto decides it is needed, the page loads in a fresh Chrome profile. Use wait_for to wait for the element you need and screenshot to get a PNG. A browser request costs 10 credits.
shop.example.com/item/42.price€ 129.00wait_for: ".price" · screenshot: true
03 · Retry & escalate
Blocked? Try again, smarter
If an attempt is blocked or the proxy fails, Siftzo retries with a new IP, and on render=auto it moves from HTTP to the browser. Up to 3 attempts, within your timeout. Siftzo also remembers which domains need a browser and starts there next time.
render: auto · attempts- Attempt 1 · http403 · challenge page
- Attempt 2 · browser200 · 48 KB
Blocked on HTTP, so the next attempt used a browser with a new IP.
04 · Bill only success
You pay for pages, not for attempts
Credits are charged for the tier that produced the result, and only when the target answered with 2xx, 3xx, 404 or 410. Blocks, timeouts and proxy errors cost 0 credits.
usage · this monthExample requests and the credits they cost Target Result Credits example.com/a 200 1 example.com/b 404 1 shop.example.com 200 10 blocked.example target_blocked 0
Under every product
Everything between your code and the page
Proxies, fingerprints, browsers and retries are the parts of scraping that break. Siftzo runs them for you behind every endpoint.
HTTP first, browser when needed
With render=auto every request starts on a fast HTTP client with a real browser fingerprint and moves to headless Chrome only if the page blocks it. A second browser engine takes over when Chrome is blocked.
Residential proxies by country
Every request leaves through a residential IP. Pick the exit country with one parameter, or keep the same IP for 10 minutes with a session.
Block detection built in
Challenge pages from the common anti-bot services are recognised and retried, not returned as data. Blocked attempts cost nothing.
Screenshots and wait_for
Wait for a CSS selector before the page is captured, and get a PNG of the viewport next to the HTML.
Async jobs and batches
Send async: true or up to 1,000 URLs in one batch, and get a signed webhook when the work is done.
Hosted in the EU
The API, the browsers and your data run in the EU. Siftzo is an EU company working under GDPR.
Built for real workloads
From one request to a production pipeline
The same API scales from a script on your laptop to scheduled jobs across teams.
For LLMs and RAG
Markdown your model can read
Add format=markdown and get the main content of the page as clean Markdown: headings, lists, tables and links kept, navigation, footers and scripts gone. It costs the same as HTML. Crawl a whole docs site as Markdown, or describe the fields you need and let AI extraction return JSON that matches your schema.
format: markdown · example.com/blog/weekly-releasestext/markdown# How we ship every week We release on Tuesdays. The steps: 1. Freeze **main** on Monday 2. Run the [test suite](https://example.com/ci) 3. Tag and deploy | Step | Owner | | ------ | -------- | | Freeze | Platform | | Deploy | On call |
Removed:navfooterscriptscookie bannerFor data pipelines
Batches in, signed webhooks out
Send up to 1,000 URLs in one batch request. Siftzo runs them within your concurrency and calls your endpoint when they are done, signed with HMAC-SHA256 and retried for 24 hours until you answer. No polling loop to maintain.
POST hooks.example.com/siftzo204- Siftzo-Event:
- batch.finished
- Siftzo-Signature:
- t=1759750000,v1=9f2c4e…
{ "event": "batch.finished", "status": "done", "counters": { "total": 1000, "done": 994, "failed": 6 } }Signature checked, delivery acknowledged
For companies
Teams with their own keys and caps
Organizations have members, roles and teams. Each team gets its own API keys, its own request logs and an optional monthly credit cap, so one project can't use up another's budget.
organization · teamsExample teams with their API keys and monthly credit caps Team API keys Monthly cap Pricing 3 40,000 Research 2 15,000 Data platform 4 no cap
Use cases
What you can build with it
Public web data for analysis, monitoring and AI, collected responsibly.
- Price monitoringTrack public prices and stock across shops as clean product records.
- SEO rank trackingCheck where pages rank on Google, Bing and DuckDuckGo, by country.
- Market researchCollect public catalogues, articles and search results for analysis.
- AI and RAG dataFeed models clean Markdown and JSON instead of raw HTML.
- Listings aggregationBring public real-estate and classifieds listings into one schema.
- Company researchRead public company websites for firmographics, not personal data.
- Brand monitoringSee where your brand shows up in search results and on public pages.
- Academic researchBuild reproducible web corpora with polite, robots.txt-aware crawls.
Why Siftzo
Build it yourself, or send one request
Scraping in-house is possible. It is also a second product to maintain. Here is what moves off your plate.
| Area | Do it yourself | With Siftzo |
|---|---|---|
| Proxies | Buy, rotate and monitor a residential pool yourself. | Residential IPs with country targeting and sticky sessions, included. |
| Fingerprints | Keep TLS and HTTP/2 fingerprints in step with real browsers. | Requests look like Chrome at the TLS and HTTP/2 level. |
| Browsers | Run, patch and scale headless browsers and their memory. | Fresh sandboxed browsers on demand, only when a page needs one. |
| Blocks | Write detection for challenge pages and decide when to retry. | Blocks are detected, retried with a new IP and escalated. |
| Cost of failures | You pay for the bandwidth and compute of every failed attempt. | Blocked, timed-out and failed requests cost 0 credits. |
| Output | Write and maintain parsers for HTML, search pages and products. | HTML, Markdown, SERP JSON, product and article records, or your own schema. |
| Crawling politely | Implement robots.txt, Crawl-delay, rate limits and deduplication. | robots.txt always respected, per-host rate limits, URLs deduplicated. |
Need full control of the browser? The Browser API runs your own Playwright or Puppeteer code on Siftzo's browsers.
For developers
It's one HTTP call
Put your key in the X-API-Key header and POST a URL. The response tells you the target's status, headers and body, plus the tier, attempts and credits used.
- Sync by default, with a timeout you choose between 5 and 90 seconds.
- Use
format: "markdown"for clean Markdown, or"raw"for the body as-is. - Official SDKs are coming soon. Until then, any HTTP client works.
curl https://api.siftzo.com/v1/scrape \
-H "X-API-Key: $SIFTZO_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com", "country": "de"}'const res = await fetch("https://api.siftzo.com/v1/scrape", {
method: "POST",
headers: {
"X-API-Key": process.env.SIFTZO_API_KEY,
"Content-Type": "application/json",
},
body: JSON.stringify({ url: "https://example.com", country: "de" }),
signal: AbortSignal.timeout(90_000),
});
const result = await res.json();
if (!res.ok) throw new Error(result.error.code);
console.log(result.target.status_code, result.tier, result.credits);
console.log(result.target.body.slice(0, 200));import os
import requests
res = requests.post(
"https://api.siftzo.com/v1/scrape",
headers={"X-API-Key": os.environ["SIFTZO_API_KEY"]},
json={"url": "https://example.com", "country": "de"},
timeout=90,
)
result = res.json()
res.raise_for_status()
print(result["target"]["status_code"], result["tier"], result["credits"])
print(result["target"]["body"][:200])package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"os"
"time"
)
func main() {
payload, _ := json.Marshal(map[string]any{"url": "https://example.com", "country": "de"})
req, _ := http.NewRequest("POST", "https://api.siftzo.com/v1/scrape", bytes.NewReader(payload))
req.Header.Set("X-API-Key", os.Getenv("SIFTZO_API_KEY"))
req.Header.Set("Content-Type", "application/json")
client := &http.Client{Timeout: 90 * time.Second}
res, err := client.Do(req)
if err != nil {
panic(err)
}
defer res.Body.Close()
var result struct {
Tier string `json:"tier"`
Credits int `json:"credits"`
Target struct {
StatusCode int `json:"status_code"`
Body string `json:"body"`
} `json:"target"`
}
json.NewDecoder(res.Body).Decode(&result)
fmt.Println(res.StatusCode, result.Target.StatusCode, result.Tier, result.Credits)
}<?php
$ch = curl_init("https://api.siftzo.com/v1/scrape");
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 90,
CURLOPT_HTTPHEADER => [
"X-API-Key: " . getenv("SIFTZO_API_KEY"),
"Content-Type: application/json",
],
CURLOPT_POSTFIELDS => json_encode(["url" => "https://example.com", "country" => "de"]),
]);
$result = json_decode(curl_exec($ch), true);
echo $result["target"]["status_code"], " ", $result["tier"], " ", $result["credits"], PHP_EOL;Pricing
Credits, not surprises
An HTTP request is 1 credit and a browser request is 10. Failed requests are free. Set a spending limit and Siftzo stops there.
Free
$0 / month
1,000 credits
Starter
$49 / month
25,000 credits
Growth
Most popular$149 / month
100,000 credits
Scale
$449 / month
350,000 credits
Trust
Built to be used responsibly
Siftzo is for public web data. We say no to some targets, answer abuse reports, and keep your keys and data in the EU.
Responsible collection
- Public pages only. Private networks, internal hostnames and a blocklist of sensitive domains are refused before a request leaves the API.
- No scraping behind logins without permission, no harvesting of personal data without a legal basis. Accounts that break the acceptable use policy are suspended.
- Site owners can report abuse or ask to opt out at [email protected].
Security
- Hosted in the EU. Request logs and results stay in the EU.
- API keys are stored only as keyed hashes. We can't read your key back, and a revoked key stops working within a minute.
- Only signed container images run in production. Every browser task gets a new, sandboxed profile, so no cookies are shared between requests.
Read more in the trust center and the guide to responsible crawling.
Questions
What is Siftzo?
Siftzo is a web data API hosted in the EU. You send a URL, a search or a crawl, and Siftzo handles proxies, browser rendering, retries and block detection, then returns HTML, Markdown or structured JSON.
Do I pay for requests that fail?
No. Only requests where the target answered with 2xx, 3xx, 404 or 410 are billed. Blocks, timeouts, unreachable targets and proxy errors cost 0 credits, including the retries Siftzo makes for you.
What does the Free plan include?
1,000 credits every month and the same API as the paid plans, including browser rendering and residential proxies. No card is needed.
Does Siftzo respect robots.txt?
The Crawl API always reads and follows robots.txt, and it cannot be turned off. A Crawl-delay makes a crawl slower, never faster. Siftzo is for public web data only; see the acceptable use policy.
Where is my data stored?
The API, the browsers, request logs and results run in the EU. Siftzo is an EU company and works under GDPR.
Can I use Siftzo from Claude, Cursor or another AI tool?
Yes. Siftzo is a remote MCP server: add its URL to your tool and log in with OAuth, with no API key to copy. The tools scrape pages to Markdown, extract JSON, read products and articles, and show your credit usage. Coding agents can also read /llms.txt, which lists the docs in a form made for them.
Are there official SDKs?
Official TypeScript, Python and Go SDKs are coming soon. Until then, any HTTP client works, and the docs have examples in cURL, Node.js, Python, Go and PHP.
Start with 1,000 free credits. Every month.
Create an account, copy your key, send a request. No card needed for the Free plan.