# Reg CF Crowdfunding Lifecycle & Outcomes Monitor — SEC EDGAR (`malonestar/reg-cf-lifecycle-monitor`) Actor

Track US Regulation Crowdfunding beyond the offering feed: new Form C filings, C-U funding progress, C-AR annual reports with two-year revenue and net income, and C-TR/C-W terminations — straight from SEC EDGAR, keyless. Feed, issuer, outcomes and delta modes with honest per-row provenance.

- **URL**: https://apify.com/malonestar/reg-cf-lifecycle-monitor.md
- **Developed by:** [Kyle Maloney](https://apify.com/malonestar) (community)
- **Categories:** Business, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.50 / 1,000 reg cf lifecycle results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Reg CF Crowdfunding Lifecycle & Outcomes Monitor (SEC EDGAR)

Track the **full Regulation Crowdfunding lifecycle** — not just new offerings.
Every Reg CF company files a paper trail with the SEC, and this actor reads all
of it, straight from EDGAR, keylessly:

| Form | What it means | `event_class` |
|---|---|---|
| **C** | New crowdfunding offering launched (with target/max amounts, security type, deadline and the **funding portal**) | `new_offering` |
| **C-U** | Progress update — including the outcome text **"Offering closed successfully" / "Offering closed unsuccessfully"** | `progress_update` |
| **C-AR** | Annual report — the issuer's **two-year financials**: total assets, cash, receivables, short/long-term debt, revenue, COGS, taxes, net income, employees | `annual_report` |
| **C-TR** | Termination of reporting | `termination` |
| **C-W** | Offering withdrawal | `withdrawal` |

Most crowdfunding data products stop at the Form C feed. The lifecycle is where
the real questions live: **What happened to the companies after they raised?
Which offerings closed successfully? What revenue are last year's crowdfunded
startups actually reporting now?** Form C-AR answers that with audited-or-not
but SEC-filed numbers, and this actor parses them into flat, CSV-friendly rows
with derived `revenue_growth_pct`, `net_income_delta` and
`is_profitable_current`.

### Who this is for

- **Crowdfunding investors** — see the C-AR financials of companies you backed
  (or are about to back), and catch C-TR terminations / C-W withdrawals early.
- **Funding portals & platforms** — monitor your own issuers' compliance
  filings, or benchmark a competitor portal's deal flow (`portalQuery`).
- **Journalists & researchers** — the Reg CF outcomes story (success rates,
  post-raise revenue, shutdowns) is sitting in these five form types.
- **B2B lead generation** — a company that just raised via Reg CF has money and
  momentum; a C-AR filer reports real revenue, employees, a website and a
  business address. Filter by state for territory-scoped lists.
- **AI agents (MCP)** — every input and output field is described; see below.

### Modes

#### `feed` — lifecycle events in a date window

```json
{
  "mode": "feed",
  "formTypes": ["C", "C-U", "C-AR", "C-TR", "C-W"],
  "startDate": "2026-08-01",
  "maxResults": 200
}
```

One row per filing, newest first, with issuer name, CIK, state/city,
incorporation state, SEC file number, accession, and direct EDGAR URLs.
Add `"enrichXml": true` to also pull each filing's XML for the funding portal,
offering amounts, C-U progress text and financials (one polite EDGAR request
per row — slower, richer).

#### `outcomes` — C-AR annual reports with two-year financials

```json
{ "mode": "outcomes", "startDate": "2026-07-01", "state": "TX", "maxResults": 100 }
```

Always XML-enriched. Each row carries both fiscal years of all nine financial
metrics plus derived deltas. This is the "what happened after the raise" mode.

#### `issuer` — one company's whole Reg CF history

```json
{ "mode": "issuer", "cik": "1373217", "maxResults": 50 }
```

Every C / C-U / C-AR / C-TR / C-W the issuer ever filed, XML-enriched — the
company's crowdfunding biography in one call. Use `issuerQuery: "Bean Box"`
when you do not know the CIK.

#### `delta` — only what is new since your last run

```json
{ "mode": "delta", "formTypes": ["C-TR", "C-W"], "maxResults": 200 }
```

Cross-run tracking in the named key-value store `reg-cf-lifecycle-baseline`,
keyed by your query scope. The **first** run for a scope stores a baseline and
fails with an explanatory message — it will never bill you the whole feed
labelled "new". Schedule it and get genuinely new events (e.g. every new
termination — a churn signal no one else sells).

### Cost — read this first

Pricing is **pay-per-result**: you pay only for rows written to the dataset,
at the listed price per 1,000 results. `maxResults` (prefill 200) is a **hard
cap on the bill** enforced by a single audited code path — every row carries
`run_max_results_cap`, `rows_emitted_this_run`, `matched_total` and
`results_truncated`, so a capped answer can never masquerade as a complete one.

Typical runs at $10/1,000 results:

| Run | Rows | Cost |
|---|---|---|
| Last 10 days of all lifecycle events (feed) | ~150-250 | ~$1.50-2.50 |
| A month of C-AR outcomes, one state | ~30-80 | ~$0.30-0.80 |
| One issuer's full history | 2-15 | ~$0.02-0.15 |
| Daily delta of terminations/withdrawals | 0-10 | usually pennies |

A run that cannot produce a trustworthy answer — EDGAR unreachable, the source
drift gate failing, an unusable input — **fails loudly and bills nothing**.
A 0-row SUCCESS only ever means the query verifiably matched nothing.

### Data quality & honesty guarantees

- **Live drift gate before any billable row**: (1) the C-AR corpus total must
  clear a floor of 5,000 (measured 5,650 live); (2) a pinned canary filing
  (TRADESTAR RESOURCES CORP C-AR, accession 0001096906-26-001311) must parse
  with the right issuer, period and financials; (3) a negative control (a
  nonsense form type) must return exactly 0 — if EDGAR ever starts ignoring
  query parameters, the run fails rather than shipping a mislabeled feed.
- **State filter is verified twice.** EDGAR's `locationCode` (singular)
  parameter is *silently ignored* by the API — measured live. This actor uses
  the working `locationCodes` parameter AND re-validates every returned row;
  a regression fails the run instead of selling a national feed as one state.
- **`null` is never `0` and never `false`.** A missing financial value is
  `null` (not reported / not fetched — see `xml_status`); `0` means the filing
  literally reported `0.00`. `is_profitable_current` is `null` when net income
  was not read, never a guessed `false`.
- **Dates are normalized, never guessed.** EDGAR XML dates (MM-DD-YYYY) are
  converted to ISO with calendar validation; an impossible date becomes `null`.
  Caller dates are strict `YYYY-MM-DD` — a slash date or month name fails the
  run loudly with a message naming the field, because a guessed date window is
  a silently wrong answer.
- **Paging can never truncate silently.** EDGAR's search API caps result
  windows at 10,000; `maxResults` is capped at 5,000 and the pager hard-stops
  before the window, so the cap is structurally unreachable — and any
  truncation that does occur is disclosed on every row.

### Output fields (63 columns, flat and CSV-friendly)

**Identity & event:** `event_class`, `form`, `form_base`, `is_amendment`,
`accession`, `cik`, `cik_padded`, `file_number`, `issuer_name`,
`file_date_iso`, `period_iso`, `filing_index_url`, `primary_doc_url`.

**Location:** `biz_state`, `biz_city`, `biz_location_raw`,
`incorporation_state`.

**From the filing XML** (when fetched — see `xml_status` / `xml_error`):
`issuer_website`, `legal_status_form`, `date_incorporation_iso`,
`funding_portal_name`, `funding_portal_cik`, `funding_portal_file_number`,
`funding_portal_crd`, `progress_update_text`, `security_offered_type`,
`price_per_security`, `offering_amount`, `max_offering_amount`,
`offering_deadline_iso`, `oversubscription_accepted`, `current_employees`.

**Two-year financials** (C-AR, and also present on C/C-U filings):
`total_assets_current/prior`, `cash_equivalents_current/prior`,
`accounts_receivable_current/prior`, `short_term_debt_current/prior`,
`long_term_debt_current/prior`, `revenue_current/prior`,
`cost_goods_sold_current/prior`, `taxes_paid_current/prior`,
`net_income_current/prior` — plus derived `revenue_delta`,
`revenue_growth_pct`, `net_income_delta`, `is_profitable_current`.

**Delta:** `is_new_since_last_run`, `delta_baseline_status`.

**Run provenance & billing arithmetic:** `mode`, `data_source`,
`retrieved_at`, `drift_gate_status`, `drift_negative_control_status`,
`matched_total`, `results_truncated`, `run_max_results_cap`,
`rows_emitted_this_run`, `query_forms`, `query_start_date`, `query_end_date`,
`query_state`, `query_portal`.

Note: `funding_portal_*` fields come from Form C / C-U XML — C-AR and C-TR
filings do not carry an intermediary block, so those rows have `null` portal
fields with `xml_status: "ok"` (present in the source as absent, not a fetch
failure).

### Use as an MCP tool

This actor is callable by AI agents through Apify's MCP server
(`https://mcp.apify.com`). Every input field has a described schema and every
output column a description, so an agent can chain it: *"find Reg CF companies
in Texas that filed an annual report this quarter with revenue over $1M, then
screen their addresses"*. Billing is unchanged when called as a tool; a run
that cannot answer fails without billing.

Example agent prompt:

> Use reg-cf-lifecycle-monitor with mode "outcomes", startDate 90 days ago and
> state "CA". Return the ten issuers with the highest revenue\_current, with
> their websites and funding portals.

### FAQ

**Where does the data come from?** SEC EDGAR — the full-text search API
(`efts.sec.gov`) for the filing index and each filing's `primary_doc.xml` from
the EDGAR Archives for details and financials. No API key needed; requests are
serialized with SEC's fair-access identification.

**How fresh is it?** EDGAR indexes filings within minutes of acceptance; a
scheduled `delta` run catches new lifecycle events same-day.

**Are the financials audited?** Form C-AR financials are issuer-reported per
Reg CF's tiered review requirements (reviewed or audited depending on raise
size). They are the SEC-filed record, reproduced exactly — this actor never
adjusts or estimates a number.

**Can I get everything since 2016?** Yes — leave `startDate` blank for the
full history (Reg CF began 2016-05-16). For very large pulls, use date windows;
`matched_total` on every row tells you the full universe size behind your page.

**Why did my first delta run fail?** By design: there was no baseline yet, so
"new since last run" had no honest answer. The run stored a baseline, billed
nothing, and the next run returns genuinely new filings.

**What's a funding portal CRD?** The FINRA identifier of the intermediary
(Wefunder, StartEngine, Honeycomb, ...) — useful for joining portal-level
deal-flow analytics.

# Actor input Schema

## `mode` (type: `string`):

What to return. "feed" = Regulation Crowdfunding lifecycle events (Form C offerings, C-U progress updates, C-AR annual reports, C-TR terminations, C-W withdrawals) in a date window. "outcomes" = Form C-AR annual reports with the issuer's two-year financials (total assets, revenue, net income, debt) parsed from each filing's XML. "issuer" = every Reg CF filing for one company (by cik or issuerQuery), XML-enriched. "delta" = only filings new since your last run for this scope, tracked in the named key-value store 'reg-cf-lifecycle-baseline'; the FIRST delta run stores a baseline and fails with an explanatory message rather than billing the whole feed as new.

## `formTypes` (type: `array`):

Which Reg CF form types to include (feed and delta modes; outcomes mode always uses C-AR only). Allowed values: C (new offering), C-U (progress update), C-AR (annual report), C-TR (termination of reporting), C-W (offering withdrawal). Leave empty for all five. Amendments (e.g. C/A) are included under their base form and flagged is\_amendment.

## `startDate` (type: `string`):

Only include filings filed on or after this date. STRICTLY YYYY-MM-DD (e.g. 2026-08-01) — slash dates, month names and compact dates are rejected with a loud failure because they cannot be applied unambiguously. Leave blank for no lower bound (Regulation Crowdfunding began 2016-05-16).

## `endDate` (type: `string`):

Only include filings filed on or before this date. STRICTLY YYYY-MM-DD. Leave blank for no upper bound (today). An unusable value fails the run loudly; nothing is billed.

## `state` (type: `string`):

Optional 2-letter US state/territory code (e.g. TX) filtering on the issuer's principal business address. Applied server-side via the EDGAR locationCodes parameter AND re-validated on every returned row — if EDGAR ever stops applying the filter the run fails loudly instead of shipping a national feed labelled as one state.

## `portalQuery` (type: `string`):

Optional funding-portal (intermediary) name, e.g. "Wefunder Portal" or "Honeycomb Portal". Matched as an exact phrase via EDGAR full-text search against the filing documents (the portal's legal name appears in every Form C / C-U XML), so use the portal's legal name as it appears in filings. This is a document-text match, not a structured field filter.

## `cik` (type: `string`):

SEC CIK number of the issuer for issuer mode, with or without leading zeros (e.g. 1373217). Find it on any EDGAR filing page. issuer mode requires cik or issuerQuery.

## `issuerQuery` (type: `string`):

Company-name phrase for issuer mode when you do not know the CIK, e.g. "Bean Box". Matched as a phrase via EDGAR full-text search; prefer cik for an exact match.

## `enrichXml` (type: `boolean`):

In feed/delta modes, also fetch each filing's primary\_doc.xml to add issuer website, legal status, funding portal name/CIK/CRD, offering amounts and deadline, C-U progress-update text, and the two-year financials. Adds one polite EDGAR request per row (slower). outcomes and issuer modes always enrich. When off, those columns are null with xml\_status="not\_fetched" — null means NOT FETCHED, never "none".

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

Hard cap on rows emitted AND billed this run (newest filings first). Every row carries matched\_total and results\_truncated so a capped answer is never mistaken for a complete one.

## Actor input object example

```json
{
  "mode": "feed",
  "formTypes": [
    "C",
    "C-U",
    "C-AR",
    "C-TR",
    "C-W"
  ],
  "startDate": "2026-08-01",
  "enrichXml": false,
  "maxResults": 200
}
```

# Actor output Schema

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

The default dataset.

# 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 = {
    "mode": "feed",
    "formTypes": [
        "C",
        "C-U",
        "C-AR",
        "C-TR",
        "C-W"
    ],
    "startDate": "2026-08-01",
    "maxResults": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/reg-cf-lifecycle-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 = {
    "mode": "feed",
    "formTypes": [
        "C",
        "C-U",
        "C-AR",
        "C-TR",
        "C-W",
    ],
    "startDate": "2026-08-01",
    "maxResults": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("malonestar/reg-cf-lifecycle-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 '{
  "mode": "feed",
  "formTypes": [
    "C",
    "C-U",
    "C-AR",
    "C-TR",
    "C-W"
  ],
  "startDate": "2026-08-01",
  "maxResults": 200
}' |
apify call malonestar/reg-cf-lifecycle-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,malonestar/reg-cf-lifecycle-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/i7TJhgezjd6HXrHon/builds/OWws3eAGDZv8G6ohH/openapi.json