Convert Any Webpage to Clean Markdown
Under 2 seconds. No credits. No multipliers. No surprises. Production-ready API for RAG pipelines, LLM apps, and content aggregation.
Copy and paste in your terminal after getting your API key
Performance That Matters
Built for speed, scaled for production. Real metrics from real usage.
10-20x faster than competitors
Including full JS rendering
Enterprise-grade reliability
On Scale plan - transparent pricing
Why Teams Choose Neo Reader
Stop paying for credit multipliers and slow response times. Get predictable pricing and lightning-fast performance.
| Feature | Others | Neo Reader |
|---|---|---|
| Average Latency | 7.9s average | <500ms for static, <2s for SPAs |
| Credit System | 5-25x multipliers for JS | One request = one request |
| Billing Model | Token-based billing | Fixed monthly plans |
| License | AGPL restrictions | Apache 2.0 (self-host freely) |
| Self-Hosting | Broken or unavailable | Production-ready Docker |
| SPA Handling | Manual configuration | Automatic framework detection |
Everything You Need, Nothing You Don't
Production-ready features that solve real problems. No bloat, no complexity, just results.
Lightning Fast
Two-tier architecture: instant HTTP fetching for static content, smart fallback to browser rendering
- 100-500ms for static pages
- Automatic SPA detection
- No manual configuration needed
Transparent Pricing
No hidden costs or credit multipliers. One request = one request, regardless of complexity
- Fixed monthly pricing
- JS rendering included
- No surprise charges
LLM-Ready Output
Clean, structured markdown optimized for AI applications and RAG pipelines
- Multiple output formats
- CSS selector targeting
- Custom element removal
Automatic JS Rendering
Intelligent detection of React, Vue, Next.js, Nuxt, Angular, and Svelte applications
- Zero configuration
- Framework detection
- Optimized wait strategies
Production Ready
Enterprise-grade infrastructure with 99.9% uptime SLA and comprehensive monitoring
- Distributed architecture
- Auto-scaling
- Real-time health monitoring
Self-Host Freely
Apache 2.0 licensed with production-ready Docker deployment. Full source access
- No AGPL restrictions
- Complete source code
- Docker & Kubernetes configs
Features Others Don't Have
Built from the ground up to solve real problems that competitors ignore.
Two-Tier Speed Architecture
Lightning-fast HTTP fetching for static pages (~500ms) with intelligent fallback to full browser rendering for SPAs (~2s). 10-20x faster than competitors.
The Problem with Competitors:
Jina Reader: 7.9s average | Neo Reader: <500ms static, <2s SPAs
Automatic speed optimization
No configuration needed - speed optimization is automatic
# Neo Reader automatically chooses the fastest method
curl 'https://api.neoreader.dev/https://static-blog.com'
# ✓ Uses HTTP fetcher: ~100-500ms
curl 'https://api.neoreader.dev/https://react-app.com'
# ✓ Detects SPA, uses browser: ~2-5s
# Still 3-4x faster than Jina Reader's 7.9s averageTransparent Pricing (No Multipliers)
One request = one request. No hidden costs for JavaScript rendering, complex pages, or premium features. All competitors use credit multipliers.
The Problem with Competitors:
Firecrawl: 5-25x multipliers | Neo Reader: Fixed per-request pricing
Predictable costs
$0.60 per 1K requests on Scale plan - no surprises
# Complex SPA with JavaScript
curl 'https://api.neoreader.dev/https://heavy-spa.com'
# Cost: 1 request
# With Firecrawl:
# Base cost: 1 credit
# JavaScript multiplier: 5x
# Premium proxy: 10x
# Total: 50 credits per request
# With Neo Reader:
# Always 1 request, regardless of complexityAutomatic Framework Detection
Zero-configuration detection and rendering of React, Vue, Next.js, Nuxt, Angular, and Svelte. Competitors require manual wait selectors.
The Problem with Competitors:
Competitors: Manual configuration | Neo Reader: Automatic detection
No configuration required
Detects _next/, _nuxt/, React root, Vue app, Angular modules automatically
# React app - works automatically
curl 'https://api.neoreader.dev/https://react-app.com'
# Vue app - works automatically
curl 'https://api.neoreader.dev/https://vue-app.com'
# Next.js app - works automatically
curl 'https://api.neoreader.dev/https://nextjs-app.com'
# No need to specify:
# - X-Wait-For-Selector
# - Framework-specific settings
# - Custom timeout logicProduction-Ready Self-Hosting
Apache 2.0 license with battle-tested Docker configs. Firecrawl uses AGPL (requires open-sourcing forks) and has unstable self-hosting.
The Problem with Competitors:
Firecrawl: AGPL + unstable | Neo Reader: Apache 2.0 + production-ready
Deploy anywhere in minutes
Docker, Kubernetes configs included. No licensing headaches.
# Clone and run
git clone https://github.com/neoreader/neo-reader-api
cd neo-reader-api
# Production deployment
docker-compose --profile prod up -d
# Or use Kubernetes
kubectl apply -f k8s/
# Full source access, no AGPL restrictions
# Modify and deploy privatelySee the Difference Yourself
Sign up for our free tier and experience the speed and simplicity.
No credit card required to get started.
Built for Your Use Case
See how teams are using Neo Reader in production. Ready-to-use code examples included.
RAG Pipeline
Index documentation and web content for AI chatbots
import requests
def fetch_for_rag(url: str) -> dict:
response = requests.get(
f"https://api.neoreader.dev/{url}",
headers={
"X-API-Key": "YOUR_API_KEY",
"X-Respond-With": "markdown",
"X-Target-Selector": "article, main"
}
)
return {
"content": response.text,
"source": url
}
# Feed directly to vector database
content = fetch_for_rag("https://docs.example.com")
vector_db.upsert(content)News Aggregator
Monitor sources and fetch articles at scale
import asyncio
import aiohttp
async def fetch_articles(urls: list[str]):
async with aiohttp.ClientSession() as session:
tasks = []
for url in urls:
task = session.get(
f"https://api.neoreader.dev/{url}",
headers={
"X-API-Key": "YOUR_API_KEY",
"X-Respond-With": "markdown"
}
)
tasks.append(task)
responses = await asyncio.gather(*tasks)
return [await r.text() for r in responses]LangChain Integration
Build document loaders for LLM applications
from langchain.document_loaders.base import BaseLoader
from langchain.schema import Document
import requests
class NeoReaderLoader(BaseLoader):
def __init__(self, urls: list[str], api_key: str):
self.urls = urls
self.api_key = api_key
def load(self) -> list[Document]:
documents = []
for url in self.urls:
response = requests.get(
f"https://api.neoreader.dev/{url}",
headers={
"X-API-Key": self.api_key
}
)
documents.append(Document(
page_content=response.text,
metadata={"source": url}
))
return documentsSimple, Transparent Pricing
No credit multipliers. No hidden fees. One request = one request. Choose the plan that fits your needs.
Free
Perfect for evaluation and side projects
- 500 requests/month
- 20 requests/minute rate limit
- All output formats (Markdown, HTML, Text)
- JavaScript rendering included
- SPA auto-detection
- Community support
Developer
For individual developers and MVPs
- 10,000 requests/month
- 100 requests/minute rate limit
- All output formats + Screenshots
- JavaScript rendering included
- CSS selector targeting
- Element removal
- Email support (48h response)
Pro
For production applications and growing teams
- 100,000 requests/month
- 500 requests/minute rate limit
- All Developer features plus:
- Full-page screenshots (pageshot)
- Custom User-Agent
- Cookie injection
- Priority queue processing
- Email support (24h response)
- Usage dashboard & analytics
Scale
For high-volume applications and data pipelines
- 500,000 requests/month
- 2,000 requests/minute rate limit
- All Pro features plus:
- Proxy rotation included
- Extended timeout (up to 180s)
- Webhook delivery
- Batch processing endpoint
- Dedicated IP pool
- Priority support (4h response)
- Slack channel access
Enterprise
For organizations with advanced requirements
- Unlimited requests (fair use policy)
- Custom rate limits
- All Scale features plus:
- Dedicated infrastructure
- On-premise deployment option
- Custom SLA (up to 99.99% uptime)
- SOC 2 Type II compliance
- SSO/SAML integration
- Invoice billing (NET-30)
- Dedicated account manager
- 1-hour emergency support
- Custom integrations
Real-World Cost Comparison
100,000 pages/month - typical production RAG pipeline
| Provider | Monthly Cost | Notes |
|---|---|---|
| Neo Reader Pro | $79 | All-inclusive, JS rendering included |
| Jina Reader | ~$50-200 | Variable by output tokens |
| Firecrawl Standard | $83 → $415 | 5x credit multiplier for JS rendering |
| ScrapingBee | $150+ | Credit multipliers apply |
| ZenRows | $299+ | Premium proxy costs extra |
All plans include JavaScript rendering, SSL, and 99.9% uptime SLA
View Full Pricing DetailsFrequently Asked Questions
Everything you need to know about Neo Reader
Still have questions?
Our team is here to help. Get in touch and we'll respond within 24 hours.
Ready to Transform Your Web Scraping?
Join 1000+ teams building production RAG pipelines, AI applications, and content aggregators with Neo Reader. Start free today.