# Hyper Reader (`ai_solutionist/hyper-reader`) Actor

High-fidelity web extraction for AI agents. Clean Markdown optimized for Claude, GPT-4 & Gemini. 3-level stealth, Vision screenshots, Deep Read link following. Standby Mode for 1-second responses.

- **URL**: https://apify.com/ai_solutionist/hyper-reader.md
- **Developed by:** [Jason Pellerin](https://apify.com/ai_solutionist) (community)
- **Categories:** AI, Agents, Developer tools
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 14 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / actor start

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 🚀 Hyper-Reader: The Agentic Web Bridge

**Stop feeding your LLM messy HTML.** Hyper-Reader delivers high-fidelity, ad-free content optimized for Claude, GPT-4, and Gemini with sub-second response times.

Built by [Jason Pellerin AI Solutionist](https://jasonpellerin.com) — the same engineering behind enterprise AI voice agents and automation systems.

***

### Why Hyper-Reader?

| Problem | Hyper-Reader Solution |
|---------|----------------------|
| Raw HTML is noisy and token-expensive | Clean Markdown with smart content extraction |
| Anti-bot systems block your scrapers | 3-level stealth with fingerprint randomization |
| Different LLMs need different formats | Agent-optimized presets (Claude, GPT, Gemini) |
| Cold starts kill your agent's speed | Standby Mode for 1-second responses |
| Single pages lack context | Deep Read follows links for comprehensive data |

***

### 🎯 Agent Presets

Choose your target LLM for optimized output:

#### Claude (Default)

```xml
<document>
  <metadata>
    <title>Article Title</title>
    <author>John Doe</author>
    <published>2024-01-15</published>
    <source>https://example.com/article</source>
  </metadata>
  <content>
    # Main Heading
    
    Clean, structured Markdown content...
  </content>
</document>
```

#### GPT-4

```markdown
## Article Title

> Source: https://example.com/article
> Author: John Doe | Published: 2024-01-15

Content with inline citations [1] and reference links...

---
### References
[1]: https://example.com/article "Original Source"
```

#### Gemini

Compact Markdown optimized for Gemini's context window with aggressive token optimization.

#### SearchGPT

Web-search optimized format with prominent source attribution and fact-checkable structure.

***

### ⚡ Standby Mode

Enable **Standby Mode** for instant API responses. Your Actor stays warm and ready:

```bash
## Response time: ~1 second vs 30+ seconds cold start
curl -X POST "https://YOUR_ACTOR_STANDBY_URL/extract" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com", "agentPreset": "Claude"}'
```

Perfect for:

- Real-time AI assistants
- MCP tool integrations
- Cursor/Claude Desktop extensions
- n8n and automation workflows

***

### 🛡️ Stealth Levels

#### Level 1: Basic

- Standard datacenter proxies
- Basic header rotation
- **Best for:** Blogs, news sites, documentation

#### Level 2: Standard (Default)

- Residential proxy rotation
- Browser fingerprint randomization
- WebGL/Canvas spoofing
- **Best for:** E-commerce, social media, most protected sites

#### Level 3: Elite

- Premium residential proxies
- Human-like mouse movements
- Session persistence
- Full anti-fingerprinting
- **Best for:** LinkedIn, Amazon, heavily protected sites

***

### 🔍 Deep Read

Gather comprehensive context by following internal links:

```json
{
  "url": "https://example.com/product",
  "deepReadDepth": 2,
  "deepReadMaxPages": 10
}
```

Returns aggregated content from the main page plus related pages (About, FAQ, Reviews, etc.) in a single, structured document.

***

### 📸 Vision Screenshots

Capture page screenshots for Vision model analysis:

```json
{
  "url": "https://example.com",
  "useVision": true
}
```

Returns a 1280x720 optimized PNG stored in Apify's Key-Value Store, perfect for GPT-4V, Claude Vision, or Gemini Pro Vision.

***

### Input Schema

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `url` | string | - | Target URL to extract |
| `urls` | array | - | Multiple URLs (batch mode) |
| `agentPreset` | enum | `Claude` | Output optimization target |
| `outputFormat` | enum | `markdown` | `markdown`, `json`, or `html_cleaned` |
| `stealthLevel` | integer | `2` | 1-3 (Basic to Elite) |
| `useVision` | boolean | `false` | Capture screenshot |
| `deepReadDepth` | integer | `0` | Link following depth (0-3) |
| `waitForSelector` | string | - | CSS selector to wait for |
| `excludeSelectors` | string | - | Elements to remove (comma-separated) |
| `maxContentLength` | integer | `0` | Truncate output (0 = unlimited) |

***

### Output Structure

```json
{
  "url": "https://example.com/article",
  "finalUrl": "https://example.com/article/",
  "format": "markdown",
  "agentPreset": "Claude",
  "content": "# Article Title\n\nClean markdown content...",
  "metadata": {
    "title": "Article Title",
    "author": "John Doe",
    "publishDate": "2024-01-15",
    "description": "Article description...",
    "wordCount": 1500,
    "readingTimeMinutes": 7
  },
  "screenshotUrl": "https://api.apify.com/v2/key-value-stores/.../screenshot.png",
  "processingTimeMs": 2340,
  "charCount": 8500,
  "extractedAt": "2024-01-15T10:30:00.000Z"
}
```

***

### Use Cases

#### 🤖 AI Agent Research

```javascript
// Feed clean web data to your AI agent
const result = await client.call('ai_solutionist/hyper-reader', {
  url: 'https://docs.example.com/api',
  agentPreset: 'Claude'
});
// result.content is ready for your LLM context
```

#### 📊 Competitive Intelligence

```javascript
// Extract competitor pages with deep context
const result = await client.call('ai_solutionist/hyper-reader', {
  url: 'https://competitor.com/pricing',
  deepReadDepth: 2,
  agentPreset: 'GPT-4'
});
```

#### 🔗 MCP Tool Integration

```json
{
  "mcpServers": {
    "hyper-reader": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-apify"],
      "env": {
        "APIFY_TOKEN": "your_token",
        "ACTOR_ID": "ai_solutionist/hyper-reader"
      }
    }
  }
}
```

#### 📰 News Aggregation

```javascript
// Batch extract multiple articles
const result = await client.call('ai_solutionist/hyper-reader', {
  urls: [
    'https://news.site/article1',
    'https://news.site/article2',
    'https://news.site/article3'
  ],
  agentPreset: 'Gemini',
  outputFormat: 'json'
});
```

***

### Pricing

| Tier | Price | Features |
|------|-------|----------|
| **Standard** | $1 / 1,000 pages | Full extraction, all presets, Stealth 1-2 |
| **Elite** | $5 / 1,000 pages | Stealth Level 3, residential proxies |
| **Pro Monthly** | $49 / month | Standby Mode, unlimited standard proxy |

***

### Support

- **Documentation:** [jasonpellerin.com/hyper-reader](https://jasonpellerin.com/hyper-reader)
- **Issues:** Open an issue on GitHub
- **Enterprise:** [Contact Jason Pellerin](https://jasonpellerin.com/contact)

***

**Built with 🔥 by Jason Pellerin AI Solutionist**

*Transforming web chaos into agent-ready intelligence.*

## Build timestamp: Sun Jan 18 16:29:53 MST 2026

# Actor input Schema

## `url` (type: `string`):

The web page URL to extract content from.

## `urls` (type: `array`):

Extract from multiple URLs at once (one per line). Takes precedence over single URL.

## `agentPreset` (type: `string`):

Optimize output format for your target AI agent.

## `outputFormat` (type: `string`):

The format of the extracted content.

## `stealthLevel` (type: `integer`):

Anti-bot protection level. 1=Basic, 2=Standard, 3=Elite (heavy protection).

## `useVision` (type: `boolean`):

Capture a 1280x720 screenshot for Vision model analysis.

## `deepReadDepth` (type: `integer`):

Follow internal links to gather more context. 0 = single page only.

## `deepReadMaxPages` (type: `integer`):

Maximum number of pages to extract when using Deep Read.

## `waitForSelector` (type: `string`):

CSS selector to wait for before extracting (for JS-heavy pages).

## `waitForTimeout` (type: `integer`):

Maximum time to wait for page load.

## `excludeSelectors` (type: `string`):

CSS selectors to remove before extraction (comma-separated).

## `includeMetadata` (type: `boolean`):

Include title, author, date, and other metadata in output.

## `includeLinks` (type: `boolean`):

Keep hyperlinks in Markdown output.

## `includeImages` (type: `boolean`):

Include image URLs in Markdown output.

## `maxContentLength` (type: `integer`):

Truncate content if it exceeds this character count. 0 = no limit.

## `proxyConfiguration` (type: `object`):

Configure proxy for requests. Leave empty to use Apify's automatic proxy.

## Actor input object example

```json
{
  "url": "https://example.com",
  "agentPreset": "Claude",
  "outputFormat": "markdown",
  "stealthLevel": 2,
  "useVision": false,
  "deepReadDepth": 0,
  "deepReadMaxPages": 10,
  "waitForTimeout": 30000,
  "excludeSelectors": "nav, footer, .ads, .sidebar, #cookie-banner",
  "includeMetadata": true,
  "includeLinks": true,
  "includeImages": false,
  "maxContentLength": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "url": "https://example.com",
    "excludeSelectors": "nav, footer, .ads, .sidebar, #cookie-banner"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ai_solutionist/hyper-reader").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "url": "https://example.com",
    "excludeSelectors": "nav, footer, .ads, .sidebar, #cookie-banner",
}

# Run the Actor and wait for it to finish
run = client.actor("ai_solutionist/hyper-reader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "url": "https://example.com",
  "excludeSelectors": "nav, footer, .ads, .sidebar, #cookie-banner"
}' |
apify call ai_solutionist/hyper-reader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ai_solutionist/hyper-reader"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tfYpgVLv8WRDglMXf/builds/859xQeNCSHRLM85ZK/openapi.json