# 13D/13G Stake Watch: Activist & 5% Ownership (`glaciological_huddle/stake-13d-13g-watch`) Actor New activist 13D and passive 13G stake reports as flat rows: holder, company, ticker, shares, percent of class, voting power and 13D purpose. New-only mode. - **URL**: https://apify.com/glaciological_huddle/stake-13d-13g-watch.md - **Developed by:** [Clark Scroggin](https://apify.com/glaciological_huddle) (community) - **Categories:** Business, Automation, News - **Security:** Limited permissions - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $3.00 / 1,000 stake rows This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## 13D/13G Stake Watch: Activist & 5% Ownership > **Unofficial; not affiliated with or endorsed by the U.S. Securities and Exchange Commission.** This Actor reads public Schedule 13D and 13G filings from the SEC's EDGAR archive (daily index files, each filing's folder listing and its structured XML) with a declared User-Agent at a polite request rate. **Data only; not investment advice.** **Who just took a 5% stake, and why.** Anyone who acquires more than 5% of a US-listed company's voting shares must report it. Investors who may push for change (board seats, a sale, buybacks) file a **Schedule 13D** and must explain their plans in **Item 4, "Purpose of Transaction"**; passive investors and institutions file the shorter **Schedule 13G**. Changes are reported as amendments (13D/A, 13G/A). 13D/13G Stake Watch turns each new filing into **one row per reporting person**: company, ticker and CUSIP, holder name and CIK, type of holder, citizenship or place of organization, sole and shared voting and dispositive power, **shares owned and percent of class**, event date, for 13D the source of funds and the **purpose text**, for 13G the **Rule 13d-1(b)/(c)/(d)** designation, and a link to the filing. Run it on a schedule with **Only new** on and every run outputs just the stakes you have not seen, with the **change in percent** when the same holder files again on the same company. By default you get the **activist side: Schedule 13D and 13D/A**. Add 13G and 13G/A for passive holders and institutions. ### Who uses it - **Activist trackers and event-driven investors** who want every new 13D and every change in an activist position, with the stated purpose, the morning after it is filed. - **Investor relations and corporate secretaries** watching who is building a stake in their company or their peers. - **Journalists and researchers** covering activism, proxy fights, takeovers and large holders. - **Data teams** loading beneficial-ownership records into a warehouse, Sheets or a dashboard without parsing XML. ### What you get One row per reporting person, flat fields, CSV-friendly. A joint filing by a fund, its general partner and its manager gives three rows. Below is a real row from a test run (a Schedule 13D filed 2026-10-30 by seven joint reporting persons on Ives Ultra AI Opportunities Inc.; the first person's row): ```json { "accessionNumber": "0001104659-26-120721", "personIndex": 0, "formType": "SCHEDULE 13D", "isAmendment": false, "amendmentNo": null, "isActivist13D": true, "filedDate": "2026-10-30", "eventDate": "2026-10-31", "issuerName": "Ives Ultra AI Opportunities Inc.", "issuerCik": "2077345", "issuerTicker": "IVAI", "cusip": "90386L108", "securityClass": "Common Stock, par value $ 0.001 per share", "reportingPersonName": "YA II PN, Ltd.", "reportingPersonCik": "1463928", "reportingPersonType": "CO", "citizenshipOrPlace": "E9", "memberOfGroup": "a", "soleVotingPower": 0, "sharedVotingPower": 2500000, "soleDispositivePower": 0, "sharedDispositivePower": 2500000, "sharesOwned": 2500000, "percentOfClass": 9.4, "previousPercentOfClass": null, "percentChange": null, "rule13gDesignation": null, "sourceOfFunds": "WC", "sourceOfFundsDetail": "On September 2, 2026, in connection with the Issuer's anticipated initial public offering (the \"IPO\"), YA II entered into an Option Agreement ...", "purposeOfTransaction": "The Reporting Persons entered into the Option and expect to exercise the Option and acquire the securities reported herein for investment purposes, subject to the following: The Reporting Persons have engaged, and intend to continue to engage, in communications with the Issuer's Board of Directors (the \"Board\") and management team regarding opportunities to enhance stockholder value. ...", "purposeTruncated": false, "coverPageComment": "Rows 8, 10 and 11 Represents Shares issuable upon exercise of an option to purchase membership interests in Ultra AI Holdings LLC, ... Row 13 Based on 26,500,000 Shares outstanding as of October 1, 2026, as reported in the Issuer's Prospectus dated September 29, 2026.", "filerCount": 7, "previousAccessionNumber": null, "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/2077345/000110465926120721/", "xmlUrl": "https://www.sec.gov/Archives/edgar/data/2077345/000110465926120721/primary_doc.xml", "isNew": true, "fetchedAt": "2026-11-02T14:45:37.813Z", "source": "www.sec.gov Archives, Schedule 13D/13G structured XML (public filing data)" } ``` (Long text fields are shortened here; the dataset holds them in full, the purpose up to 4,000 characters.) Notes on the columns: - `percentOfClass` and the share counts are the cover-page numbers for **that** reporting person. In joint filings the same shares are usually counted for every person in the control chain (fund, general partner, manager, principal), so **do not add up the rows of one filing**. - `isActivist13D` is `true` for 13D and 13D/A. A 13D means the holder does not certify a passive intent; it does not by itself mean a campaign. Read `purposeOfTransaction`. - `purposeOfTransaction` is Item 4 with whitespace collapsed, cut at 4,000 characters (`purposeTruncated: true` when cut). Amendments contain it only when Item 4 changed; otherwise it is `null`. - `sourceOfFunds` (13D) holds the cover-page codes: `WC` working capital, `PF` personal funds, `AF` affiliate, `BK` bank, `OO` other, and so on. `sourceOfFundsDetail` is the Item 3 text (up to 1,000 characters). - `rule13gDesignation` (13G) is `Rule 13d-1(b)` (banks, brokers, advisers, funds), `Rule 13d-1(c)` (other passive investors) or `Rule 13d-1(d)` (holders who were never required to file under 13d-1(b)/(c), e.g. pre-IPO holders). - `reportingPersonType` codes: `IA` investment adviser, `PN` partnership, `IN` individual, `CO` corporation, `HC` parent holding company, `BD` broker-dealer, `OO` other... - `citizenshipOrPlace` is the code as filed: US states (`DE`, `NY`...), `X1` = United States, other EDGAR country codes (`E9` = Cayman Islands, `K7` = India...). - `reportingPersonCik` comes from the 13D cover page. The 13G form has no CIK field, so for 13G the Actor matches the person's name against the filing's own index line and fills the CIK when it matches; otherwise `null`. Some 13D persons have no CIK either. - `previousPercentOfClass` and `percentChange` are filled when **this watch** has already output an earlier filing by the same holder on the same company (it does not look up older filings). - `issuerTicker` comes from the SEC's public company ticker file (main symbol); `null` for companies not listed there. - `accessionNumber` + `personIndex` identify a row uniquely. Empty values are `null`, never empty strings. A `RUN_SUMMARY` record in the run's key-value store has the counts: index days read and missing, 13D/13G filings in the index by type, filings skipped before download (by ticker, by filer name, already seen), filings downloaded, rows filtered out, errors, requests used and why the run stopped. ### How to use it 1. **Pick the forms.** Keep 13D and 13D/A for activist stakes, or add 13G and 13G/A for passive holders and institutions. 2. **Pick companies, investors, or the whole market.** Enter **Tickers** (or **Issuer CIKs**) to watch who files on those companies, and/or **Filer name contains** to follow particular investors (`Elliott`, `Starboard`, `Icahn`...). Both are applied to the daily index before anything is downloaded, so watch runs are small and quick. Leave them empty for the whole market. 3. **Set a threshold** with **Minimum percent of class** if you only care about larger stakes. 4. **Name the watch.** `watchName` is the memory key; use one per saved search. The first run of a new watch returns everything that matches in the window (up to **Max items**); from then on, only rows not output before. 5. **Schedule it.** Add a daily schedule in Apify with `daysBack` 1. Each day's index file appears in the evening (US Eastern), so a morning run picks up the previous business day's filings. 6. **Connect the output** to Google Sheets, Slack, email, webhooks, Zapier, Make, n8n or your own API with Apify integrations. Quiet runs push nothing. #### Example 1: Every new activist stake and change, market-wide ```json { "formTypes": ["SCHEDULE 13D", "SCHEDULE 13D/A"], "daysBack": 1, "watchName": "activists", "maxItems": 200, "maxFilingsScanned": 300 } ``` #### Example 2: Named activist funds, all four schedules ```json { "formTypes": ["SCHEDULE 13D", "SCHEDULE 13D/A", "SCHEDULE 13G", "SCHEDULE 13G/A"], "filerNameContains": ["Elliott", "Starboard", "Icahn", "Trian", "Pershing Square", "Jana Partners", "ValueAct", "Engine Capital", "Ancora"], "daysBack": 1, "watchName": "named-activists", "maxItems": 200 } ``` #### Example 3: Passive 5%+ holders of big tech ```json { "formTypes": ["SCHEDULE 13G", "SCHEDULE 13G/A"], "tickers": ["AAPL", "MSFT", "NVDA", "AMZN", "GOOGL", "META", "TSLA"], "minPercentOfClass": 5, "daysBack": 5, "watchName": "big-tech-holders", "maxItems": 200 } ``` ### Input reference | Field | Type | Default | What it does | |---|---|---|---| | `formTypes` | enum\[] | 13D, 13D/A | `SCHEDULE 13D`, `SCHEDULE 13D/A`, `SCHEDULE 13G`, `SCHEDULE 13G/A`. An empty list means all four. | | `tickers` | string\[] | \[] | Subject-company symbols. Mapped to CIKs with the SEC's public company ticker file and applied to the daily index before any download. | | `issuerCiks` | string\[] | \[] | Subject-company CIKs, for companies without a ticker. Combined with `tickers`. | | `filerNameContains` | string\[] | \[] | Case-insensitive substrings of investor names. Checked on the index lines before download and on the reporting persons after parsing; a matching joint filing is kept whole. | | `minPercentOfClass` | number 0–100 | none | Keep rows reporting at least this percent of class. Rows without a percent are left out when set. | | `daysBack` | int 1–10 | 1 | Past business days of daily index files to read, plus today's index if already published. | | `onlyNew` | bool | true | Output only rows this watch has not output before. | | `watchName` | string | "default" | Memory key; stored in the named key-value store `stake-watch-`. | | `maxItems` | int 1–5000 | 200 | Hard cap on rows per run; the rest is left for the next run. | | `maxFilingsScanned` | int 1–5000 | 300 | Hard cap on filings downloaded per run, so whole-market 13G runs stay short. | | `userAgentContact` | string | none | Optional contact (your e-mail) for the User-Agent header sent to www.sec.gov. Sent only in that header; masked (e.g. `j***@e***.com`) in logs and `RUN_SUMMARY`. | ### Pricing Pay per event. You pay for rows actually delivered, plus a small start fee. | Event | Price | When | |---|---|---| | Actor start | **$0.005** | Once per run, even when nothing is new | | `stake` | **$0.003** | Per row in the dataset (one reporting person on one filing) | **What a typical watch costs.** The market-wide activist watch (13D + 13D/A) on our test day, 2026-10-30, produced 54 rows from 16 filings: 54 × $0.003 + $0.005 = **$0.167 for the day**. A watch on a handful of tickers or named funds usually outputs a few rows a week and costs $0.005 on quiet days, **about $0.15 a month** plus $0.003 per row. Joint filings produce one row per reporting person (often 2–7), which is why rows outnumber filings. Compute is included, there are no proxy charges, and the run stops itself before exceeding the spending limit you set on the run (`Maximum cost per run` in Apify). Filtered-out rows are never charged. ### Data source and how the Actor behaves **Source: U.S. Securities and Exchange Commission, EDGAR Schedule 13D and 13G filings (public information).** The SEC states that information presented on sec.gov is public information that may be copied or further distributed, and asks for appropriate citation of the SEC as the source. Since December 2024 these schedules are filed as structured XML under the form types `SCHEDULE 13D`, `SCHEDULE 13D/A`, `SCHEDULE 13G` and `SCHEDULE 13G/A`. The Actor reads only those; the older text forms (`SC 13D`, `SC 13G`) and other schedules (`SC 13E3`, `SC TO`...) are ignored. It reads only documented, machine-readable files: the **daily form index** (`/Archives/edgar/daily-index/YYYY/QTRn/form.YYYYMMDD.idx`, one request per business day), the **company ticker file** (`/files/company_tickers.json`, at most one request per run, to resolve your tickers and fill `issuerTicker`), and for each filing it needs, the filing folder's **`index.json`** and the **`primary_doc.xml`** it lists (two requests per filing). It does not crawl web pages, does not log in and does not use a browser. Requests carry a declared User-Agent (`StakeWatch/0.1 ...`, with your contact if you provide one) and accept gzip, are spaced at **5 per second** (half the SEC's published ceiling of 10), time out after 30 s, and transient errors (429, 5xx, network) are retried at most 3 times with backoff. If the site's automated-traffic guard answers, the run stops cleanly, keeps the rows already pushed and tells you to wait before the next run. A filing is listed in the daily index once per filer (under the subject company and under the filing person), so the Actor groups those lines by accession number and downloads each filing once. If one filing's XML does not look like a Schedule 13D/13G, that filing is skipped and counted in `errors`; the run continues and tries it again next time. If the daily index itself no longer matches the documented layout, the run fails with a clear message instead of emitting empty results. **Timing.** Rows appear after the SEC publishes the filing in its daily index, in the evening (US Eastern) of the filing day. A 13D is due within 5 business days of crossing 5%; a 13G within 5 business days (13d-1(c)) or 45 days after the quarter (13d-1(b)). So a stake usually shows up in this Actor one business day after it is filed and several days after the event. **This is not a live feed.** **People named in filings.** Holder names, CIKs and the other cover-page facts are what the filer reported publicly; the Actor outputs them as filed and nothing more. Contact and address blocks are not output. ### Limitations - **Whole-market 13G runs.** A business day has a few dozen 13D/13D-A filings but several hundred 13G/13G-A filings (343 on our test day), and far more in February when annual 13G amendments are due. Every filing must be downloaded to see its numbers, so `maxFilingsScanned` (default 300) caps the downloads per run. Filings beyond the cap are left for the next run, but a daily schedule with `daysBack` 1 moves on to the next day: for a complete whole-market 13G feed raise `maxFilingsScanned` to 1000 or more, or use tickers or filer names. - `filerNameContains` matches names as filed. Funds often file under the manager's or the principal's name (`DME Capital Management, LP` for Greenlight, `EINHORN DAVID`), so add the variants you know. - 13G cover pages carry no reporting-person CIK; `reportingPersonCik` is filled only when the name matches the filing's index line or the filing has a single person. - Percentages are as filed. Filers compute them from the shares outstanding they cite; `coverPageComment` often says which figure was used. - The daily index lists filings alphabetically by form type and filer. With a low `maxItems` or `maxFilingsScanned` the run stops part-way through a day; the next run continues where the watch left off, person by person. - The first run of a new `watchName` reports everything in the window as new. That is expected; lower `daysBack` or `maxItems` if you prefer. - The watch memory lives in a named key-value store in your account called `stake-watch-`. Deleting it resets the watch, including `previousPercentOfClass`. Filings and holdings not seen for 180 days are forgotten automatically. - Before today's index is published, www.sec.gov sometimes answers with an error or not at all instead of "not found"; the Actor treats that as "not published yet" for today's file only (after one retry) and reads the previous business days normally. ### Integrations and automation Works with every Apify integration: schedules, webhooks, Google Sheets, Slack, email, Zapier, Make, n8n, LangChain and the Apify API and MCP server. Because the output is already the delta, a "new dataset items" trigger maps one-to-one to "new stakes". Typical pipelines: - **Slack alert on new activist stakes:** daily at 8 am, 13D only; post `issuerTicker`, `reportingPersonName`, `percentOfClass`, the first 300 characters of `purposeOfTransaction` and `filingIndexUrl`. - **IR watch:** your own ticker plus five peers, all four forms; append to a Google Sheet and sort by `percentOfClass`. - **Warehouse:** load the dataset into BigQuery or Postgres keyed on `accessionNumber` + `personIndex`. ### FAQ **Is this investment advice?** No. The Actor delivers data as filed. A stake report says who owns what and what they say they intend; it says nothing on its own about future prices. **Is this data legal to use?** Schedule 13D and 13G filings are public records published by the SEC, which states the information may be copied and further distributed with appropriate citation. The Actor uses only the SEC's documented archive files, identifies itself with a declared User-Agent and stays at half the published request-rate ceiling, as the SEC's fair-access policy asks. You remain responsible for how you use the data. **What is the difference between 13D and 13G?** Both report ownership above 5%. 13G is the short form for holders who certify they have no intention of influencing control (institutions, index funds, passive investors). 13D is required otherwise and includes the purpose of the stake and the source of funds. A switch from 13G to 13D is often worth a look. **Why does one filing give several rows?** Each reporting person on the cover pages is a row: a fund, its general partner, its investment manager and the individual who controls them often file together and each reports the same shares. **Why is a stake I read about missing?** It may not have been filed yet, the day's index may not be published yet, it may be a form type you did not select, a legacy `SC 13D` text filing (pre-2025 style, not read), or your filters, `maxItems` or `maxFilingsScanned` left it out. Check `RUN_SUMMARY` for the counts. **Can I track several watchlists?** Yes. Give each its own `watchName`; each keeps its own memory. **What happens to the e-mail I put in `userAgentContact`?** It is sent only in the User-Agent header of requests to www.sec.gov, as the SEC asks of automated tools. Everywhere else (the run log, error messages, the status message and `RUN_SUMMARY`) it appears masked, for example `j***@e***.com`. It is not stored in the watch memory or the dataset. ### Support Open an issue on the Actor's **Issues** tab in Apify Console with your input and run ID. Feature requests welcome, especially new filters or output fields. # Actor input Schema ## `formTypes` (type: `array`): Which schedules to read. 13D = activist or control intent (with the purpose of the stake in Item 4); 13G = passive investors and institutions above 5%. /A = amendments (changes in the stake). Default: 13D and 13D/A. Clear the list to read all four. ## `tickers` (type: `array`): Stock symbols of the companies whose holders you want to watch, e.g. AAPL, MSFT. Mapped to the company's CIK with the SEC's public company ticker file and used to pick filings from the daily index BEFORE anything is downloaded. Leave empty (and Issuer CIKs empty) for the whole market. ## `issuerCiks` (type: `array`): Optional Central Index Keys of subject companies (e.g. 320193 for Apple), for companies without a listed ticker. Combined with Tickers (either matches). ## `filerNameContains` (type: `array`): Keep only filings by investors whose name contains any of these words (case-insensitive), e.g. Elliott, Starboard, Icahn, Trian, Vanguard. Checked on the daily index BEFORE download and again on the reporting persons after parsing; a joint filing is kept whole (fund, manager and principal) when any of its reporting persons matches. ## `minPercentOfClass` (type: `number`): Keep only reporting persons who report at least this percentage of the class (e.g. 10). Rows without a percentage are left out when this is set. Leave empty for no minimum. ## `daysBack` (type: `integer`): How many past business days of daily filing index files to read, plus today's if it has already been published (each day's index appears in the evening, US Eastern time). 1 is right for a daily schedule. ## `onlyNew` (type: `boolean`): Remember every row this watch has output (by filing and reporting person) and output only rows not seen before. Quiet runs output nothing and cost only the start fee. Turn off to re-output everything in the window. ## `watchName` (type: `string`): Name of the saved watch. Each watch keeps its own memory (named key-value store stake-watch-), so several watches ('activists', 'my-portfolio-holders') can run side by side. The memory also gives previousPercentOfClass when the same holder files again on the same company. ## `maxItems` (type: `integer`): Hard cap on output rows per run. The run also stops early if your Apify spending limit for this run would be exceeded. Rows beyond the cap are left for the next run. ## `maxFilingsScanned` (type: `integer`): Hard cap on filings downloaded per run. A business day has a few dozen 13D/13D-A filings but several hundred 13G/13G-A filings (more in February, when annual 13G amendments are due); this cap keeps whole-market runs short. Filings beyond the cap are left for the next run. ## `userAgentContact` (type: `string`): www.sec.gov asks automated tools to identify themselves with contact details. If you enter your e-mail address, requests are sent as 'StakeWatch/0.1 '; otherwise the Actor's default identification is used. Sent only in the User-Agent header of requests to www.sec.gov; masked (e.g. j\*\*\*@e\*\*\*.com) in logs and the run summary. ## Actor input object example ```json { "formTypes": [ "SCHEDULE 13D", "SCHEDULE 13D/A" ], "tickers": [], "issuerCiks": [], "filerNameContains": [], "daysBack": 1, "onlyNew": true, "watchName": "default", "maxItems": 200, "maxFilingsScanned": 300 } ``` # Actor output Schema ## `stakes` (type: `string`): No description ## `runSummary` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "formTypes": [ "SCHEDULE 13D", "SCHEDULE 13D/A" ], "tickers": [], "issuerCiks": [], "filerNameContains": [], "daysBack": 1 }; // Run the Actor and wait for it to finish const run = await client.actor("glaciological_huddle/stake-13d-13g-watch").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "formTypes": [ "SCHEDULE 13D", "SCHEDULE 13D/A", ], "tickers": [], "issuerCiks": [], "filerNameContains": [], "daysBack": 1, } # Run the Actor and wait for it to finish run = client.actor("glaciological_huddle/stake-13d-13g-watch").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 '{ "formTypes": [ "SCHEDULE 13D", "SCHEDULE 13D/A" ], "tickers": [], "issuerCiks": [], "filerNameContains": [], "daysBack": 1 }' | apify call glaciological_huddle/stake-13d-13g-watch --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,glaciological_huddle/stake-13d-13g-watch" } } } ``` 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 ` 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/LMdbO3h8atA6jJKsw/builds/wg1JfhAfs4bFPLrRF/openapi.json