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
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
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 |
Production-ready features that solve real problems. No bloat, no complexity, just results.
Two-tier architecture: instant HTTP fetching for static content, smart fallback to browser rendering
No hidden costs or credit multipliers. One request = one request, regardless of complexity
Clean, structured markdown optimized for AI applications and RAG pipelines
Intelligent detection of React, Vue, Next.js, Nuxt, Angular, and Svelte applications
Enterprise-grade infrastructure with 99.9% uptime SLA and comprehensive monitoring
Apache 2.0 licensed with production-ready Docker deployment. Full source access
Built from the ground up to solve real problems that competitors ignore.
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
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 averageOne 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
$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 complexityZero-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
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 logicApache 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
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 privately Sign up for our free tier and experience the speed and simplicity.
No credit card required to get started.
See how teams are using Neo Reader in production. Ready-to-use code examples included.
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)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]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 documentsNo credit multipliers. No hidden fees. One request = one request. Choose the plan that fits your needs.
Perfect for evaluation and side projects
For individual developers and MVPs
For production applications and growing teams
For high-volume applications and data pipelines
For organizations with advanced requirements
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 DetailsEverything you need to know about Neo Reader
Our team is here to help. Get in touch and we'll respond within 24 hours.
Join 1000+ teams building production RAG pipelines, AI applications, and content aggregators with Neo Reader. Start free today.