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

Pull IETF Datatracker internet drafts and RFCs: document name, title, authors, abstract, working group, area, status, revision, dates, related drafts, and PDF or text URL. Export internet engineering standards to JSON, CSV, or Excel for protocol research and developer tooling.

- **URL**: https://apify.com/parseforge/ietf-datatracker-drafts-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 $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/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)

## 📨 IETF Datatracker Drafts Scraper

> 🚀 **Export the IETF standards lifecycle in seconds.** Pull **42,000+ Internet Drafts, 9,000+ RFCs**, working-group charters, meeting agendas, BoF requests, and the full Internet engineering corpus with state, stream, and group metadata.

> 🕒 **Last updated:** 2026-05-23 · **📊 17 fields** per record · **📜 42k+ drafts** · **📄 9k+ RFCs** · **🏛️ All IETF working groups**

The **IETF Datatracker Drafts Scraper** exports the authoritative catalog of Internet engineering standards published through the IETF. It returns **17 fields per record**, including draft name, title, RFC number when applicable, abstract, revision, stream, standardization level, working-group acronym, state slugs, page count, word count, keywords, last-updated timestamp, expiry date, and a canonical Datatracker URL.

The corpus covers **14 document types** including Internet Drafts, RFCs, Charters, BoF Requests, Meeting Agendas, Minutes, Slides, Conflict Reviews, Status Changes, Reviews, Shepherd Writeups, Liaison Statements, Best Current Practices, and For Your Information notes. Together they trace the lifecycle of every Internet protocol from initial proposal through stable RFC.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Network engineers, protocol researchers, infrastructure security teams, standards trackers, technical writers, policy analysts, RFC authors, working-group chairs | Standards-tracking dashboards, RFC archives, draft monitoring, working-group reports, protocol research, conformance audits |

---

### 📋 What the IETF Datatracker Drafts Scraper does

Five workflows in a single run:

- 📜 **Document-type selector.** Internet Draft, RFC, Charter, BoF Request, Meeting Agenda, Minutes, Slides, Conflict Review, Status Change, Review, Shepherd Writeup, Liaison Statement, Best Current Practice, For Your Information.
- 🔖 **State filter.** Restrict to Active, Expired, Published as RFC, Replaced, Author Withdrew, or IETF Withdrew. Leave empty for any.
- 🏛️ **Working-group filter.** Scope to one IETF working group by acronym (e.g. `httpbis`, `tls`, `quic`, `oauth`).
- 📅 **Date window.** Pull only documents updated within a custom `dateFrom`/`dateTo` range.
- 🧾 **Rich metadata.** Each record carries the abstract, page count, word count, keywords, stream, standardization level, and a stable Datatracker link.

> 💡 **Why it matters:** the IETF runs by rough consensus and running code, but its catalog of 42,000+ drafts and 9,000+ RFCs is the documentation backbone of the open Internet. A queryable copy is the foundation of every standards dashboard, conformance audit, and protocol research project.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to pull a working group's active drafts and load them into a tracking dashboard._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>type</td><td>string</td><td>"draft"</td><td>One of 14 IETF document types.</td></tr>
<tr><td>state</td><td>string</td><td>""</td><td>State slug (active, expired, rfc, repl, auth-rm, ietf-rm). Empty = any.</td></tr>
<tr><td>groupAcronym</td><td>string</td><td>""</td><td>IETF working-group acronym (e.g. httpbis, tls, quic).</td></tr>
<tr><td>dateFrom, dateTo</td><td>string (YYYY-MM-DD)</td><td>""</td><td>Updated-on window.</td></tr>
</tbody>
</table>

**Example: every active HTTPBIS working-group draft.**

```json
{
    "maxItems": 100,
    "type": "draft",
    "state": "active",
    "groupAcronym": "httpbis"
}
````

**Example: every RFC published since 2024.**

```json
{
    "maxItems": 1000,
    "type": "rfc",
    "dateFrom": "2024-01-01"
}
```

> ⚠️ **Good to Know:** state filtering is applied after fetching each document's state metadata. For working-group filters, the Actor resolves the acronym to a group ID server-side before paging, so large group queries stay efficient.

***

### 📊 Output

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

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `name` | string | null | `"draft-ietf-httpbis-http2bis"` |
| 📜 `title` | string | null | `"HTTP/2"` |
| 🏷️ `type` | string | `"draft"` |
| 🔢 `rfcNumber` | number | null | `9113` |
| 🔄 `revision` | string | null | `"05"` |
| 📝 `abstract` | string | null | `"This document describes HTTP/2..."` |
| 🌊 `stream` | string | null | `"ietf"` |
| ⭐ `stdLevel` | string | null | `"std"` |
| 🎯 `intendedStdLevel` | string | null | `"std"` |
| 🏛️ `groupAcronym` | string | null | `"httpbis"` |
| 🔖 `stateSlugs` | string\[] | null | `["rfc"]` |
| 📄 `pages` | number | null | `96` |
| 🔤 `words` | number | null | `42150` |
| 🏷️ `keywords` | string\[] | null | `["http","web","framing"]` |
| 🕒 `timeUpdated` | ISO 8601 | `"2024-06-12T13:43:00"` |
| ⏳ `expires` | ISO 8601 | null | `"2025-01-01T00:00:00"` |
| 🔗 `datatrackerUrl` | string | `"https://datatracker.ietf.org/doc/draft-ietf-httpbis-http2bis/"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>📨 Active draft: HTTPBIS working group</strong></summary>

```json
{
    "name": "draft-ietf-httpbis-http2bis",
    "title": "HTTP/2",
    "type": "draft",
    "rfcNumber": 9113,
    "revision": "07",
    "stream": "ietf",
    "stdLevel": "std",
    "intendedStdLevel": "std",
    "groupAcronym": "httpbis",
    "stateSlugs": ["rfc"],
    "pages": 96,
    "words": 42150,
    "datatrackerUrl": "https://datatracker.ietf.org/doc/draft-ietf-httpbis-http2bis/",
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>📄 Published RFC: TLS 1.3</strong></summary>

```json
{
    "name": "rfc8446",
    "title": "The Transport Layer Security (TLS) Protocol Version 1.3",
    "type": "rfc",
    "rfcNumber": 8446,
    "stream": "ietf",
    "stdLevel": "ps",
    "groupAcronym": "tls",
    "pages": 160,
    "words": 60842,
    "datatrackerUrl": "https://datatracker.ietf.org/doc/rfc8446/"
}
```

</details>

<details>
<summary><strong>🏛️ Working-group charter</strong></summary>

```json
{
    "name": "charter-ietf-quic",
    "title": "QUIC",
    "type": "charter",
    "groupAcronym": "quic",
    "datatrackerUrl": "https://datatracker.ietf.org/doc/charter-ietf-quic/"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📨 | **Full corpus.** 42,000+ drafts, 9,000+ RFCs, plus charters, agendas, BoF requests, and 10 more document types. |
| 🔖 | **State and stream filters.** Active, Expired, Replaced, Withdrawn, Published as RFC. |
| 🏛️ | **Working-group scoping.** Acronym-based filter for httpbis, tls, quic, oauth, and every other IETF group. |
| 📅 | **Date windows.** Pull only what changed since your last run. |
| 📊 | **Rich metadata.** Pages, words, keywords, abstract, stream, std level, intended std level. |
| ⚡ | **Fast.** 100 documents in under 30 seconds. |
| 🚫 | **No authentication.** Public IETF Datatracker. No login or token needed. |

> 📊 The IETF catalog is the documentation source-of-truth for the protocols that run the open Internet. A clean, queryable copy makes every standards dashboard, conformance audit, and research project faster.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ IETF Datatracker Drafts Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **42k drafts, 9k RFCs** | **Live per run** | type, state, group, date | ⚡ 2 min |
| RFC Editor static index | Free | RFCs only | Periodic | None | 🐢 No structure |
| Hand-parsed Datatracker HTML | Free | Same | Manual | Custom code | 🕒 Days |
| Tools.ietf.org legacy scraping | Free | Subset | Stale | None | 🕒 Variable |

Pick this Actor when you need the full IETF lifecycle (not just published RFCs) with structured filters and stable fields.

***

### 🚀 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 IETF Datatracker Drafts Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a `type`, optionally filter by `state`, `groupAcronym`, or date window, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

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

***

### 💼 Business use cases

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

#### 🌐 Network & Infrastructure Engineering

- Track new drafts in HTTPBIS, QUIC, TLS, OAUTH
- Monitor protocol updates that affect your stack
- Build internal "protocols we implement" dashboards
- Alert on state transitions (draft to RFC)

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

#### 🔐 Security & Conformance

- Audit TLS, IPsec, SASL, and PKIX drafts
- Track BCP and security-area working groups
- Build compliance reports against current RFCs
- Detect deprecated specs in your codebase

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

#### 📚 Standards Research

- Map working-group activity over time
- Trace draft-to-RFC lifecycle data
- Build citation graphs across documents
- Academic papers on Internet governance

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

#### 📰 Technical Writing & DevRel

- Auto-update docs links to latest RFCs
- Generate "implements" pages for OSS projects
- Newsletter content on standards updates
- Internal "RFC of the week" digests

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

***

### 🔌 Automating IETF Datatracker Drafts 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 working-group monitors are a common pattern, with Slack or email notifications on new draft revisions.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia

- Internet governance research with reproducible pulls
- Protocol-evolution studies for CS papers
- Network coursework anchored to real RFCs
- Standards-process measurement studies

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

#### 🎨 Personal and creative

- Build a personal RFC reading queue
- Side projects mapping the Internet's plumbing
- Hobbyist protocol implementations
- "On this day in IETF history" feeds

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

#### 🤝 Non-profit and civic

- Internet-policy advocacy with citation data
- Open-source contribution dashboards
- Digital-rights research with primary sources
- Standards transparency for civil society

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

#### 🧪 Experimentation

- Train document-classification models on RFC text
- Prototype agent pipelines that read IETF specs
- Build "what changed since last quarter" workflows
- Test embeddable RFC lookup widgets

</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%20IETF%20Datatracker%20Drafts%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%20IETF%20Datatracker%20Drafts%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%20IETF%20Datatracker%20Drafts%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%20IETF%20Datatracker%20Drafts%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?

Pick a document type, optionally narrow by state, working group, or date window, and click Start. The Actor pages through the Datatracker catalog and emits a clean structured record per document.

#### 📨 How many documents are in the catalog?

The IETF Datatracker tracks 42,000+ Internet Drafts and 9,000+ RFCs, plus charters, BoF requests, and 10 more document types. The Actor pages through the whole catalog when `maxItems` is high enough.

#### 🏛️ Can I filter by working group?

Yes. Set `groupAcronym` to the group's acronym (for example `httpbis`, `tls`, `quic`, `oauth`). The Actor resolves the acronym to the internal group ID and applies the filter server-side.

#### 🔖 What states are supported?

`active`, `expired`, `rfc` (Published as RFC), `repl` (Replaced), `auth-rm` (Author Withdrew), `ietf-rm` (IETF Withdrew). Leave the field empty for any state.

#### 📅 Can I pull only what changed?

Yes. Use `dateFrom` and `dateTo` (YYYY-MM-DD) to scope the run to a custom updated-on window. Common pattern: pull yesterday's changes for a daily monitor.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run on any cron interval. Daily monitors of one working group, weekly RFC digests, and monthly full-catalog refreshes are all common patterns.

#### ⚖️ Is this data legal to use?

Yes. The IETF Datatracker is publicly accessible and the underlying IETF documents are published for open use.

#### 💼 Can I use this commercially?

Yes. Standards dashboards, conformance reports, and protocol-research products are all valid commercial use cases.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan is enough for testing and small runs (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 partway?

Apify retries transient errors automatically. Records already pushed are preserved. The Actor pages through the catalog deterministically, so a re-run picks up cleanly.

#### 🆘 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

IETF Datatracker Drafts 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 IETF data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from repo commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to fire downstream actions when a run finishes. Push a daily diff of HTTPBIS drafts into Slack, or load every new RFC into your knowledge base.

***

### 🔗 Recommended Actors

- [**📐 W3C Standards Catalog Scraper**](https://apify.com/parseforge/w3c-standards-catalog-scraper) - Open Web specifications catalog
- [**📚 arXiv Scraper**](https://apify.com/parseforge/arxiv-scraper) - Open-access research papers across all fields
- [**🔐 FIRST.org CSIRT Teams Scraper**](https://apify.com/parseforge/first-org-csirt-teams-scraper) - Incident response teams and EPSS scores
- [**📊 OEC Economic Complexity Trade Scraper**](https://apify.com/parseforge/oec-economic-complexity-trade-scraper) - International trade flows
- [**🌐 Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap

> 💡 **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 IETF or the Internet Society. All trademarks mentioned are the property of their respective owners. Only publicly available Datatracker data is collected.

# 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("💾 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,
  "type": "draft",
  "state": "",
  "groupAcronym": "",
  "dateFrom": "",
  "dateTo": ""
}' |
apify call parseforge/ietf-datatracker-drafts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IETF Datatracker Documents Scraper",
        "description": "Pull IETF Datatracker internet drafts and RFCs: document name, title, authors, abstract, working group, area, status, revision, dates, related drafts, and PDF or text URL. Export internet engineering standards to JSON, CSV, or Excel for protocol research and developer tooling.",
        "version": "1.0",
        "x-build-id": "rqOQKH9ID2AgMzZmx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~ietf-datatracker-drafts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-ietf-datatracker-drafts-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~ietf-datatracker-drafts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-ietf-datatracker-drafts-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~ietf-datatracker-drafts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-ietf-datatracker-drafts-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"
                    },
                    "type": {
                        "title": "Document type",
                        "enum": [
                            "draft",
                            "rfc",
                            "charter",
                            "bofreq",
                            "agenda",
                            "minutes",
                            "slides",
                            "conflrev",
                            "statchg",
                            "review",
                            "shepwrit",
                            "liaison",
                            "bcp",
                            "fyi"
                        ],
                        "type": "string",
                        "description": "IETF document type to enumerate."
                    },
                    "state": {
                        "title": "State filter",
                        "enum": [
                            "",
                            "active",
                            "expired",
                            "rfc",
                            "repl",
                            "auth-rm",
                            "ietf-rm"
                        ],
                        "type": "string",
                        "description": "Filter drafts by state slug (e.g. active, expired, rfc, repl). Leave blank for all."
                    },
                    "groupAcronym": {
                        "title": "Working group acronym",
                        "type": "string",
                        "description": "Filter to one IETF working group acronym (e.g. httpbis, tls, quic). Leave blank for all."
                    },
                    "dateFrom": {
                        "title": "Updated from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only documents updated on or after this date."
                    },
                    "dateTo": {
                        "title": "Updated to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only documents updated on or before this date."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
