# RFC Editor Index Scraper (`parseforge/rfc-editor-scraper`) Actor

Export RFC documents from the RFC Editor index. Query 9,000+ Internet standards by RFC number, status, stream, or title keyword. Pull title, authors, status, stream, publish date, abstract, format URLs, obsoletes, updates.

- **URL**: https://apify.com/parseforge/rfc-editor-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Education, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📜 RFC Editor Index Scraper

> 🚀 **Export the full IETF standards catalog in seconds.** Pull **9,700+ RFCs** with titles, authors, status, stream, abstracts, and obsoletes/updates relationships. No login, no manual XML parsing, no broken anchor links.

> 🕒 **Last updated:** 2026-05-22 · **📊 23 fields** per record · **📜 9,700+ RFCs** · **🌐 6 streams** · **🏷️ 8 status tiers**

The **RFC Editor Scraper** exports the canonical Internet standards index and returns **23 fields per record**, including RFC number, title, full author list, publication status, document stream, publish date, page count, abstract, DOI, keywords, obsoletes and updates relationships, errata flags, and direct links to HTML, PDF, TXT, and JSON formats. The underlying index is the authoritative catalog of every published Request for Comments since RFC 1 in 1969.

The catalog spans **9,700+ documents, six document streams (IETF, IAB, IRTF, Independent, Editorial, Legacy), and eight publication status tiers**. This Actor turns the official document index into a downloadable dataset as CSV, Excel, JSON, or XML in under five minutes. Three query modes let you pull by RFC numbers, keyword, status, or stream.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Protocol developers, network engineers, security researchers, standards bodies, technical writers, library scientists | Spec auditing, obsoletes-chain tracing, BCP discovery, citation management, internal knowledge bases, compliance checklists |

---

### 📋 What the RFC Editor Scraper does

Three retrieval workflows in a single run:

- 🎯 **Direct lookup.** Pass a list of RFC numbers like `[791, 2616, 9110]` and get those records.
- 🔎 **Keyword search.** Filter the index by title or abstract keyword (case-insensitive).
- 🏷️ **Status & stream filters.** Restrict to Internet Standards, Proposed Standards, Best Current Practices, or any of the six streams.

Each record bundles identifiers (RFC ID, number, DOI), publishing metadata (status, stream, publish date, page count), authorship, full abstract text, relationship chains (obsoletes, obsoletedBy, updates, updatedBy), keyword tags, errata flag, and download links to HTML, PDF, plain text, and JSON formats.

> 💡 **Why it matters:** the official index is split across XML files, sub-series indexes, and a website with no bulk export. Tracing which RFC obsoletes another, or finding every BCP in the IRTF stream, normally means writing parsers against undocumented XML. This Actor returns a clean structured dataset in one run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>rfcNumbers</code></td><td>array</td><td><code>[]</code></td><td>Optional list of RFC numbers to fetch directly. Takes precedence over filters.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>""</code></td><td>Keyword filter against the title (case-insensitive).</td></tr>
<tr><td><code>status</code></td><td>enum</td><td><code>""</code></td><td>One of 8 publication status tiers.</td></tr>
<tr><td><code>stream</code></td><td>enum</td><td><code>""</code></td><td>One of 6 document streams: IETF, IAB, IRTF, Independent, Editorial, Legacy.</td></tr>
</tbody>
</table>

**Example: HTTP-related standards in the IETF stream.**

```json
{
    "maxItems": 50,
    "searchQuery": "HTTP",
    "stream": "IETF"
}
````

**Example: fetch IP, HTTP, and TLS foundational specs.**

```json
{
    "rfcNumbers": [791, 9110, 8446]
}
```

> ⚠️ **Good to Know:** the obsoletes/updates fields reflect the catalog at fetch time. If you build a long-running RFC tracker, schedule a daily refresh so newly published documents and re-classified entries flow through. Status names follow the canonical RFC Editor vocabulary, not informal shorthand.

***

### 📊 Output

Each RFC record contains **23 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `rfcId` | string | `"RFC9110"` |
| 🔢 `number` | number | `9110` |
| 📝 `title` | string | `"HTTP Semantics"` |
| 👥 `authors` | array | `["R. Fielding, Ed.", "M. Nottingham, Ed.", "J. Reschke, Ed."]` |
| 🏷️ `status` | string | `"INTERNET STANDARD"` |
| 🌐 `stream` | string | `"IETF"` |
| 📅 `publishDate` | string | `"June 2022"` |
| 📄 `pages` | number | `203` |
| 📖 `abstract` | string | `"The Hypertext Transfer Protocol (HTTP) is a stateless..."` |
| 🔖 `doi` | string | `"10.17487/RFC9110"` |
| 🏷️ `keywords` | array | `["http", "semantics", "messaging"]` |
| 🔁 `obsoletes` | array | `[2818, 7230, 7231, 7232, 7233, 7235, 7538, 7615, 7694]` |
| 🚫 `obsoletedBy` | array | `[]` |
| 📝 `updates` | array | `[3864]` |
| 🔄 `updatedBy` | array | `[]` |
| 🔗 `seeAlso` | array | `["STD97"]` |
| 📦 `formats` | array | `["ASCII", "HTML", "PDF", "XML"]` |
| 🌐 `htmlUrl` | string | `"https://www.rfc-editor.org/rfc/rfc9110.html"` |
| 📕 `pdfUrl` | string | `"https://www.rfc-editor.org/rfc/rfc9110.pdf"` |
| 📃 `txtUrl` | string | `"https://www.rfc-editor.org/rfc/rfc9110.txt"` |
| 🧾 `jsonUrl` | string | `"https://www.rfc-editor.org/rfc/rfc9110.json"` |
| ⚠️ `errata` | boolean | `true` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |
| ⚠️ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>📜 Modern Internet Standard: RFC 9110 (HTTP Semantics)</strong></summary>

```json
{
    "rfcId": "RFC9110",
    "number": 9110,
    "title": "HTTP Semantics",
    "authors": ["R. Fielding, Ed.", "M. Nottingham, Ed.", "J. Reschke, Ed."],
    "status": "INTERNET STANDARD",
    "stream": "IETF",
    "publishDate": "June 2022",
    "pages": 203,
    "abstract": "The Hypertext Transfer Protocol (HTTP) is a stateless application-level request/response protocol that uses extensible semantics and self-descriptive messages for flexible interaction with network-based hypertext information systems.",
    "doi": "10.17487/RFC9110",
    "keywords": ["http", "semantics", "messaging"],
    "obsoletes": [2818, 7230, 7231, 7232, 7233, 7235, 7538, 7615, 7694],
    "obsoletedBy": [],
    "updates": [3864],
    "updatedBy": [],
    "seeAlso": ["STD97"],
    "formats": ["ASCII", "HTML", "PDF", "XML"],
    "htmlUrl": "https://www.rfc-editor.org/rfc/rfc9110.html",
    "pdfUrl": "https://www.rfc-editor.org/rfc/rfc9110.pdf",
    "txtUrl": "https://www.rfc-editor.org/rfc/rfc9110.txt",
    "jsonUrl": "https://www.rfc-editor.org/rfc/rfc9110.json",
    "errata": true,
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏛️ Foundational standard: RFC 791 (Internet Protocol)</strong></summary>

```json
{
    "rfcId": "RFC0791",
    "number": 791,
    "title": "Internet Protocol",
    "authors": ["J. Postel"],
    "status": "INTERNET STANDARD",
    "stream": "Legacy",
    "publishDate": "September 1981",
    "pages": 51,
    "abstract": "Specifies the Internet Protocol (IP), a connectionless datagram protocol providing host addressing, routing, and packet fragmentation across heterogeneous networks.",
    "doi": "10.17487/RFC0791",
    "keywords": ["ip", "internet protocol", "datagram"],
    "obsoletes": [760],
    "obsoletedBy": [],
    "updates": [],
    "updatedBy": [1349, 2474, 6864],
    "seeAlso": ["STD5"],
    "formats": ["ASCII", "HTML", "PDF"],
    "htmlUrl": "https://www.rfc-editor.org/rfc/rfc791.html",
    "pdfUrl": "https://www.rfc-editor.org/rfc/rfc791.pdf",
    "txtUrl": "https://www.rfc-editor.org/rfc/rfc791.txt",
    "jsonUrl": "https://www.rfc-editor.org/rfc/rfc791.json",
    "errata": true,
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🔬 Research stream: RFC 9000 (QUIC Transport)</strong></summary>

```json
{
    "rfcId": "RFC9000",
    "number": 9000,
    "title": "QUIC: A UDP-Based Multiplexed and Secure Transport",
    "authors": ["J. Iyengar, Ed.", "M. Thomson, Ed."],
    "status": "PROPOSED STANDARD",
    "stream": "IETF",
    "publishDate": "May 2021",
    "pages": 151,
    "abstract": "This document defines the core of the QUIC transport protocol. QUIC provides applications with flow-controlled streams for structured communication, low-latency connection establishment, and network path migration.",
    "doi": "10.17487/RFC9000",
    "keywords": ["quic", "transport", "udp"],
    "obsoletes": [],
    "obsoletedBy": [],
    "updates": [],
    "updatedBy": [9369],
    "seeAlso": [],
    "formats": ["ASCII", "HTML", "PDF", "XML"],
    "htmlUrl": "https://www.rfc-editor.org/rfc/rfc9000.html",
    "pdfUrl": "https://www.rfc-editor.org/rfc/rfc9000.pdf",
    "txtUrl": "https://www.rfc-editor.org/rfc/rfc9000.txt",
    "jsonUrl": "https://www.rfc-editor.org/rfc/rfc9000.json",
    "errata": true,
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📜 | **Full catalog.** Every RFC published since 1969, from RFC 1 through the latest release, in one queryable dataset. |
| 🔁 | **Relationship chains.** Obsoletes, obsoletedBy, updates, and updatedBy fields ready for graph traversal. |
| 🏷️ | **Stream and status filters.** Slice the index by IETF, IRTF, IAB, Independent, Editorial, or Legacy streams and by 8 status tiers. |
| 📦 | **All formats linked.** Direct download URLs for HTML, PDF, TXT, and JSON renderings of each document. |
| 🔖 | **DOI included.** Citable identifiers for academic papers and bibliography managers. |
| 🔁 | **Always fresh.** Every run reads the live index so newly published RFCs flow through automatically. |
| 🚫 | **No authentication.** Public standards catalog. No login, no token. |

> 📊 RFCs are the operating system of the Internet. Knowing which spec obsoletes which is the difference between a working implementation and a security advisory.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ RFC Editor Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **9,700+** RFCs | **Live per run** | numbers, keyword, status, stream | ⚡ 2 min |
| Raw XML index parsing | Free | Full | Live | None | 🐢 Days |
| GitHub mirror of rfc-editor-data | Free | Full but stale | Weekly | None | 🕒 Variable |
| Commercial standards database | $500+/year | RFCs + ISO + ITU | Daily | Many | ⏳ Hours |

Pick this Actor when you want clean structured RFC records, relationship chains, and zero parsing work.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the RFC Editor Index Scraper page on the Apify Store.
3. 🎯 **Set input.** Pass RFC numbers directly, or filter by keyword, status, and stream.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your dataset.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛠️ Protocol Engineering

- Trace obsoletes chains before shipping a new implementation
- Discover every BCP relevant to a given technology
- Track newly published RFCs against an internal feature matrix
- Build a private knowledge base of standards your team relies on

</td>
<td width="50%" valign="top">

#### 🔐 Security & Compliance

- Cross-reference CVE advisories with the underlying RFC text
- Audit deprecated specs that are still in production
- Build TLS, OAuth, and DNS hardening checklists from primary sources
- Map vendor disclosures back to the affected standards

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Research & Analytics

- Quantify standards evolution by year and stream
- Build citation networks across the RFC corpus
- Compute author productivity and co-authorship graphs
- Track how long PROPOSED takes to reach INTERNET STANDARD

</td>
<td width="50%" valign="top">

#### 📚 Technical Writing & Education

- Generate teaching materials with verified spec quotes
- Build a syllabus around foundational networking RFCs
- Auto-fill bibliography entries with DOI and authors
- Power a doc-search experience over the RFC corpus

</td>
</tr>
</table>

***

### 🔌 Automating RFC Editor Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily or weekly refreshes keep an internal RFC mirror up to date without manual intervention.

***

### 🌟 Beyond business use cases

Standards data powers more than commercial workflows. The same records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Citation networks across the IETF corpus
- Standards-evolution studies for computer science theses
- Reproducible bibliographies with cited dataset pulls
- Open-knowledge contributions to networking education

</td>
<td width="50%">

#### 🎨 Personal and creative

- Build a personal RFC reading list
- Hobby projects on protocol visualization
- Side projects exploring obsoletes graphs
- Curated newsletters on newly published standards

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Public-interest tooling around open Internet standards
- Civic transparency about protocol governance
- Investigative journalism on protocol vulnerabilities
- Volunteer documentation projects

</td>
<td width="50%">

#### 🧪 Experimentation

- Train spec-summarization or QA models
- Validate documentation hypotheses against real RFC text
- Prototype agent pipelines that answer spec questions
- Seed graph databases with relationship chains

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20RFC%20Editor%20Index%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20RFC%20Editor%20Index%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20RFC%20Editor%20Index%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20RFC%20Editor%20Index%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pass RFC numbers directly or set keyword, status, and stream filters. The Actor reads the live RFC index, normalizes each entry, and emits one record per RFC. No browser automation, no captchas, no setup.

#### 📏 How accurate are the relationship chains?

The obsoletes, obsoletedBy, updates, and updatedBy lists come straight from the official index. When a new RFC re-classifies an older one, the change flows through on your next run.

#### 🔁 How often is the catalog refreshed?

The RFC Editor publishes updates as documents move through the process. Every run of this Actor fetches the latest index so your dataset reflects the current state.

#### 🌐 What streams are supported?

All six: IETF, IAB, IRTF, Independent, Editorial, and Legacy. Filter to one stream or pull the whole catalog.

#### 📦 Do I get download links for each format?

Yes. Every record includes URLs for the HTML, PDF, plain text, and JSON renderings of the document.

#### 🔖 Can I use the DOI to cite RFCs in academic papers?

Yes. The DOI field gives you a citable identifier that resolves directly to the canonical RFC page and works with reference managers like Zotero and Mendeley.

#### 💼 Can I use this data commercially?

Yes. RFCs are public-domain or BCP-licensed depending on the stream and era. You are responsible for complying with any specific document's IPR statement.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small pulls (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### ⚠️ Does it flag RFCs that have errata?

Yes. The `errata` boolean is set when the document has at least one reported erratum. Cross-check the RFC Editor errata page for the full report list.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

RFC Editor Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe RFC records into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Update an internal standards mirror, or alert your team in Slack when a watched RFC is obsoleted.

***

### 🔗 Recommended Actors

- [**🐙 GitHub Status History Scraper**](https://apify.com/parseforge/github-status-history-scraper) - GitHub uptime, incidents, and component history
- [**📚 arXiv Scraper**](https://apify.com/parseforge/arxiv-scraper) - Preprint papers across physics, math, and CS
- [**🔬 ClinicalTrials.gov Scraper**](https://apify.com/parseforge/clinicaltrials-gov-scraper) - Registered medical trials with outcomes and sponsors
- [**📊 OSF Scraper**](https://apify.com/parseforge/osf-scraper) - Open Science Framework preregistrations and projects
- [**🌐 IP Geolocation Scraper**](https://apify.com/parseforge/ipapi-geolocation-scraper) - Bulk IPv4/IPv6 geolocation lookups

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the RFC Editor, the IETF, or any of its contributors. All trademarks mentioned are the property of their respective owners. Only publicly available open standards data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `rfcNumbers` (type: `array`):

Optional list of RFC numbers to fetch directly (e.g. \[791, 2616, 9110]). When provided, takes precedence over filters.

## `searchQuery` (type: `string`):

Optional. Filter RFCs whose title contains this keyword (case-insensitive).

## `status` (type: `string`):

Filter by RFC publication status.

## `stream` (type: `string`):

Filter by document stream.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/rfc-editor-scraper").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/rfc-editor-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/rfc-editor-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/rfc-editor-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RFC Editor Index Scraper",
        "description": "Export RFC documents from the RFC Editor index. Query 9,000+ Internet standards by RFC number, status, stream, or title keyword. Pull title, authors, status, stream, publish date, abstract, format URLs, obsoletes, updates.",
        "version": "1.0",
        "x-build-id": "4YrNCOK3bQM1oSw9x"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~rfc-editor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-rfc-editor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~rfc-editor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-rfc-editor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~rfc-editor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-rfc-editor-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "rfcNumbers": {
                        "title": "RFC Numbers",
                        "type": "array",
                        "description": "Optional list of RFC numbers to fetch directly (e.g. [791, 2616, 9110]). When provided, takes precedence over filters.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 99999
                        }
                    },
                    "searchQuery": {
                        "title": "Title / Abstract Keyword",
                        "type": "string",
                        "description": "Optional. Filter RFCs whose title contains this keyword (case-insensitive)."
                    },
                    "status": {
                        "title": "Publication Status",
                        "enum": [
                            "INTERNET STANDARD",
                            "PROPOSED STANDARD",
                            "DRAFT STANDARD",
                            "INFORMATIONAL",
                            "EXPERIMENTAL",
                            "HISTORIC",
                            "BEST CURRENT PRACTICE",
                            "UNKNOWN"
                        ],
                        "type": "string",
                        "description": "Filter by RFC publication status."
                    },
                    "stream": {
                        "title": "Stream",
                        "enum": [
                            "IETF",
                            "IAB",
                            "IRTF",
                            "INDEPENDENT",
                            "Editorial",
                            "Legacy"
                        ],
                        "type": "string",
                        "description": "Filter by document stream."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
