# SEC Insider Trades — EDGAR Form 4 Buys & Sells as JSON (`shelvick/sec-insider-trades`) Actor Track corporate insider trading from SEC EDGAR. Give a ticker or CIK; get normalized Form 4/3/5 insider transactions as JSON: who traded (officer, director, 10% owner), buy/sell/grant/exercise, shares, price, value, shares held after, and dates. Deterministic parsing of public SEC data. - **URL**: https://apify.com/shelvick/sec-insider-trades.md - **Developed by:** [Scott Helvick](https://apify.com/shelvick) (community) - **Categories:** AI, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $8.50 / 1,000 insider filing parseds 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 ## SEC Insider Trades — EDGAR Form 4 Buys & Sells as JSON Corporate insiders — officers, directors, and 10% owners — must report every trade in their own company's stock to the SEC on Form 4 (and Form 3/5), but the filings are buried in EDGAR as raw ownership XML with cryptic single-letter transaction codes. Give this Actor a ticker or CIK and it returns the recent insider filings as clean, normalized JSON: who traded, whether it was a buy or a sell, how many shares, at what price, what they own now, and when. ### What this does - Resolves a stock **ticker** (e.g. `AAPL`, `BRK.B`) or 10-digit **CIK** to the issuer via SEC's official ticker map. - Reads the issuer's EDGAR filing history and selects the recent **Form 4** (changes in ownership), **Form 3** (initial holdings), and/or **Form 5** (annual) filings you ask for. - Fetches each filing's structured ownership XML and parses it **deterministically** — no LLM, no guesswork — into one dataset record per filing. - Decodes the SEC transaction code into a human-readable type: open-market **purchase** / **sale**, **grant/award**, **option exercise**, **gift**, **tax withholding**, and the rest of the Form 4/5 code table. - Captures both the **non-derivative** table (common stock) and the **derivative** table (options, RSUs, warrants) with underlying security, exercise price, and expiration. - Identifies the **reporting owner** and their relationship (director, officer + title, 10% owner) so you can tell an executive's trade from a passive holder's. - Adds a per-filing **summary**: transaction count, total acquired (buy) value, total disposed (sell) value, and net share change — for quick scanning. - Bounds cost and runtime with `maxFilings` (per company) and an optional `sinceDate` floor. Use it to: - **Monitor a watchlist** of tickers for new insider buying or selling since a given date. - **Flag cluster buys** — several insiders at one company purchasing in a short window. - **Track a specific executive's** acquisitions and dispositions over their recent filings. - **Feed an investment-research agent** structured insider-activity data without writing an EDGAR parser. - **Build an ownership-change dataset** across a set of companies for downstream analysis. ### Why deterministic parsing matters The data is already public and free — SEC publishes every Form 4 as machine-readable XML. The problem isn't access; it's that the raw document is awkward to consume: transaction amounts are nested several elements deep, buys and sells are distinguished by a one-letter code (`P`, `S`, `A`, `M`, `F`, `G`, …) plus a separate acquired/disposed flag, and options live in a wholly separate table with their own schema. Insider-trade figures are the kind of data people act on, so the extraction has to be exact. Every value this Actor returns is copied verbatim from the filing's XML — share counts, prices, and post-transaction holdings are the filer's own reported numbers, and the only interpretation layer is mapping the SEC's documented transaction codes to readable labels. There is no language model in the path to hallucinate a number. That also keeps the cost floor near zero, so the price reflects the normalization work, not an inference bill. ### How it compares to the alternatives | Approach | Normalized fields | Codes decoded | Per-filing aggregates | Derivatives | Agent-callable | |---|---|---|---|---|---| | Raw EDGAR XML / full-text search | — | — | — | raw only | — (you parse it) | | Generic web scraper on a finance site | partial | sometimes | — | inconsistent | brittle | | **SEC Insider Trades** | yes | yes | yes | yes | yes | Raw EDGAR is authoritative but unstructured — you own the parsing, the code table, and the derivative-table edge cases. A scraper pointed at a third-party finance site inherits that site's layout changes and gaps. This Actor goes straight to the primary source and returns a stable, documented JSON shape. ### Input | Field | Type | Required | Default | Description | |---|---|---|---|---| | `identifiers` | array of strings | yes | — | Tickers or 10-digit CIKs (1–50). Tickers resolve to CIK via SEC's official map; `BRK.B`/`BRK-B` variants are handled. | | `formTypes` | array of strings | | `["4"]` | Which ownership forms to include: `4` (changes — buys/sells), `3` (initial holdings), `5` (annual). Validated at runtime. | | `maxFilings` | integer | | `20` | Max filings per company, newest first (1–100). Bounds runtime and cost (one charge per filing). | | `sinceDate` | string | | — | Optional ISO date floor (`YYYY-MM-DD`); only filings filed on/after are returned. Blank = most recent regardless of date. | One dataset record is produced per filing. Filings come from the issuer's recent EDGAR history (the latest ~1000 filings); deep historical archives beyond that window are out of scope. ### Output One record per insider filing. Nullable fields are `null` on a failed record. ```json { "identifier": "AAPL", "status": "completed", "cik": "0000320193", "issuerName": "Apple Inc.", "issuerTicker": "AAPL", "formType": "4", "filingDate": "2026-05-29", "periodOfReport": "2026-05-27", "accessionNumber": "0001140361-26-023363", "reportingOwner": { "name": "LEVINSON ARTHUR D", "cik": "0001214128", "isDirector": true, "isOfficer": false, "isTenPercentOwner": false, "isOther": false, "officerTitle": null, "relationship": "Director" }, "transactions": [ { "securityTitle": "Common Stock", "transactionDate": "2026-05-27", "transactionCode": "S", "transactionType": "Open-market sale", "acquiredDisposed": "D", "shares": 50000, "pricePerShare": 311.02, "transactionValue": 15551000.0, "sharesOwnedAfter": 3764576, "directOrIndirect": "D", "isDerivative": false, "underlyingSecurity": null, "underlyingShares": null, "exercisePrice": null, "expirationDate": null } ], "summary": { "transactionCount": 1, "totalAcquiredValue": 0.0, "totalDisposedValue": 15551000.0, "netShares": -50000 }, "sourceFilingUrl": "https://www.sec.gov/Archives/edgar/data/320193/000114036126023363/form4.xml", "error": null, "notice": "Figures are from public SEC EDGAR filings (see sourceFilingUrl); parsing is best-effort and provided as-is, not investment advice — verify against the primary filing before relying on any value." } ```` A failed record carries `status: "failed"` and an `error` tag (e.g. `unresolved-identifier`, `no-insider-filings`, `xml-fetch-failed`) with `transactions: []`. ### Example Input — latest 10 insider transactions at each of two companies, since a date: ```json { "identifiers": ["AAPL", "NVDA"], "formTypes": ["4"], "maxFilings": 10, "sinceDate": "2026-01-01" } ``` ```bash curl -X POST "https://api.apify.com/v2/acts/shelvick~sec-insider-trades/run-sync-get-dataset-items?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"identifiers":["AAPL","NVDA"],"formTypes":["4"],"maxFilings":10,"sinceDate":"2026-01-01"}' ``` ```python from apify_client import ApifyClient client = ApifyClient("YOUR_TOKEN") run = client.actor("shelvick/sec-insider-trades").call( run_input={"identifiers": ["AAPL", "NVDA"], "formTypes": ["4"], "maxFilings": 10} ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["issuerTicker"], item["reportingOwner"]["relationship"], item["summary"]) ``` ### Calling from an AI agent **Apify MCP server (`mcp.apify.com`)** — the Actor is exposed as a callable tool whose input schema is self-documenting, so an LLM can construct a valid call from the tool description alone (ticker or CIK in; normalized insider filings out). Pay per call via x402 (USDC on Base) or Skyfire managed tokens. **Apify SDK (Python)** — `from apify_client import ApifyClient`, then `client.actor("shelvick/sec-insider-trades").call(run_input=...)` and iterate the dataset (see the example above). **REST API** — `POST /v2/acts/shelvick~sec-insider-trades/run-sync-get-dataset-items?token=...` for synchronous runs; the async `/runs` endpoint for large multi-company pulls that may exceed the 5-minute sync window. ### Pricing Pay-per-event, billed only on success: one charge per insider filing that is fetched and parsed, after that record is pushed to the dataset. Companies that don't resolve, and filings that can't be retrieved or parsed, are **free**. Because billing is per filing, `maxFilings` is also your spend cap — a quick latest-activity scan is a handful of charges; a deep multi-company pull scales linearly and is bounded by your run's max-charge setting. See the **Pricing** tab on this Store page for the current per-event rate and any active subscriber discounts. Design notes: [www.scotthelvick.com/tools/sec-insider-trades](https://www.scotthelvick.com/tools/sec-insider-trades) ### Behavior **Run-level failures (rare)** — input validation only: an empty `identifiers` list, more than 50 identifiers, an unknown value in `formTypes`, or `maxFilings` out of the 1–100 range are rejected before any work. **Per-record outcomes (common)** — each company/filing yields a record; failures are isolated and never charged: - `unresolved-identifier` — the ticker/CIK didn't resolve in SEC's map. - `no-insider-filings` — the company has no filings of the requested form type(s) in the recent window. - `submissions-fetch-failed` / `xml-fetch-failed` — SEC returned an HTTP error for the filing list or a document. - `xml-parse-failed` / `not-an-ownership-document` — the document wasn't parseable ownership XML. **Performance** — requests are paced under SEC's ~10 requests/second fair-access ceiling. Cost is one filing-list fetch per company plus one document fetch per filing, so wall-clock scales with total filings: a single company at the default `maxFilings` finishes in a few seconds; a 50-company pull at depth runs longer and may need the async endpoint rather than the 5-minute sync window. ### FAQ **Do you charge for a company with no insider filings?** No. A company that doesn't resolve, or has no filings of the requested type, returns a `failed` record and is not charged. You only pay per filing actually fetched and parsed. **How do I get just buys, or just sells?** The Actor returns all transactions in each filing; filter on `transactions[].transactionCode` (`P` = purchase, `S` = sale) or `acquiredDisposed` (`A`/`D`) in your own code. The per-filing `summary` already separates acquired vs disposed value. **Why is a price `0` on some transactions?** Grants, gifts, and certain exempt transactions have no market price — they're reported with a zero or absent price-per-share. Those rows still appear, with `transactionValue` of `0` or `null`. **How far back can I go?** The Actor reads the issuer's recent EDGAR filing window (the latest ~1000 filings) and takes the newest `maxFilings` after any `sinceDate`. Deep historical archives beyond that window aren't fetched in this version. **Can I pass a CIK instead of a ticker?** Yes — any mix of tickers and 10-digit CIKs (zero-padding optional). CIKs skip the ticker-map lookup. ### What this doesn't do - **No real-time alerting.** It returns the current state of recent filings on demand; it isn't a streaming feed or a push notifier. - **No analysis or signals.** It returns the transactions as filed — no buy/sell scoring, sentiment, or recommendations. It is not investment advice. - **No Form 13D/13F or institutional holdings.** This is insider ownership (Forms 3/4/5), not activist stakes or fund holdings. - **No full historical backfill.** Only the recent EDGAR filing window, not the entire multi-decade archive. - **No deduplication of amended filings.** Amendments are returned as their own records; reconcile them yourself if needed. For standardized company **financial statements** (income statement, balance sheet, cash flow) from SEC XBRL, use a fundamentals-normalization Actor instead. For company **enforcement and litigation history**, use a regulatory-records profiler. For arbitrary page-to-JSON extraction from non-EDGAR sources, use a structured-extraction Actor. # Actor input Schema ## `identifiers` (type: `array`): Companies whose insider filings to fetch, as ticker symbols (e.g. AAPL, BRK.B) or 10-digit SEC CIK numbers (zero-padding optional). Tickers are resolved to CIK via SEC's official ticker map. Insider Form 3/4/5 filings are read from the issuer's EDGAR filing history. One dataset record is produced per filing. Public SEC data only; 1-50 companies per run. ## `formTypes` (type: `array`): Which insider ownership form types to include. Valid values: 4 (changes in ownership — the open-market buys and sells), 3 (initial statement of holdings), 5 (annual statement of deferred/exempt transactions). Defaults to 4 only, which carries the buy/sell signal most users want. Values are validated at runtime; unknown values are rejected with a clear error. ## `maxFilings` (type: `integer`): Maximum number of matching insider filings to fetch per company, newest first. Bounds both run time and cost — one charge per filing parsed. Increase for a deeper history; lower for a quick scan of the latest activity. ## `sinceDate` (type: `string`): Optional ISO date filter (YYYY-MM-DD). When set, only filings filed on or after this date are returned, applied before the max-filings cap. Leave blank to take the most recent filings regardless of date. Useful for monitoring recent insider activity since a known point in time. ## Actor input object example ```json { "identifiers": [ "AAPL", "NVDA" ], "formTypes": [ "4" ], "maxFilings": 20 } ``` # Actor output Schema ## `results` (type: `string`): Parsed insider-filing records for this run. # 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 = { "identifiers": [ "AAPL", "NVDA" ], "formTypes": [ "4" ], "maxFilings": 20, "sinceDate": "" }; // Run the Actor and wait for it to finish const run = await client.actor("shelvick/sec-insider-trades").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 = { "identifiers": [ "AAPL", "NVDA", ], "formTypes": ["4"], "maxFilings": 20, "sinceDate": "", } # Run the Actor and wait for it to finish run = client.actor("shelvick/sec-insider-trades").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 '{ "identifiers": [ "AAPL", "NVDA" ], "formTypes": [ "4" ], "maxFilings": 20, "sinceDate": "" }' | apify call shelvick/sec-insider-trades --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=shelvick/sec-insider-trades", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "SEC Insider Trades — EDGAR Form 4 Buys & Sells as JSON", "description": "Track corporate insider trading from SEC EDGAR. Give a ticker or CIK; get normalized Form 4/3/5 insider transactions as JSON: who traded (officer, director, 10% owner), buy/sell/grant/exercise, shares, price, value, shares held after, and dates. Deterministic parsing of public SEC data.", "version": "0.0", "x-build-id": "Lku5M4YAgCBd7QGUu" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/shelvick~sec-insider-trades/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-shelvick-sec-insider-trades", "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/shelvick~sec-insider-trades/runs": { "post": { "operationId": "runs-sync-shelvick-sec-insider-trades", "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/shelvick~sec-insider-trades/run-sync": { "post": { "operationId": "run-sync-shelvick-sec-insider-trades", "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", "required": [ "identifiers" ], "properties": { "identifiers": { "title": "Companies (tickers or CIKs)", "type": "array", "description": "Companies whose insider filings to fetch, as ticker symbols (e.g. AAPL, BRK.B) or 10-digit SEC CIK numbers (zero-padding optional). Tickers are resolved to CIK via SEC's official ticker map. Insider Form 3/4/5 filings are read from the issuer's EDGAR filing history. One dataset record is produced per filing. Public SEC data only; 1-50 companies per run.", "items": { "type": "string" } }, "formTypes": { "title": "Filing types to include", "type": "array", "description": "Which insider ownership form types to include. Valid values: 4 (changes in ownership — the open-market buys and sells), 3 (initial statement of holdings), 5 (annual statement of deferred/exempt transactions). Defaults to 4 only, which carries the buy/sell signal most users want. Values are validated at runtime; unknown values are rejected with a clear error.", "default": [ "4" ], "items": { "type": "string" } }, "maxFilings": { "title": "Max filings per company", "minimum": 1, "maximum": 100, "type": "integer", "description": "Maximum number of matching insider filings to fetch per company, newest first. Bounds both run time and cost — one charge per filing parsed. Increase for a deeper history; lower for a quick scan of the latest activity.", "default": 20 }, "sinceDate": { "title": "Only filings on/after (YYYY-MM-DD)", "type": "string", "description": "Optional ISO date filter (YYYY-MM-DD). When set, only filings filed on or after this date are returned, applied before the max-filings cap. Leave blank to take the most recent filings regardless of date. Useful for monitoring recent insider activity since a known point in time." } } }, "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 } } } } } } } } } } ```