OpenInsider Scraper: 18 Data Fields, Up to 1,000 Free Results/Month

Each scraped record carries 18 output fields, capturing essential transaction details including ticker, insider name, executive title, shares traded, transaction price, and direct SEC filing links. Corporate insider filing data is gathered directly from OpenInsider.com, requiring no API keys or proxy setups. You can filter transactions by stock ticker, minimum dollar value, or trade date ranges to extract targeted intelligence. This scraper is designed for financial analysts and developers who need structured Form 4 data. It is not suitable for those looking for international markets, as OpenInsider only tracks US SEC filings.

Try it: open OpenInsider Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try OpenInsider Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of OpenInsider Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 20, so a first run returns at most 20 results and costs at most $0.10 in result charges. That is enough to see the real shape of the data before deciding anything.

OpenInsider Scraper was last updated on 2026-06-11. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 680,173 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run OpenInsider Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The maxItems setting is the key control that dictates the total cost of each run. Because Apify charges a flat rate of $5.00 per 1,000 results on the free plan, setting an explicit cap ensures you remain within your expected monthly budget. To test your integration cheaply, use the prefilled maxItems cap of 20 to limit result fees to a maximum of $0.10 per test run.

How do you run OpenInsider Scraper from the API?

The schema marks 1 of its 9 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~open-insider-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"recentTransactions","transactionTypeMode":"all","transactionType":"","maxItems":20}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "recentTransactions",
  "transactionTypeMode": "all",
  "transactionType": "",
  "maxItems": 20
}

run = client.actor("crawlerbros~open-insider-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "recentTransactions",
  "transactionTypeMode": "all",
  "transactionType": "",
  "maxItems": 20
}

const run = await client.actor('crawlerbros~open-insider-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which OpenInsider Scraper inputs matter, and which can you skip?

The primary control is the mode parameter, which dictates whether you are scraping recent transactions, viewing history for a specific ticker, or using the advanced screener. For your first execution, leave transactionType and the value filters blank and use the default recentTransactions mode to quickly understand how the database behaves.

• mode (string): What to scrape. Default: "recentTransactions".
• ticker (string): Stock ticker symbol, e.g. AAPL, MSFT, TSLA. Used in byTicker mode or as a screener filter.
• transactionTypeMode (string): Which transaction categories to fetch in recentTransactions mode. Default: "all".
• transactionType (string): Filter output to a specific transaction type. Leave blank for all types. Default: "".
• dateRangeFrom (string): Only include trades on or after this date (ISO format: 2024-01-01).
• dateRangeTo (string): Only include trades on or before this date (ISO format: 2024-12-31).
• minTotalValue (integer): Only include trades with absolute total value at or above this threshold (USD).
• maxTotalValue (integer): Only include trades with absolute total value at or below this threshold (USD).
• maxItems (integer): Hard cap on total records emitted. Default: 100.

Fixed-choice controls: mode accepts recentTransactions (latest buys + sales), byTicker (all trades for a specific stock), screener (advanced filter); transactionTypeMode accepts all (buys + sales), buys (Purchases only), sales (Sales only); transactionType accepts 9 values (default ""), including "" (All types), Purchase, Sale, Sale+OE (Sale + Option Exercise).

What does OpenInsider Scraper return?

The returned records contain clean corporate data points, including CIK numbers, absolute transaction values, and insider titles, making it ideal for institutional trend tracking. Note that the output does not include corporate balance sheets or historical stock prices, as the source is strictly limited to SEC Form 4 filings.

• ticker (e.g. AAPL)
• companyName (e.g. Apple Inc.)
• insiderName (e.g. Levinson Arthur D)
• insiderTitle (e.g. Dir)
• transactionType (e.g. Sale)
• transactionTypeRaw (e.g. S - Sale)
• sharesTraded (e.g. -50000)
• sharesOwned (e.g. 3755576)
• price (e.g. 311.02)
• totalValue (e.g. -15551000)
• filingDate (e.g. 2026-05-29 18:30:27)
• tradeDate (e.g. 2026-05-27)
• secFilingUrl (e.g. http://www.sec.gov/Archives/edgar/data/320193...)
• insiderProfileUrl (e.g. https://openinsider.com/insider/Levinson-Arth...)
• insiderCik (e.g. 1214128)
• sourceUrl (e.g. https://openinsider.com/latest-sales)
• scrapedAt (e.g. 2026-06-10T12:00:00+00:00)
• recordType (e.g. insiderTrade)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open OpenInsider Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select the operational mode in the mode selector, choosing either recentTransactions, byTicker, or screener based on your data scope.
2. If you selected byTicker, input a valid stock ticker symbol in the ticker field, such as AAPL or TSLA.
3. Configure the transactionTypeMode selector when using the recentTransactions mode to filter specifically for buys or sales.
4. Apply precise dates using the dateRangeFrom and dateRangeTo fields in YYYY-MM-DD format to isolate specific filing periods.
5. Establish absolute financial limits on your search by entering USD thresholds in minTotalValue or maxTotalValue.
6. Set the maxItems field to 20 for a first run to verify the connection and format without using up your platform resources.
7. Start the run and open the dataset view once the state changes to succeeded.
8. Check the returned dataset records to verify that fields like insiderName, sharesTraded, totalValue, and secFilingUrl contain expected values.

How do you apply it? Three worked playbooks

These are OpenInsider Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Trading signals

Outcome: Identify stocks where insiders are buying heavily

Configure: Set mode to "screener", set transactionType to "Purchase", and configure minTotalValue to 50000 to filter out small trades.

Working method: Execute the scraper using the screener mode to identify high-value buy transactions across all active tickers. Start with a broad sweep of recent filings, then evaluate the aggregate purchasing volume of the top five companies to isolate where directors or C-suite executives are deploying their own capital.

Deliverable: A structured dataset containing active insider buying activity, featuring ticker symbols, buyer titles, exact transaction values, and SEC filing dates.

Stop condition: The runner emits records where transactionType is recorded as Sale, indicating a failure in the API transaction filter.

Use case 2: Compliance monitoring

Outcome: Track Form 4 filings for specific companies

Configure: Set mode to "byTicker", set ticker to a target stock symbol like "AAPL", and leave transactionType blank to monitor all action types.

Working method: Set up a recurring schedule for this Actor to run daily, capturing any newly submitted Form 4 filings for your target stock. Compare each daily dataset against the previous day's run to detect new filings, checking the filingDate field to ensure you do not process duplicate historical records.

Deliverable: An append-ready file or database-ready feed containing every newly declared corporate insider transaction for your specified tickers.

Stop condition: The run finishes with zero results despite a confirmed SEC filing occurring within the target date range.

Use case 3: Due diligence

Outcome: Check executive selling patterns before investing

Configure: Set mode to "byTicker", set ticker to the target stock symbol, set dateRangeFrom to "2025-01-01", and set transactionType to "Sale".

Working method: Execute the scraper for the target stock ticker over a multi-month period to retrieve historical sales. Calculate the ratio of shares sold to total shares owned for key executives like the CEO and CFO to evaluate whether their liquidation pattern represents normal compensation diversification or abnormal divestment.

Deliverable: A historical export of executive sales containing sharesTraded, sharesOwned, and totalValue to calculate selling ratios.

Stop condition: The sharesOwned field returns null values, preventing a calculation of the relative size of the insider's remaining equity.

What breaks, and how do you design around it?

If you hit the default record limit on a busy trading day, you must adjust the maxItems limit up to its maximum ceiling of 2,000. When trying to gather massive datasets over broad timeframes, segment your requests into separate runs by using specific dateRangeFrom and dateRangeTo parameters. This keeps your datasets manageable and prevents runs from hitting execution boundaries.

When should you not use OpenInsider Scraper?

Do not use this Actor if you need to track global equity markets, as OpenInsider aggregates data strictly for US-listed companies filing with the SEC. If you need Singapore-listed equity data instead, you should use SGX Company Announcements Scraper to capture official regulatory filings from the Singapore Exchange. Additionally, if your investment research focuses on major institutional fund holdings rather than individual corporate executive transactions, do not use this scraper; instead, use SEC EDGAR 13F Institutional Holdings Scraper to parse 13F filings. Finally, if you require underlying corporate entity registration data such as registered agent details or official capital structures rather than market trade histories, look at specialized state registry tools like the Wisconsin DFI Business Entity Search Scraper.

What should you check before trusting the output?

• Verify that the totalValue field matches your minTotalValue threshold; set up an automated schema check if any returned value falls below this limit.
• Check that sharesTraded is negative for records where transactionType is Sale and positive when transactionType is Purchase.
• Monitor the presence of the secFilingUrl field and halt scheduled tasks if more than five percent of returned records have null or blank SEC links.
• Validate that the date format in filingDate and tradeDate conforms strictly to standard ISO and YYYY-MM-DD structures.
• Check the scrapedAt timestamp on each record to ensure that your scheduled run is capturing newly published SEC disclosures.

None of this proves a record is correct. It gives a scheduled OpenInsider Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to scrape 10,000 records?

At the free-plan price of $5.00 per 1,000 results, scraping 10,000 records will cost $50.00 in result charges. Keep in mind that Apify also bills platform usage for CPU and memory runtime on top of the result fee, so the final cost will vary slightly depending on your plan's platform rates.

Can I test this scraper without paying anything?

Yes. Apify's free plan includes $5.00 of monthly usage with no credit card required. This is enough to cover up to 1,000 results of this Actor before any run-start charges, allowing you to thoroughly test your data pipeline for free.

Does this Actor require proxies to run reliably?

No. OpenInsider.com is a public website with no active bot protection. The Actor uses standard HTTP requests without proxy overhead, keeping your data collection process simple, reliable, and fast.

Are there negative values in the sharesTraded field?

Yes. Negative values are expected and represent insider sales or other equity dispositions. Positive values indicate that the executive purchased or was awarded shares.

What is the difference between filingDate and tradeDate?

The filingDate timestamp shows exactly when the Form 4 was submitted and processed by the SEC. The tradeDate shows the actual calendar day the executive executed the stock transaction.

Where to go next

When you are ready to run it, open OpenInsider Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the OpenInsider Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Singapore HDB Resale Flat Prices Scraper: Scrape Singapore HDB resale flat transaction data from the official data.gov.sg open API.
• TCG Card Scraper - Magic, Pokémon & More with Prices: Scrape trading card data and prices from Scryfall (MTG) and the Pokémon TCG API.
• Poland KRS Company Registry Scraper: Look up companies, foundations, and associations in Poland's KRS (Krajowy Rejestr Sadowy) by KRS number.
• SEC EDGAR 13F Institutional Holdings Scraper: Browse institutional 13F holdings data from SEC EDGAR - track what top hedge funds and mutual funds own.
• Dallas Building Permits Scraper: Scrape City of Dallas building permit records from the official Dallas Open Data portal (dallasopendata.com).
• Wisconsin DFI Business Entity Search Scraper: Search Wisconsin's official Corporate Records registry (apps.dfi.wi.gov).
• EstateSales.net Estate & Moving Sale Listings Scraper: Scrape EstateSales.net - search estate, moving, and auction sale listings by US state, city or ZIP code, filter by real sale type and date range, or pull the site's nationally-featured sales.
• SGX Company Announcements Scraper: Scrape Singapore Exchange (SGX) listed-company announcements and disclosures.

Related guides:

• SEC EDGAR Filings Scraper: 25 Data Fields per Record (2026)
• TikTok Downloader API: Practical Playbooks and Workflows

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-26.

• Actor last updated by its maintainers on 2026-06-11.

• Run outcome figures cover the 30 day public window ending 2026-09-26.

• OpenInsider Scraper on Apify