zlurp

Quick Verdict

zlurp is a paid web-scraping service for AI agents. It converts public URLs into Markdown through a remote API or Streamable HTTP MCP endpoint. Instead of an account or API key, each scrape uses x402 to settle USDC on Base. As of July 21, 2026, the capability verifiable in the public implementation is static HTML scraping: the server directly fetches a URL and processes it with Mozilla Readability, Cheerio, and Turndown.

The advertised static price of 0.005 USDC per URL matches the API and payment middleware. The site also advertises JavaScript rendering at 0.015 USDC per URL, but the public /scrape implementation does not invoke a browser or renderer. Its js input does not reach the scraping path, and responses report jsRendered: false. The higher-priced JS capability is therefore an unverified product claim, not a feature that should be relied on without a paid test.

Best For

zlurp best fits developers who already understand Base wallets and x402 and need occasional agent access to public, static pages. Its accountless per-request model can be convenient for experiments or low-volume MCP workflows where a subscription would be unnecessary.

It is a poor fit for authenticated pages, complex SPAs, sensitive intranet URLs, compliance-heavy bulk collection, or teams that cannot accept on-chain, non-refundable payments. Requirements such as verified JavaScript rendering, browser actions, proxy pools, regional selection, SLAs, or data-processing agreements point toward a more established scraping platform.

Key Features

• Static URL-to-Markdown: returns a title, Markdown, word and character counts, and scrape timestamp for an HTTP or HTTPS URL.
• Two extraction modes: article uses Readability and falls back to the page body; full converts the full body after removing scripts and styles.
• Remote MCP: https://zlurp.ai/mcp uses Streamable HTTP and exposes free probe_url plus paid scrape_url tools.
• REST API: GET /probe estimates cost and POST /scrape performs the paid scrape, with OpenAPI and agent-card descriptions available.
• x402 payments: a compatible client handles the HTTP 402 payment requirement with Base USDC and retries the request.
• One-hour Redis cache: results are keyed by URL and mode for 3,600 seconds; cached responses are still charged at the standard rate.
• robots.txt check: the service checks robots rules before scraping, but allows access when retrieval errors, times out, or returns a non-success response.

Use Cases

1. Let an MCP client read a public blog post as Markdown for summarization or question answering.
2. Call probe_url first, then approve a single scrape from a low-balance wallet with a strict budget.
3. Convert a static documentation page through the REST API for temporary analysis.
4. Experiment with x402 machine payments inside an agent tool flow without creating a traditional API account.

zlurp should not be treated as browser automation. The verifiable static path does not execute page JavaScript and provides no login, clicking, forms, or session-state workflow.

Pricing

This is paid per request, not freemium. Base transactions are generally irreversible and publicly expose the sender, recipient, amount, and transaction. Use a low-balance dedicated wallet with agent spending controls rather than a primary wallet or unrestricted private key.

Pros

• No account or API key, with no monthly plan required for low-volume use.
• Clear static price and a free probe before payment.
• REST, OpenAPI, agent card, and MCP interfaces simplify agent integration.
• Readability and full-page modes cover common articles and ordinary HTML.
• The one-hour cache can improve latency for repeated URLs.

Cons

• Unverified JavaScript path: the site lists a 0.015-USDC renderer, but no browser-rendering branch is present in the public scrape implementation.
• SSRF gap: public code validates only the HTTP/HTTPS scheme. It does not visibly block localhost, private addresses, cloud metadata, DNS rebinding, or unsafe redirect targets. Operators need egress isolation, and clients should never submit intranet URLs.
• Fail-open robots behavior: robots retrieval failures and non-2xx responses default to allowed. A generic browser user agent is used while checking *; this is not a substitute for terms, copyright, database-right, or privacy review.
• Limited legal disclosure: short terms place target-site compliance on users but provide little detail on the operating entity, jurisdiction, takedowns, infringement handling, SLA, or disputes. Commercial collection needs separate legal review.
• Wallet and x402 exposure: sample code loads a private key from an environment variable. Automated payment can be amplified by loops or prompt injection, while on-chain transfers are non-refundable and link wallet activity publicly.
• Caching and processors: submitted URLs and Markdown are cached in Redis for one hour, and hosting or cache providers may retain operational logs. Sensitive or restricted content should not be submitted.
• License mismatch: github.com/zlurp/zlurp has no license file and its root package.json declares no license. The PyPI package named zlurp is only a client and lists MIT in its metadata; that does not license the TypeScript server, hosted API, or MCP service.

Alternatives

FAQ

Is zlurp free?

No. Probing is free, but a verified static scrape costs 0.005 USDC per URL, so its catalog pricing is correctly classified as paid.

Can zlurp render JavaScript pages?

The site advertises js: true for 0.015 USDC per URL. As of July 21, 2026, the public /scrape code has no browser renderer, directly fetches HTML, and reports jsRendered: false. Test the paid behavior before depending on it.

How does the MCP server get paid?

The remote MCP’s probe_url tool provides a free estimate. scrape_url uses x402 and requires Base USDC, so the client must support the payment flow and protect wallet signing.

Is zlurp MIT-licensed open source?

That claim is not supported for the service. The TypeScript service repository has no declared license. MIT metadata on the PyPI client applies to that client package only and does not automatically cover the server source, hosted API, or brand service.

How long is data cached, and are cache hits charged?

The public code sets a Redis TTL of 3,600 seconds, or one hour. The service terms say cached results are still charged at the normal rate.

Does zlurp always respect robots.txt?

It performs a robots check, but retrieval errors fail open. Even an allowed robots result does not remove the user’s obligation to follow target-site terms, copyright, privacy rules, and applicable law.

What are the main security risks?

The major concerns are SSRF through user-supplied URLs, uncontrolled agent payments, wallet-key exposure, and scraped content entering caches or third-party logs. Production use needs URL egress policy, spending caps, a dedicated wallet, and content-compliance review.

Bottom Line

zlurp has a simple, legible proposition: a remote API/MCP that converts static URLs to Markdown for 0.005 USDC per request without an account. It remains an early paid service. Its 0.015-USDC JavaScript claim is not verifiable from the public implementation, while server licensing, SSRF controls, fail-open robots handling, legal disclosures, automated wallet payments, and one-hour caching all require additional diligence. Keep it to isolated, low-value experiments rather than unrestricted production agents.