# SEC EDGAR Filings Scraper and Monitor (`skootle/sec-edgar-filings`) Actor

Scrape SEC EDGAR company filings by ticker, CIK, form type, and date. Export filing metadata, document links, companies, dates, and agent-ready records for finance research and monitoring.

- **URL**: https://apify.com/skootle/sec-edgar-filings.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** Developer tools, AI, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 sec filing records

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?

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

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

## How to integrate an Actor?

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

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

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

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

# README

### Fast answer: what this Actor is for

Monitor SEC EDGAR filings for company research, finance workflows, diligence, and AI agents that need structured filing metadata.

- Run it from the Apify UI for one-off exports.
- Schedule it or call it by API for recurring monitoring.
- Use the dataset output directly in spreadsheets, automations, and AI agents.

![SEC EDGAR Filings hero](https://raw.githubusercontent.com/kesjam/skootle-actors-assets/main/heroes/sec-edgar.png)

### TL;DR

Equity research analysts, hedge fund quants, M\&A desks, and fintech compliance teams refresh EDGAR for filings on 50+ tickers daily. This monitors SEC EDGAR filings for any public company by ticker or CIK and returns one clean structured record per filing: form name, form-category enum (10-K, 10-Q, 8-K, S-1, DEF 14A, Form 4, 13F, more), ISO 8601 filing/period/acceptance timestamps, direct primary-document URL, items list, XBRL flags, plus a joined company snapshot (name, ticker, exchange, SIC). Watchlist mode emits only NEW filings since the previous run, so a daily schedule becomes a clean diff feed of new disclosures for portfolio monitoring, insider-signal pipelines, 13F tracking, IPO desks, and proxy-season research.

***

> Try it on a small dataset, then let us know what you think in a [review](https://apify.com/skootle/sec-edgar-filings/reviews).

***

### What does SEC EDGAR Filings Monitor do?

SEC EDGAR Filings Monitor extracts SEC filings for any public company. Pass a list of stock tickers (or CIKs for funds, insiders, and foreign issuers); get back one record per filing with form name, a normalized form-category, filing and period dates, the primary document URL, 8-K item codes, XBRL flags, plus a joined snapshot of company metadata (name, ticker, exchange, SIC code, fiscal year end).

Reads EDGAR live with no delay, so a filing shows up minutes after the SEC accepts it. Same uptime as the EDGAR website itself.

Watchlist mode (`watchlistMode: true`) makes this scraper schedulable. State persists across runs in the actor's key-value store, so a daily cron only emits filings NEW since the last run.

### Why scrape SEC EDGAR?

EDGAR is the canonical source of public-company financial disclosures, and every 10-K, 10-Q, 8-K, S-1, proxy filing, insider Form 4, and 13F lands there minutes after the SEC accepts it. Equity research analysts, hedge fund quants, M\&A desks, and fintech compliance teams all need to know when a filing drops on a watchlist of 50+ tickers, but the EDGAR UI is one company at a time. The manual workflow is refreshing the same 50 company pages every morning.

This actor delivers a watchlist diff feed: feed it the tickers, schedule it daily, get only the filings that are new since yesterday. Each record carries the company snapshot inline (name, ticker, exchange, SIC) and a clean form category, so a portfolio-monitoring pipeline or insider-signal scanner can filter on one field instead of mapping 200+ raw form names by hand.

### Who needs this?

- **Equity research analysts** monitoring a portfolio of tickers for new 10-K, 10-Q, and 8-K disclosures
- **Insider-trading signal pipelines** filtering `formCategory: 'insider_transaction'` (Form 4, 5, 3) on watchlist tickers
- **13F-tracking quants** monitoring institutional holders (Berkshire, Renaissance, Citadel, hedge funds)
- **IPO and capital-markets desks** filtering `formCategory: 'registration'` and `prospectus` for S-1, S-1/A, 424B filings
- **Compliance and corporate-actions desks** watching 8-K events for material developments
- **Proxy-season governance researchers** filtering DEF 14A across the S\&P 500 in March-May
- **AI agents and LLM apps** ingesting filings as a structured feed for downstream summarization, sentiment, or alerting
- **Financial-news aggregators** breaking stories minutes after EDGAR posts

### How to use SEC EDGAR Filings Monitor

1. Open the **Input** tab on the actor page
2. Add tickers (e.g., `AAPL`, `MSFT`, `NVDA`) to the `tickers` field, OR raw CIKs to `ciks` for filers without tickers
3. Optionally set `formFilter` to specific forms (e.g., `["10-K", "10-Q", "8-K"]`) or `formCategoryFilter` to category enums (e.g., `["annual_report", "current_report"]`)
4. Set `filingsPerCompany` (default 20) and `maxItems` (default 50, conservative for the 5-minute auto-test)
5. Optionally set `daysLookback` to limit to recent filings (e.g., `daysLookback: 30` for last 30 days)
6. Optionally enable `watchlistMode` for daily scheduled runs that only return new filings
7. Click **Start** or call via the Apify REST API or CLI

You can run on demand from the Console, schedule it with Apify's cron, call via API, or integrate with Make, Zapier, n8n, Slack, Google Sheets.

### How much will scraping SEC EDGAR cost?

This actor is priced per event:

- **Actor Start**: $0.01 once per run
- **SEC filing record**: tiered, charged per record written

| Apify plan | $/1000 records |
|---|---|
| FREE | $30.00 |
| BRONZE | $25.50 |
| SILVER | $21.00 |
| GOLD | $18.00 |
| PLATINUM | $18.00 |
| DIAMOND | $16.20 |

A typical daily portfolio watchlist on 25 tickers with `filingsPerCompany: 20` returns ~50-100 records on day 1, then 5-20 per day in watchlist mode. Roughly $0.90-$1.80 per daily run on the GOLD plan. Premium tier matches the value: this is real-time financial intelligence, not a commodity scrape.

### Is it legal to scrape SEC EDGAR?

Yes, EDGAR is explicitly designed for public access. The SEC publishes [API access guidelines](https://www.sec.gov/os/accessing-edgar-data) requesting only that callers send a User-Agent with a contact email and stay under 10 requests/second. This actor honors both: the User-Agent includes the maintainer's email by default (override via `contactEmail` input), and rate-limiting keeps it well under the 10/s ceiling.

There is no copyright on the filings themselves, they are public-record disclosures filed by registrants with the SEC, and federal law explicitly puts them in the public domain. Use the data freely for research, analytics, AI training, or commercial products.

### Examples

#### Example 1: Daily watchlist on Apple

```json
{
  "tickers": ["AAPL"],
  "filingsPerCompany": 20,
  "watchlistMode": true,
  "maxItems": 20
}
```

#### Example 2: 10-K and 10-Q filings only across the FAANG portfolio

```json
{
  "tickers": ["META", "AMZN", "AAPL", "NFLX", "GOOGL"],
  "formFilter": ["10-K", "10-K/A", "10-Q", "10-Q/A"],
  "filingsPerCompany": 10,
  "maxItems": 50
}
```

#### Example 3: Insider Form 4 monitoring on the S\&P-50 mega-caps

```json
{
  "tickers": ["AAPL", "MSFT", "NVDA", "GOOGL", "AMZN", "META", "TSLA", "BRK.B", "JPM", "JNJ"],
  "formCategoryFilter": ["insider_transaction"],
  "filingsPerCompany": 50,
  "watchlistMode": true,
  "maxItems": 500
}
```

#### Example 4: 13F holdings disclosures for top hedge funds (CIKs)

```json
{
  "ciks": ["1067983", "1029160", "1336528", "1167483"],
  "formFilter": ["13F-HR", "13F-HR/A"],
  "filingsPerCompany": 5,
  "maxItems": 20
}
```

CIK `1067983` is Berkshire Hathaway. Use SEC's [EDGAR full-text search](https://efts.sec.gov/LATEST/search-index?q=\&forms=13F-HR) to find any filer's CIK.

#### Example 5: 8-K material-events monitoring (M\&A, exec changes, restatements)

```json
{
  "tickers": ["MSFT", "GOOGL", "META", "AAPL", "NVDA", "TSLA"],
  "formCategoryFilter": ["current_report"],
  "watchlistMode": true,
  "filingsPerCompany": 30
}
```

#### Example 6: IPO-pipeline monitoring (S-1 and S-1/A across recent filers)

```json
{
  "tickers": ["RDDT", "ARM", "INSM", "BRK.B"],
  "formCategoryFilter": ["registration", "prospectus"],
  "daysLookback": 365,
  "filingsPerCompany": 20
}
```

#### Example 7: Proxy-season DEF 14A scrape

```json
{
  "tickers": ["AAPL", "MSFT", "GOOGL", "AMZN", "META", "JPM", "BAC", "WFC"],
  "formCategoryFilter": ["proxy"],
  "daysLookback": 120,
  "filingsPerCompany": 5
}
```

#### Example 8: Last 7 days of any filings, any company, premium token

```json
{
  "tickers": ["AAPL"],
  "daysLookback": 7,
  "filingsPerCompany": 100
}
```

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `tickers` | string\[] | `["AAPL"]` | Stock tickers. Resolved to CIK via SEC's official ticker map. |
| `ciks` | string\[] | `[]` | Use for filers without tickers (private filers, funds, insiders). |
| `formFilter` | string\[] | `[]` | Exact-match form names. Empty = all. |
| `formCategoryFilter` | string\[] | `[]` | Filter by category enum. Empty = all. |
| `filingsPerCompany` | int | `20` | 1-1000 |
| `daysLookback` | int | `0` | 0 = no date filter; otherwise only filings on or after (today - N days). |
| `watchlistMode` | bool | `false` | Idempotent diff against KV-stored seen accession numbers. |
| `maxItems` | int | `50` | Hard cap on total filings. |
| `contactEmail` | string | maintainer | Sent in the SEC User-Agent header per SEC requirements. |

### Form category enum

Each filing carries `formCategory` from this enum (so you don't have to map 200+ form names downstream):

| Category | Forms it covers |
|---|---|
| `annual_report` | 10-K, 10-K/A, 20-F, 40-F |
| `quarterly_report` | 10-Q, 10-Q/A |
| `current_report` | 8-K, 8-K/A, 6-K |
| `registration` | S-1, S-1/A, S-3, S-4, F-1 |
| `prospectus` | 424B1, 424B2, 424B3, 424B4, 424B5 |
| `proxy` | DEF 14A, DEFA14A, PRE14A |
| `insider_transaction` | 3, 4, 4/A, 5 |
| `institutional_holdings` | 13F-HR, 13F-HR/A, 13D, 13G, SC13D, SC13G |
| `amendment` | any form ending in `/A` not classified above |
| `other` | every other form on EDGAR |

### SEC EDGAR output format

#### `sec_filing`

| Field | Type | Description |
|---|---|---|
| `outputSchemaVersion` | string | Versioned literal (`'2026-05-08'`) |
| `recordType` | literal | `'sec_filing'` |
| `recordId` | string | `sec:filing:<accession-clean>` (idempotent, cross-run dedupe-friendly) |
| `accessionNumber`, `accessionNumberClean` | string | SEC's official ID (with dashes + cleaned) |
| `url`, `primaryDocumentUrl`, `filingIndexUrl` | string | Direct links to the document and EDGAR index |
| `form`, `formCategory`, `isAmendment` | string/enum/bool | Form identity + classification |
| `filingDate`, `reportDate`, `acceptanceDateTime` | ISO 8601 | All timestamps standardized |
| `primaryDocument`, `primaryDocDescription` | string | Filename + SEC-supplied description |
| `fileNumber`, `filmNumber` | string | EDGAR file/film IDs |
| `items` | string\[] | 8-K item codes (e.g., `["2.02", "9.01"]`) |
| `isXBRL`, `isInlineXBRL` | bool | XBRL availability flags |
| `size` | int | Bytes |
| `company` | object | Joined company metadata: `cik`, `cikPadded`, `name`, `ticker`, `exchange`, `sicCode`, `sicDescription`, `fiscalYearEnd` |
| `fieldCompletenessScore` | int 0-100 | Self-filtering signal |
| `agentMarkdown` | string | 300-500 char LLM-ready summary |

#### SEC EDGAR scraper output example

```json
{
  "outputSchemaVersion": "2026-05-08",
  "recordType": "sec_filing",
  "recordId": "sec:filing:000032019325000118",
  "accessionNumber": "0000320193-25-000118",
  "form": "10-K",
  "formCategory": "annual_report",
  "isAmendment": false,
  "filingDate": "2025-11-01",
  "reportDate": "2025-09-28",
  "primaryDocDescription": "10-K",
  "primaryDocumentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000118/aapl-20250928.htm",
  "items": [],
  "isXBRL": true,
  "company": {
    "cik": "320193",
    "cikPadded": "0000320193",
    "name": "Apple Inc.",
    "ticker": "AAPL",
    "exchange": "Nasdaq",
    "sicCode": "3571",
    "sicDescription": "Electronic Computers",
    "fiscalYearEnd": "0928"
  },
  "fieldCompletenessScore": 100,
  "agentMarkdown": "**📄 10-K · $AAPL · Apple Inc.**\n> 10-K\n- 🗂 form: 10-K (annual_report)\n- 📅 filed: 2025-11-01 · period: 2025-09-28\n- 🏢 Electronic Computers · Nasdaq\n- 🔗 https://www.sec.gov/Archives/edgar/data/320193/000032019325000118/aapl-20250928.htm"
}
```

### During the Actor run

No authentication required beyond a contact email in the User-Agent (SEC's own guideline). The actor stays well under SEC's 10/s rate ceiling and reads filings live, with no delay vs the EDGAR website itself. A typical 25-ticker portfolio watchlist completes in under a minute.

A run summary lands at the `OUTPUT` key, a markdown digest with form-mix counts and the top 10 material filings at `AGENT_BRIEFING`, and (with `watchlistMode: true`) seen accession numbers at `WATCHLIST_STATE` (capped at 10,000).

### FAQ

#### How does SEC EDGAR Filings Monitor work?

Input: a list of tickers (or raw CIKs for filers without tickers), optional form filters (10-K, 10-Q, 8-K, S-1, 13F, Form 4, DEF 14A, more), and a lookback window. Output: one structured record per filing in your Apify dataset, exportable as JSON, CSV, or Excel. Reads EDGAR live with no delay, so a filing shows up minutes after the SEC accepts it. Turn on watchlist mode and the next run only emits what's new.

#### Can I monitor filings for new disclosures only?

Yes. Set `watchlistMode: true`. The first run emits everything; subsequent runs emit only filings new since the previous run. Schedule with the Apify cron scheduler.

#### Can I filter to specific form types?

Two ways: `formFilter` for exact-match form names (e.g., `["10-K", "10-Q"]`), or `formCategoryFilter` for category groupings (e.g., `["annual_report", "quarterly_report"]`). Combine both for narrow filters.

#### Can I use this with the Apify API?

Yes. POST to `https://api.apify.com/v2/acts/skootle~sec-edgar-filings/runs` with your input as JSON body and your Apify token as the `Authorization: Bearer` header.

#### Can I integrate with Make / Zapier / n8n / Slack?

Yes. From the actor page, click **Integrations** and pick your destination.

#### Can I get filings from before EDGAR's recent window?

This actor returns the most recent ~1,000 filings per company (the `submissions/recent` window EDGAR exposes). For deeper historical pulls, use SEC's full-index files at `https://www.sec.gov/Archives/edgar/full-index/`.

#### Can I get the full text of each filing?

This actor returns metadata + a direct URL to the primary document. To download document contents, pipe the `primaryDocumentUrl` to a downstream HTTP fetcher (e.g., the Apify Web Crawler or a Make.com HTTP step).

#### Can I find a CIK by company name?

This actor accepts both tickers and CIKs as input. To look up a CIK by name, use SEC's [EDGAR full-text search](https://efts.sec.gov/LATEST/search-index?q=) or the `company_tickers.json` map (also fetched by this actor when you supply tickers).

#### Is the data delayed?

No, EDGAR exposes filings as soon as the SEC accepts them, typically within minutes of the filer's submission. This actor reads the live API, not a delayed cache.

#### Why does this actor cost more than free EDGAR scrapers?

Free actors trade reliability and feature depth for cost. This actor ships a versioned schema, idempotent record IDs, the joined company metadata, the `formCategory` enum (saves you from mapping 200+ form names), `agentMarkdown` per filing, watchlist diff mode, and continuous maintenance. If you're feeding the data into a portfolio-monitoring pipeline or AI agent, those features pay back the per-record cost in saved engineering time.

#### Your feedback

Hit a bug or want a feature? Open an issue on the [Issues tab](https://apify.com/skootle/sec-edgar-filings/issues/open) rather than the reviews page, and we'll fix it fast (typically within 48 hours).

### Why choose SEC EDGAR Filings Monitor

- **Filter by form type in one field**, 10-K, 10-Q, 8-K, S-1, 13F, Form 4, DEF 14A, mapped into nine clean category enums so you skip mapping 200+ raw form names by hand
- **Watchlist mode emits only what's new since last run**, schedule daily across 50+ tickers without paying for duplicates or re-ingesting yesterday's 10-Qs
- **50+ ticker watchlists in one run**, pass the list, get the diff feed back
- **Joined company metadata per filing**, name, ticker, exchange, SIC, fiscal year end. No second query
- **Live, not delayed**, filings show up minutes after the SEC accepts them
- **AI agents can self-filter sparse rows** and paste the per-filing markdown summary straight into Claude or ChatGPT
- **Hand-tuned for this source. Fixes ship the same week the source changes**, typically within 24-48 hours
- **Safe to dedupe across re-runs**, stable `sec:filing:<accession>` IDs upsert cleanly
- **Schema doesn't break your pipeline**, versioned and date-stamped on every record
- **SEC-compliant from day one**, User-Agent with contact email, sub-second rate limit, follows SEC's published API guidelines

### Other Skootle actors you might want to check

- **[Hacker News Watchlist](https://apify.com/skootle/hackernews-watchlist)**, same agent-grade pattern for tech discourse
- **[Reddit Subreddit Scraper](https://apify.com/skootle/reddit-subreddit-monitor)**, sentiment + brand monitoring on subreddits
- **[GitHub Trending Repos](https://apify.com/skootle/github-trending)**, daily/weekly/monthly trending dev repos with API enrichment
- **[Apple App Store Reviews Monitor](https://apify.com/skootle/app-store-reviews)**, App Store reviews with watchlist mode
- **[Shopify App Store Scraper](https://apify.com/skootle/shopify-app-store-scraper)**, Shopify app listings with rating + pricing tiers
- **[SAM.gov + USAspending Federal Contracts](https://apify.com/skootle/sam-gov-federal-contracts)**, federal contract opportunities + historical award context

### Support and contact

File issues on this actor's page (Issues tab), replies within 48 hours. For feature requests, drop them in the same tracker tagged `enhancement`.

# Actor input Schema

## `tickers` (type: `array`):

Stock tickers (e.g., AAPL, MSFT, TSLA). Resolved to CIK via SEC's official ticker map.

## `ciks` (type: `array`):

SEC Central Index Keys (with or without leading zeros). Use this for entities without tickers (private filers, funds, insiders).

## `formFilter` (type: `array`):

Filter to specific forms (e.g., '10-K', '10-Q', '8-K', 'S-1', 'DEF 14A', '4'). Empty = all.

## `formCategoryFilter` (type: `array`):

Filter by category. Empty = all. Categories: annual_report, quarterly_report, current_report, registration, proxy, insider_transaction, institutional_holdings, prospectus, amendment, other.

## `filingsPerCompany` (type: `integer`):

How many recent filings to fetch per company.

## `daysLookback` (type: `integer`):

Only return filings on or after (today - N days). 0 means no date filter.

## `watchlistMode` (type: `boolean`):

When true, only emit filings NEW since the previous run. State persists in the key-value store.

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

Hard cap on total filings saved. Conservative default for the 5-minute auto-test.

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

SEC requires a contact email in the User-Agent header. Defaults to the actor maintainer.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "ciks": [],
  "formFilter": [],
  "formCategoryFilter": [],
  "filingsPerCompany": 20,
  "daysLookback": 0,
  "watchlistMode": false,
  "maxItems": 50,
  "contactEmail": "jamie.kester@gmail.com"
}
```

# Actor output Schema

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

All filings from this run.

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

Markdown digest with form mix and top 10 material filings.

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

Compact OUTPUT object with row counts and per-stage error counts.

# 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 = {
    "tickers": [
        "AAPL"
    ],
    "ciks": [],
    "formFilter": [],
    "formCategoryFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("skootle/sec-edgar-filings").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 = {
    "tickers": ["AAPL"],
    "ciks": [],
    "formFilter": [],
    "formCategoryFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("skootle/sec-edgar-filings").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 '{
  "tickers": [
    "AAPL"
  ],
  "ciks": [],
  "formFilter": [],
  "formCategoryFilter": []
}' |
apify call skootle/sec-edgar-filings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,skootle/sec-edgar-filings"
        }
    }
}
```

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/hmfgOzEep457qsdOg/builds/rj6Dl2lQwobzjGcPg/openapi.json