# Article Extractor API — Title, Author, Date & Full Text (`highbrow_fame/article-extractor-api`) Actor

Extracts the article from any news or blog URL: title, author, published date, full text, Markdown, lead image and language. Works on paywall-free pages. Unofficial Article Extractor API.

- **URL**: https://apify.com/highbrow_fame/article-extractor-api.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** AI, Agents, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 articles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Article Extractor API — Title, Author, Date & Full Text

Give it news or blog links, get back one clean record per article: title, author, publish date, lead image, language, site name, the full text and the same text as Markdown. It works on any public, paywall-free page in any language — the main content is found with the Readability algorithm that powers reader mode in Firefox, so navigation, footers, cookie banners and "related articles" boxes are left out.

**Try it in 1 minute:** press **Start** with the prefilled input (a Wikipedia article and the Apify blog). In a few seconds you get two records with `title`, `author`, `publishedAt`, `text`, `markdown`, `wordCount` and `readingTimeMinutes`. Price: $0.50 per 1,000 articles; pages that give no article are free.

**Use it to:**

- 📰 **Feed news into an LLM** — clean Markdown with headings, lists, links and tables instead of raw HTML saves tokens and improves answers.
- 🔎 **Monitor coverage** — pair it with a news search or RSS Actor and store the full text of every article that mentions your brand.
- 🧠 **Build a RAG corpus** — one record per URL with stable field names, ready for your vector database.
- 📊 **Analyse content** — word counts, reading time, publish dates and authors for thousands of URLs in one run.
- 🤖 **Give an agent a "read this page" tool** — call it from the Apify MCP server or the API with a list of links.

### How it works

1. Each URL is fetched over plain HTTP with browser-like headers, redirects followed, a 30-second timeout and up to three attempts (a network error is retried through the Apify proxy).
2. `robots.txt` is read once per site; pages it disallows are skipped with a free `ROBOTS_DISALLOWED` record (you can turn this off for sites you have permission to read).
3. The page's metadata is collected from Open Graph, Twitter cards, JSON-LD and standard meta tags; the main article is isolated with Mozilla Readability and converted to Markdown (tables, lists, links and images kept, addresses made absolute).
4. E-mail addresses and phone numbers in the article text are removed. Everything is delivered as one record with a `status`.

No browser is started, so a run is fast and cheap. Pages that only render in JavaScript come back thin (`readable: false`, few words) — use **Minimum words** to turn them into free `NO_CONTENT` records.

### Input

| Field | Meaning | Default |
|---|---|---|
| `urls` | Article or page links, one per line | *(required)* |
| `outputFormat` | `both`, `markdown` or `text` | `both` |
| `respectRobotsTxt` | Skip pages the site's robots.txt disallows | `true` |
| `minWords` | Below this word count a page is a free `NO_CONTENT` record | `0` |
| `includeHtml` | Also deliver the cleaned article HTML | `false` |
| `includeLinks` | Also deliver every link on the page (up to 500) | `false` |
| `maxTextLength` | Cut text and Markdown after N characters | `0` (no limit) |
| `maxConcurrency` | Pages read in parallel | `5` |
| `proxyConfiguration` | Proxy for retries after a network error | Apify proxy |

### Output

| Field | What it is |
|---|---|
| `url`, `canonicalUrl` | the final address after redirects, and the canonical one the page declares |
| `title`, `description`, `siteName`, `language` | from Open Graph / meta tags; language as the page declares it (`en`, `de`, …) |
| `author`, `publishedAt` | byline and ISO 8601 publish time from the page's metadata |
| `image` | lead image (absolute address) |
| `text`, `markdown` | the article as plain text and as Markdown (title as first heading) |
| `wordCount`, `readingTimeMinutes`, `headings` | size of the article and its heading outline |
| `readable` | `true` when a main article was found; `false` when the whole body minus chrome was used |
| `linksCount`, `links` | number of unique links on the page, and the links themselves with `includeLinks` |
| `contentHtml` | cleaned article HTML, with `includeHtml` |
| `input`, `status`, `error`, `httpStatus`, `scrapedAt` | what you gave, `OK` or a reason code, and when |

Statuses: `OK` (charged) — `NOT_FOUND`, `NOT_HTML`, `NO_CONTENT`, `ROBOTS_DISALLOWED`, `TOO_LARGE`, `INVALID_INPUT`, `FAILED` (free, with `error` saying why).

#### Example

```json
{
  "input": "https://journal.example.com/articles/web-scraping",
  "url": "https://journal.example.com/articles/web-scraping",
  "title": "Web Scraping Explained",
  "author": "Jane Example",
  "publishedAt": "2026-03-04T09:15:00.000Z",
  "siteName": "Example Journal",
  "description": "What web scraping is and how it works.",
  "language": "en",
  "canonicalUrl": "https://journal.example.com/articles/web-scraping",
  "image": "https://journal.example.com/img/lead.jpg",
  "text": "Web scraping is the practice of collecting data from websites with a program instead of a browser. …",
  "markdown": "# Web Scraping Explained\n\nWeb scraping is the practice of collecting data from websites …\n\n## Common steps\n\n- Fetch the page\n- Parse the HTML\n- Extract and store the fields\n\n| Tool | Language |\n| --- | --- |\n| Cheerio | JavaScript |",
  "wordCount": 168,
  "readingTimeMinutes": 1,
  "readable": true,
  "headings": [{ "level": 2, "text": "Common steps" }, { "level": 2, "text": "Tools compared" }],
  "linksCount": 6,
  "httpStatus": 200,
  "status": "OK",
  "scrapedAt": "2026-10-19T12:00:00.000Z"
}
```

### Pricing

You pay **per article delivered** ($0.50 per 1,000). Dead links, non-HTML files, pages without an article and pages blocked by robots.txt are free. Set a **Maximum charge** on the run to cap the cost; the run stops cleanly when it is reached and tells you how many links were left.

### FAQ

**Is this an official API?** No, it's an unofficial API built on public pages.

**Does it work behind paywalls or logins?** No. It reads what a logged-out visitor can read, and it does not bypass paywalls, captchas or bot walls.

**Why is `author` or `publishedAt` empty?** The page does not state them in its metadata (Open Graph, JSON-LD, `<time>` or meta tags). Fields are never guessed.

**Why did a page come back with a few words and `readable: false`?** The page builds its content in JavaScript, so a plain HTTP fetch sees only the shell. A headless-browser version is on the roadmap; for now use **Minimum words** to make such pages free `NO_CONTENT` records.

**Can I pass thousands of URLs?** Yes — raise **Parallel pages** to 10–20 for big batches. Each URL is one record; the run's status message tells you how many were delivered.

**Like it?** A short review on the Store page helps other people find this Actor. Something missing or broken? Tell us on the Issues tab — we read every one.

### Related Actors

- [RSS & Atom Feed Reader](https://apify.com/highbrow_fame/rss-feed-reader) — any feed or website as one clean list
- [Substack Scraper](https://apify.com/highbrow_fame/substack-posts) — posts and full text from Substack
- [Hacker News Scraper](https://apify.com/highbrow_fame/hacker-news-stories) — stories, comments and search
- [URL to Markdown API](https://apify.com/highbrow_fame/url-to-markdown-api) — clean Markdown from any URL for LLMs
- [News Search API](https://apify.com/highbrow_fame/news-search-api) — news by keyword with date range and full text

# Actor input Schema

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

Links to news articles, blog posts or any other web pages, one per line. Each becomes one record with title, author, date, full text and Markdown.

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

What the article body is delivered as: Markdown, plain text, or both.

## `respectRobotsTxt` (type: `boolean`):

Skip pages the site's robots.txt disallows (a free ROBOTS_DISALLOWED record). Turn off only for sites you have permission to read.

## `minWords` (type: `integer`):

Pages whose extracted text has fewer words than this come back as a free NO_CONTENT record instead of an article. 0: deliver whatever text there is.

## `includeHtml` (type: `boolean`):

Also deliver the cleaned article HTML (contentHtml).

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

Also deliver every link on the page (up to 500) as links\[] with href and anchor text.

## `maxTextLength` (type: `integer`):

Cut text and Markdown after this many characters (textTruncated: true). 0: no limit.

## `maxConcurrency` (type: `integer`):

How many pages to read at the same time.

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

Used only to try again after a network error: the first try goes out directly.

## Actor input object example

```json
{
  "urls": [
    "https://en.wikipedia.org/wiki/Web_scraping",
    "https://blog.apify.com/"
  ],
  "outputFormat": "both",
  "respectRobotsTxt": true,
  "minWords": 0,
  "includeHtml": false,
  "includeLinks": false,
  "maxTextLength": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Every result as a JSON record, with a status for each input.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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 = {
    "urls": [
        "https://en.wikipedia.org/wiki/Web_scraping",
        "https://blog.apify.com/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/article-extractor-api").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 = {
    "urls": [
        "https://en.wikipedia.org/wiki/Web_scraping",
        "https://blog.apify.com/",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/article-extractor-api").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 '{
  "urls": [
    "https://en.wikipedia.org/wiki/Web_scraping",
    "https://blog.apify.com/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call highbrow_fame/article-extractor-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,highbrow_fame/article-extractor-api"
        }
    }
}
```

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/KHhSyMH1aC9eWAobJ/builds/vJVWSaf82UPaSsYwO/openapi.json