# IETF Datatracker Documents Scraper (`parseforge/ietf-datatracker-drafts-scraper`) Actor

Scrapes IETF Datatracker documents by type, working group, state, and date window. Returns each document as a flat row with title, authors, group, state, and update date.

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

## Pricing

from $14.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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### IETF Datatracker Documents Scraper

**Scrape IETF Datatracker drafts, RFCs, charters, and meeting documents by type, working group, state, or date window.** Every document comes with its title, authors, group, state, and update date. No login or API key. Export to CSV, JSON, Excel, or XML.

The IETF Datatracker web interface is built for browsing one document at a time, not for bulk analysis. This Actor reads the public document feeds directly, filtered by document type, working group acronym, state, or update date, and returns each match in one fixed schema.

| Who uses it | What they scrape IETF Datatracker for |
|---|---|
| Standards engineers | Which drafts a working group is actively revising |
| Protocol researchers | How a specification changed across draft versions |
| Compliance analysts | Which RFCs and drafts affect a product area |
| Technical writers | Source material for documentation and tutorials |
| Open source maintainers | Upstream standards that a project must implement |

### What it does

This Actor collects IETF Datatracker documents by type, working group, state, and date window, and returns each one as a flat row.

- 📄 **Document types:** Internet Drafts, RFCs, charters, BoF requests, agendas, minutes, slides, reviews, liaison statements, and more.
- 🔍 **Working group filter:** Limit results to one IETF working group acronym such as httpbis, tls, or quic.
- 📅 **Date window:** Pull only documents updated on or after a start date, on or before an end date, or both.
- 🏷️ **State filter:** Active, expired, published as RFC, replaced, or withdrawn by author or IETF.
- 📦 **Flat rows:** Every document is returned as one row with the same fields, ready for spreadsheets or databases.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with IETF Datatracker data

**📈 Track working group activity.**

A standards engineer pulls all active drafts for the quic working group each week to see which topics are moving and which are stalled.

**🔎 Audit specification changes.**

A compliance analyst scrapes drafts updated in the last quarter for a product area, then diffs titles and states to find new requirements.

**📚 Build a standards library.**

A technical writer exports all RFCs and charters for a set of working groups into a searchable internal knowledge base.

**🧪 Monitor protocol evolution.**

A researcher collects every version of a draft over two years to study how a protocol design changed before publication.

**🛠️ Feed an implementation tracker.**

An open source maintainer scrapes active drafts for the httpbis group and imports them into a project tracker as implementation tasks.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Reads the public Datatracker feeds directly, no registration or OAuth. |
| **One fixed schema** | Every document type returns the same flat row shape. |
| **Bulk export** | CSV, JSON, Excel, or XML for downstream analysis. |
| **Date and state filters** | Only documents that changed in your window or match a state. |

### How it compares

This Actor focuses on bulk document collection from IETF Datatracker, while Technical Standards Revision Monitor is built for change monitoring across IETF and W3C standards.

| Feature | ParseForge | Technical Standards Revision Monitor |
|---|---|---|
| Bulk document collection | Yes | Not listed |
| Filter by working group acronym | Yes | Not listed |
| Filter by document state | Yes | Not listed |
| Filter by update date window | Yes | Not listed |
| Export to CSV, JSON, Excel, XML | Yes | Not listed |
| Change monitoring with baselines | Not listed | Yes |

### Configure the run

Drive the Actor from document type, working group acronym, state, and update date window, alone or together, and filters run as each document is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "type": "draft"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "type": "draft"
}
```

### Pricing

Pay-per-result: **$0.01867 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.87 |
| 1,000 results | $18.67 |
| 10,000 results | $186.70 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [IETF Datatracker Documents Scraper](https://apify.com/parseforge/ietf-datatracker-drafts-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to IETF Datatracker through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/ietf-datatracker-drafts-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your filters. A working group acronym that does not exist, a state that does not match the document type, or a date window with no updates will return an empty dataset. Try clearing one filter at a time.

**Why did I only get 10 items?**

Free users are limited to 10 items as a preview. Upgrade to a paid plan and set the maximum drafts field to a higher number to collect more.

**Why are my date filters not working?**

Use the YYYY-MM-DD format exactly, for example 2024-01-31. If the date is invalid or the window is reversed, the Actor may ignore the filter or return no results.

**Why do I see documents from other working groups?**

The working group filter matches the exact acronym you enter. If you leave it blank, all groups are returned. Check for typos or extra spaces in the acronym.

**Can I get the full text of a draft?**

This Actor returns document metadata only. To fetch the full text, use the document URL from the result and download it separately, or pair this Actor with a URL scraper.

### FAQ

| Question | Answer |
|---|---|
| Do I need an IETF Datatracker account or API key? | No. The Actor reads the public Datatracker document feeds directly, so no login, registration, or API key is required. |
| Which document types can I scrape? | Internet Drafts, RFCs, charters, BoF requests, meeting agendas, meeting minutes, slides, conflict reviews, status changes, reviews, shepherd writeups, liaison statements, BCPs, and FYIs. |
| Can I filter by working group? | Yes. Set the working group acronym field to a value like httpbis, tls, or quic to return only documents from that group. |
| Can I filter by document state? | Yes. Choose active, expired, published as RFC, replaced, author withdrew, or IETF withdrew. Leave the field blank to return all states. |
| Can I filter by update date? | Yes. Set a start date, an end date, or both. Only documents updated inside that window are returned. |
| What is the maximum number of documents per run? | Free users are limited to 10 items as a preview. Paid users can set the maximum up to 1,000,000 documents. |
| What output formats are supported? | The Actor exports to CSV, JSON, Excel, and XML, so you can load the results into spreadsheets, databases, or analysis tools. |
| Does the Actor return the full document text? | The Actor returns document metadata such as title, authors, group, state, and update date. Full document text is not included in the flat row. |
| Can I scrape multiple document types in one run? | Each run uses one document type. To collect multiple types, run the Actor once per type or use multiple runs. |
| Is the data live? | Yes. The Actor reads the current public Datatracker feeds at the time of the run, so results reflect the latest published state. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by IETF Trust. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

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

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

IETF document type to enumerate.

## `state` (type: `string`):

Filter drafts by state slug (e.g. active, expired, rfc, repl). Leave blank for all.

## `groupAcronym` (type: `string`):

Filter to one IETF working group acronym (e.g. httpbis, tls, quic). Leave blank for all.

## `dateFrom` (type: `string`):

Only documents updated on or after this date.

## `dateTo` (type: `string`):

Only documents updated on or before this date.

## Actor input object example

```json
{
  "maxItems": 10,
  "type": "draft"
}
```

# 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,
    "type": "draft",
    "state": "",
    "groupAcronym": "",
    "dateFrom": "",
    "dateTo": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/ietf-datatracker-drafts-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,
    "type": "draft",
    "state": "",
    "groupAcronym": "",
    "dateFrom": "",
    "dateTo": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ietf-datatracker-drafts-scraper").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 '{
  "maxItems": 10,
  "type": "draft",
  "state": "",
  "groupAcronym": "",
  "dateFrom": "",
  "dateTo": ""
}' |
apify call parseforge/ietf-datatracker-drafts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/ietf-datatracker-drafts-scraper"
        }
    }
}

```

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/Nxih98jcAdDtLBUzA/builds/SwOFtC1RhHY79cPk7/openapi.json