# Share Offering & Dilution Monitor - SEC Disclosures (`maydit/share-offering-dilution-monitor`) Actor

Monitor SEC offering disclosures with source evidence. Separate primary offerings, resales and shelf capacity; extract stated share counts and prices. No dilution-percent or price predictions.

- **URL**: https://apify.com/maydit/share-offering-dilution-monitor.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 financing disclosure observations

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

![SEC offering stages, stated financing terms and original disclosure evidence](https://api.apify.com/v2/key-value-stores/nemaYfVcrTgloz8Wn/records/share-offering-dilution-monitor-172f6abcd8d0.png?signature=wqse1hpYPbwA32A1UMo7)

### Put each financing disclosure in context

Build a review queue from SEC offering documents: what was registered or offered, which stage the disclosure describes, and which shares or prices are explicitly stated. Keep primary offerings, resales and shelf capacity distinguishable in your research.

Use it for a financing watchlist, filing review or a source-linked research feed. **No API key or proxy is required.** Every row includes review reasons and should be checked against its cited document.

[Open Actor](https://console.apify.com/actors/pmMVLNURklHbprTHn/input) · [Read the results](#read-the-results) · [Saved monitoring](#build-a-saved-financing-watchlist) · [Coverage and reference](#coverage-and-reference)

### Try one offering document

Start with Seaport Therapeutics’ fixed priced IPO prospectus to inspect a filing’s stage, stated share count and per-share price together.

1. Open the Actor and select the **JSON** input editor.
2. Paste the input below and click **Start**.
3. Open the output table. Read **Offering stage** and **Review reasons**, then follow **SEC source** to the document.

```json
{
  "documentUrls": [
    "https://www.sec.gov/Archives/edgar/data/2042347/000119312526201758/d73463d424b4.htm"
  ],
  "maxResults": 3
}
```

Prefer a current sample? Click **Start** with the default input to inspect Seaport Therapeutics’ recent filings (CIK 2042347). The fixed prospectus above is a historical example; the default follows the SEC’s current recent-filings response.

### Read the results

| Your research question | Fields to inspect |
| --- | --- |
| Which company and filing? | `companyName`, `tickers`, `form` |
| What stage is explicitly disclosed? | `eventStage` |
| Is this primary issuance, resale or another role? | `offeringRole` |
| Which terms are actually stated? | `sharesOffered`, `offeringPricePerShare`, `grossProceeds` |
| What is capacity rather than completed issuance? | `registrationOrSalesCapacity`, read with `eventStage` |
| What needs a closer look? | `reviewReasons`, warrant/convertible mentions and evidence excerpts |
| Where did it come from, and when? | `sourceUrl`, `filingDate`, `acceptedAt`, `observedAt` |

**A shelf registration is capacity; a priced offering is not automatically completed issuance.** Missing supported terms remain null. Each document is a separate observation, so multiple filings may discuss the same deal. The Actor does not calculate percentage dilution or trading returns.

#### Check coverage before using the export

Export the dataset as **JSON or CSV** from the run’s output panel. Each observation includes the original SEC URL, accession, filing date, acceptance timestamp when available, and observation time.

In the Output tab, open **Run report** for a readable coverage report or **Coverage and history summary** (`SUMMARY`) for machine-readable source coverage, unsupported cases, failures, saved rows and limits. Reports create no paid dataset rows. A successful run can have partial coverage; SUMMARY marks it explicitly.

### Usage and pricing

**$5 per 1,000 saved observations on the FREE plan** ($0.005 per observation), plus the applicable Actor Start charge. The [Pricing tab](https://apify.com/maydit/share-offering-dilution-monitor/pricing) is authoritative for your plan and current charges.

One confirmed saved observation is one result. Failure messages and run reports are never charged as result rows. Set Apify’s spending limit and `maxResults` before scheduling. The Actor checks the remaining dataset-item charge allowance before writing.

### Build a saved financing watchlist

#### Follow recent company filings

Review Seaport’s recent offering and registration documents with distinct filing identities.

```json
{
  "ciks": [
    "2042347"
  ],
  "maxFilingsPerCompany": 3,
  "maxResults": 10
}
```

Replace the sample CIK with your companies’ exact SEC identifiers. Current SEC ticker arrays are included for convenience; they are not historical ticker mappings.

#### Save a baseline, then follow changes

1. Keep your chosen watchlist and enable **Compare with saved observations** (`comparePrevious`).
2. Choose a **History name** (`snapshotName`) and dedicated **History storage** (`stateStoreName`), then run once. First observations establish a new baseline.
3. Save the input as an Apify task. Reuse the same watchlist, filing limit, date filter and history names on later runs.
4. Enable **Save only new or changed observations** (`onlyChanges`) for incremental output. An unchanged repeat can correctly save zero rows.

Schedule the saved task at a cadence suited to your research. Use one writer per history scope; overlapping runs are unsupported.

#### Compare with the earlier registration

Review the earlier amended registration without treating a proposed offering as completed.

```json
{
  "documentUrls": [
    "https://www.sec.gov/Archives/edgar/data/2042347/000119312526178716/d73463ds1a.htm"
  ],
  "maxResults": 3
}
```

Run this fixed document separately to inspect an earlier disclosure stage. It remains a distinct filing observation; the Actor does not automatically merge it with the priced prospectus.

### Coverage and reference

#### Supported disclosures

The Actor reads selected recent S-1/S-3 registrations and amendments, 424B1–5 prospectuses and 8-K disclosures under Items 1.01, 3.02, 7.01 or 8.01. If an 8-K primary document has no supported disclosure, the first HTML EX-99.1 is checked. It distinguishes priced offerings, completed issuance, proposed/registered offerings, resale registrations, shelf capacity and at-the-market sales-agreement capacity using explicit source wording.

#### Terms, currency and review flags

Stated share counts, per-share prices, gross proceeds, registration/sales capacity and warrant share counts are optional fields. They are populated only for supported wording and otherwise remain null. Currency is `dollar_unspecified` when the text uses a dollar sign without an unambiguous ISO currency. Evidence excerpts and review reasons accompany every observation. Financing prose is varied: every row is marked `rule_based_review_required`. Review the cited document before treating extracted terms as a complete deal description.

Pure share-count observations can have a null currency. A missing term is not treated as zero.

#### Filing identity and extraction limits

One filing document is one observation. Different accessions are separate disclosures, and may discuss the same financing. The Actor does not merge deals automatically, assume a shelf has been sold, infer percentage dilution, treat share authorizations as issued shares, compute discounts to a market price, or predict trading returns. Warrant and convertible mentions do not decode all exercise/conversion terms. The parser binds terms to the first supported financing paragraph and a narrow explicit current-offering pricing supplement. Later financing paragraphs are not merged, and a review reason records that limitation. The parser focuses on the document’s front cover or opening event discussion; it is not a comprehensive cap-table model.

Conflicting historical and current event wording is flagged for review rather than combined into a completed current offering.

#### Inputs and saved-history boundaries

- `ciks`: up to 10 exact SEC company identifiers. The source checks company identity before parsing filings.
- `documentUrls`: up to 10 specific official SEC HTML documents, validated against their accession index. Direct documents suppress the sample fallback. Combine them with explicit CIKs when intentional.
- `maxFilingsPerCompany`: 1–10 matching filings from the SEC’s current recent-submissions response; default 3. Old archive pages are not scanned.
- `filedFrom`: optional inclusive filing-date filter. Historical direct documents with unavailable filing dates do not pass a date filter.
- `comparePrevious`: save and compare observations in your named key-value store. The first run is a new baseline.
- `onlyChanges`: implies comparison and suppresses unchanged observations. A repeat can correctly save zero rows.
- `snapshotName` / `stateStoreName`: isolate workflows. Scope includes the exact watchlist, document URLs, date filter and filing bound. Use one writer per scope; overlapping runs are unsupported.

Only confirmed saved dataset rows advance history. A source failure cannot erase previous observations. No disappearance or deletion is inferred from bounded or missing filings.

#### Source access and run limits

SEC requests are sequential with at least 1.1 seconds between request starts; every request has a deadline and an 8 MiB response cap. There are no paid providers, proxies, generative-model calls or credential requirements. SEC refusals and timeouts remain visible in SUMMARY. Coordinate parallel runs to respect the SEC’s aggregate fair-access policy.

#### Source and interpretation

Data comes from official [SEC submissions APIs](https://www.sec.gov/search-filings/edgar-application-programming-interfaces) and the [EDGAR archive](https://www.sec.gov/edgar/search/). See [SEC developer resources](https://www.sec.gov/about/developer-resources) for fair access. Filing acceptance time, disclosure/event date and observation time are different; this Actor does not promise real-time exchange data or a trading signal.

Questions about an extraction? Include the run ID, source URL and relevant excerpt when reporting it through the Actor’s Issues tab.

[Explore Maydit data tools](https://mayd-it.com/data-tools/) · [Quality dashboard](https://mayd-it.com/data-tools/quality/) · [Workflow recipes](https://mayd-it.com/data-tools/workflows/)

# Actor input Schema

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

Up to 10 SEC company CIKs (digits only). Omitted or empty uses Seaport Therapeutics (2042347) unless direct documents are supplied. Company names and ticker arrays come from SEC submissions; no fuzzy ticker matching.

## `documentUrls` (type: `array`):

Up to 10 HTTPS www.sec.gov/Archives/edgar/data HTML URLs. Each must appear in its official accession index. Supplying documents suppresses the sample company fallback. Can be combined with explicit CIKs.

## `maxFilingsPerCompany` (type: `integer`):

Inspect recent S-1/S-3 variants, 424B1-5 and selected 8-K items 1.01/3.02/7.01/8.01. 8-K EX-99.1 is checked only when the primary document has no supported disclosure.

## `filedFrom` (type: `string`):

Optional YYYY-MM-DD. Filters recent filings by SEC filing date. Does not load old submission archives; direct documents with an unknown filing date are excluded when this filter is set.

## `maxResults` (type: `integer`):

Maximum confirmed dataset rows. Skipped unchanged observations do not count. Source requests remain bounded separately by the watchlist and filing limit.

## `comparePrevious` (type: `boolean`):

First observations are new. Later observations are changed or unchanged; only confirmed saved rows can advance history.

## `onlyChanges` (type: `boolean`):

Implies comparePrevious. A fully unchanged run correctly saves zero rows. The initial comparison saves new observations.

## `snapshotName` (type: `string`):

1-80 letters, numbers, underscores or hyphens. History scope includes sorted CIKs/documents, filing bound and date filter. Use only one writer per namespace.

## `stateStoreName` (type: `string`):

3-63 letters, numbers or hyphens. Read/written only when comparisons are requested. Use your own dedicated store to isolate a workflow.

## `maxRunSeconds` (type: `integer`):

Includes source and history work, also bounded by the platform deadline minus 25 seconds.

## Actor input object example

```json
{
  "ciks": [
    "2042347"
  ],
  "documentUrls": [],
  "maxFilingsPerCompany": 3,
  "maxResults": 10,
  "comparePrevious": false,
  "onlyChanges": false,
  "snapshotName": "default",
  "stateStoreName": "maydit-share-offering-dilution",
  "maxRunSeconds": 240
}
```

# Actor output Schema

## `results` (type: `string`):

Source-backed extracted guidance or offering observations. Failures are never synthetic paid rows.

## `runReport` (type: `string`):

Readable coverage, limits and history outcome from this run.

## `summary` (type: `string`):

Source documents, unsupported cases, time/spending limits and saved-history status.

## `csvExport` (type: `string`):

Download the current run observations for spreadsheets.

# 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 = {
    "ciks": [
        "2042347"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/share-offering-dilution-monitor").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 = { "ciks": ["2042347"] }

# Run the Actor and wait for it to finish
run = client.actor("maydit/share-offering-dilution-monitor").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 '{
  "ciks": [
    "2042347"
  ]
}' |
apify call maydit/share-offering-dilution-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maydit/share-offering-dilution-monitor"
        }
    }
}
```

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/pmMVLNURklHbprTHn/builds/RC2I4lfT4YHzyRFpU/openapi.json