# Funding Round Tracker — SEC Form D Evidence (`zinin/funding-round-tracker`) Actor

Search recent SEC EDGAR Form D notices by company or sector keyword. Get unique filing identity, filing date, direct SEC URL, evidence, freshness, confidence, coverage gaps, and a review action. A search hit is not proof of a completed round, amount raised, valuation, investor, or buying intent.

- **URL**: https://apify.com/zinin/funding-round-tracker.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 form d filings

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

## SEC Form D Search Evidence — deduplicated filing intelligence from EDGAR

Search recent SEC Form D filing identities by company name or sector keyword and receive review-ready evidence rows: filer name, CIK, accession number, filing date, direct SEC link, query scope, confidence, gaps, stable IDs, billing semantics, and a recommended next action.

This Actor is deliberately narrower and more honest than a generic “funding round database.” It proves that a specific Form D filing identity appeared in a bounded SEC EDGAR full-text result. It does **not** prove a venture round label, final amount raised, valuation, investor participation, company-domain identity, commercial intent, or investment suitability.

Use it when official filing evidence is more valuable than an unsupported headline and when your workflow can include issuer verification and document review.

![SEC Form D Search Evidence: buyer input to evidence-backed action](https://raw.githubusercontent.com/TimmyZinin/apify-actor-assets/ca4f5809215176a16838b98c48e545499c1d9c21/commercial115/funding-round-tracker/readme-hero.webp)

### What you get

- One paid row per **unique identified SEC accession number**, even when several submitted queries return the same filing.
- Legacy-compatible fields such as `sourceQuery`, `found`, `matched`, `company`, `ciks`, `filedAt`, `form`, `accessionNumber`, `url`, `summary`, and `checkedAt`.
- Additional `sourceQueries` and `queryMatches` fields explaining every submitted query merged into the filing observation.
- A direct SEC filing index URL built only from a validated numeric CIK and validated accession number.
- Explicit scope fields: `retrievedCount`, `resultLimit`, `matchedIsLowerBound`, and `coverageComplete`.
- Stable `entityId`, `observationId`, `eventId`, and evidence IDs for deduplication and audit trails.
- Separate filing-existence confidence and issuer-match confidence. A strong accession identity is not presented as strong buyer-intended-company attribution.
- `evidence`, `freshness`, `confidence`, `dataGaps`, `recommendedAction`, `failureDiagnostics`, and `safeToAutomate` on every row.
- Free no-match, source-failure, incomplete-hit, and budget-notice rows. Only a unique identified filing row is eligible for `result-found` billing.
- A KVS `OUTPUT` record reconciling query normalization, source success, candidate count, duplicate accessions, paid/free/local delivery, withheld rows, partial state, fatal errors, and replay safety.

### What this Actor is — and is not

The SEC describes Form D as a notice of an exempt offering. In the usual Regulation D path it is due within 15 days after the first sale, but Form D notices can be amended, a full-text search can match text beyond the issuer name, and the lightweight search result does not contain every offering fact needed for a commercial or investment conclusion.

This Actor therefore makes only this positive claim:

> At the recorded observation time, SEC EDGAR returned this stable Form D filing identity for the submitted full-text query and date window.

It never upgrades that observation into any of the following without evidence the Actor does not collect:

- “the company completed a funding round”;
- “the round was Seed, Series A, Series B, debt, or another inferred label”;
- “the company raised the total offering amount”;
- “the filing belongs to the domain or brand the buyer had in mind”;
- “the issuer is actively buying software, hiring vendors, or ready for outreach”;
- “the filing is new to the market” rather than merely present in the requested lookback;
- “the company is a good investment” or any investment recommendation;
- “contacting the issuer is lawful, wanted, or appropriate.”

That boundary is the product. It lets a CRM, research sheet, agent, or analyst keep filing evidence separate from attribution, interpretation, and action.

### Who it is for

#### Founder-led sales and small B2B teams

Use a short list of exact company names or a narrow market phrase to build a primary-source research queue. Open the cited filing, confirm the issuer and domain, then decide whether the observation is relevant. A Form D hit may justify research; it does not create permission to contact or prove buying intent.

#### Agencies and lead-research services

Deliver an auditable enrichment column instead of a vague “recently funded” badge. Preserve accession, CIK, date, source link, query, confidence risks, and reviewer action in the client export. Bill your work for verification and context, not for an unsupported round claim.

#### Private-market and ecosystem researchers

Run repeatable keyword panels across sectors, geographies, technologies, or issuer names. Use `matched`, `matchedIsLowerBound`, and `coverageComplete` to understand the bounded search before comparing cohorts. Deduplicate downstream by `entityId` or accession number.

#### Analysts, journalists, and competitive-intelligence teams

Use the output as a discovery index into official filings. Cite the filing itself after reading it. Do not cite this Actor's summary as a substitute for the document or assume the first full-text match explains why the document matched.

#### Automation builders and AI-agent developers

Use the Dataset for evidence rows and KVS `OUTPUT` for run-level reconciliation. Branch on `failureDiagnostics`, `coverageComplete`, `confidence.level`, and `safeToAutomate`; require a human or an approved verification service before external action.

### High-value use cases

#### 1. Exact-name issuer discovery

Submit a legal company name or distinctive phrase. The output identifies SEC filing accessions returned by full-text search. Confirm the legal entity against the CIK and filing before associating it with a website, CRM account, or founder.

#### 2. Sector and theme research

Search a narrow phrase such as `artificial intelligence`, `industrial robotics`, or `rare disease`. The result is a document-discovery cohort, not a canonical list of all companies in that sector. Broad phrases can have high totals, incomplete page coverage, and ambiguous reasons for matching.

#### 3. CRM enrichment with source receipts

Map accession number, CIK, filed date, SEC URL, evidence confidence, and review status into staging fields. Promote a “verified funding event” field only after your own issuer and filing review. Keep the raw Actor observation unchanged for audit.

#### 4. Agency research deliverables

Create three tabs: identified filings, query/source exceptions, and reviewed issuer matches. Include run URL, input scope, observed time, evidence link, gaps, and reviewer name. This avoids the common failure where a client receives a polished list but cannot trace any claim.

#### 5. Scheduled filing panels

Schedule the same bounded input and compare stable `entityId` values in your destination. This Actor is stateless: it returns current matches in the requested window each run. If you want an Actor-managed named baseline that emits only newly observed filing identities, use [Funding Alert](https://apify.com/zinin/funding-alert).

#### 6. Research-agent evidence retrieval

Let an agent retrieve rows, but force it to cite `evidence[].sourceUrl`, state confidence risks, and preserve `dataGaps`. The model may summarize the filing after fetching and reading it; it must not invent amount, round label, investor, domain identity, or intent.

### How it works

1. Runtime input validation requires a JSON object, 1–25 string queries, integer bounds, and no hidden numeric/string coercion.
2. Queries are trimmed and deduplicated case-insensitively. `Acme` and `ACME` become one SEC request.
3. Each query is wrapped as an exact phrase for the SEC EDGAR full-text search endpoint and bounded by `sinceDays`.
4. The source request uses a fixed SEC origin, a descriptive user agent, a 25-second timeout, no redirect following, JSON content-type validation, and a 4 MB streaming ceiling.
5. Source hits are ordered by SEC file date and capped by the buyer's `limit` for that query.
6. CIK and accession syntax are validated before a direct filing URL or billable row can exist.
7. All query results are collected before delivery. Identical accessions are merged across queries, so one filing identity is not delivered or charged twice.
8. The decision layer separates filing identity, query-to-issuer attribution, freshness, result coverage, confidence, gaps, and next action.
9. Dataset delivery and `result-found` billing occur in one linked SDK operation behind a process-wide mutex. The receipt must prove the expected linked operations exactly.
10. Free outcome rows use an unpriced Dataset channel only after runtime pricing is checked. Ambiguous delivery fails the run and marks `replaySafe=false` in KVS `OUTPUT`.

### Source and methodology

#### Primary source

The Actor queries the public SEC EDGAR full-text search endpoint at `efts.sec.gov`. It does not use a funding-news scraper, social network, proprietary company database, LLM, proxy, or buyer-supplied API key.

Official SEC background:

- [Filing a Form D Notice](https://www.sec.gov/resources-small-businesses/exempt-offerings/filing-form-d-notice)
- [SEC Search Filings](https://www.sec.gov/search-filings)
- [Securities Act Forms interpretations](https://www.sec.gov/rules-regulations/staff-guidance/corporation-finance-interpretations/securities-act-forms)

#### What the search response supports

For an identified hit, the response supports the displayed SEC filer name, CIK list, SEC file date, form value, accession number, and document identity used to construct the SEC index URL. The Actor records these values as observed source data and exposes the exact search URL.

#### What it does not support

The search response alone does not establish the intended company-domain match, the reason the full text matched, first-sale date, offering amount, amount sold, investor count, security type, amendment history, round label, valuation, or transaction outcome. Those remain named gaps.

#### Coverage semantics

- `matched` is the count returned by SEC for that query window.
- `matchedIsLowerBound=true` means SEC marked the total as `gte`; do not present it as exact.
- `retrievedCount` is the number of hit objects present in the SEC response page before the buyer limit is applied.
- `resultLimit` is the configured maximum delivered from that query.
- `coverageComplete=true` only when the reported total is exact and fits inside the selected rows. Otherwise the row is still useful, but the bounded result is not the complete match universe.
- `sourceQueries` lists the submitted queries that returned the same accession after cross-query deduplication.

### Evidence, confidence, and decision contract

#### Filing existence versus issuer attribution

An identified row typically has `filingExistenceConfidence=95` because accession, CIK, date, and direct SEC URL form a strong filing identity. It separately has `issuerMatchConfidence=30` because a full-text keyword result does not independently prove that the filing belongs to the company or domain the buyer intended.

The overall `confidence.score` is evidence support for the Actor's narrow observation, not conversion probability, investment quality, round materiality, or source accuracy in every downstream interpretation.

#### Recommended actions

| `recommendedAction` | Meaning |
|---|---|
| `VERIFY_ISSUER_AND_READ_FILING` | Confirm legal issuer/domain identity and read the SEC document before using the observation. |
| `REFINE_QUERY_OR_SCHEDULE_RECHECK` | The bounded search completed with no identified match; refine scope or repeat later without interpreting it as a universal negative. |
| `RETRY_SOURCE_CHECK` | SEC request or response contract failed; retry later and do not treat the failure as no filing. |
| `INSPECT_SOURCE_SHAPE` | A hit lacked a stable CIK/accession identity and was delivered free for investigation. |
| `RAISE_BUDGET_AND_RERUN_REVIEWED_SCOPE` | The cap stopped delivery; review query breadth before increasing spend. |

#### Automation boundary

Every row has `safeToAutomate=false`. You may automate collection, storage, deduplication, routing, and creation of a manual review task. You should not automatically send outreach, overwrite a verified CRM funding field, make a legal conclusion, place a trade, or publish a funding claim from this row alone.

### Input

| Field | Type | Required | Default | Bounds | Meaning |
|---|---|---:|---:|---:|---|
| `queries` | string array | yes | — | 1–25 items, 1–200 characters each | Company names or sector phrases. Trimmed and case-insensitively deduplicated. |
| `sinceDays` | integer | no | 90 | 1–730 | UTC date lookback applied to every SEC query. |
| `limit` | integer | no | 20 | 1–100 | Maximum hits selected per query from the returned SEC page. |
| `maxConcurrency` | integer | no | 3 | 1–8 | Concurrent SEC queries. Delivery and billing remain serialized. |

The runtime rejects wrong types instead of silently coercing them. For example, `"sinceDays":"30"`, a numeric query item, a fractional limit, or 26 queries fails before source work.

#### Narrow company-name search

```json
{
  "queries": ["Flo Artificial Intelligence"],
  "sinceDays": 180,
  "limit": 10,
  "maxConcurrency": 1
}
```

#### Sector panel with duplicate normalization

```json
{
  "queries": [
    "artificial intelligence",
    "ARTIFICIAL INTELLIGENCE",
    "industrial robotics"
  ],
  "sinceDays": 90,
  "limit": 25,
  "maxConcurrency": 2
}
```

The first two inputs become one request. The KVS output records `requestedQueries:3`, `uniqueQueries:2`, and `duplicateQueries:1`.

### Output

#### Identified filing row

The example below is based on a bounded local live-source run on 11 August 2026. Filing values can change across future query windows; use the current run's Dataset as the source of truth.

```json
{
  "sourceQuery": "artificial intelligence",
  "sourceQueries": ["artificial intelligence"],
  "found": true,
  "matched": 10,
  "matchedIsLowerBound": false,
  "company": "Flo Artificial Intelligence, Inc.",
  "ciks": ["0001798621"],
  "filedAt": "2026-07-06",
  "form": "D",
  "accessionNumber": "0001798621-26-000003",
  "url": "https://www.sec.gov/Archives/edgar/data/1798621/000179862126000003/0001798621-26-000003-index.htm",
  "retrievedCount": 10,
  "resultLimit": 3,
  "coverageComplete": false,
  "entityId": "sec-filing:0001798621-26-000003",
  "filingExistenceConfidence": 95,
  "issuerMatchConfidence": 30,
  "fundingClaimStatus": "unverified_form_d_search_hit_not_a_verified_round",
  "confidence": {
    "score": 65,
    "level": "medium"
  },
  "recommendedAction": "VERIFY_ISSUER_AND_READ_FILING",
  "safeToAutomate": false,
  "billing": {
    "event": "result-found",
    "billable": true,
    "unit": "one_unique_identified_sec_form_d_search_hit_delivered"
  }
}
```

#### Free no-match row

```json
{
  "sourceQuery": "a very narrow phrase",
  "found": false,
  "matched": 0,
  "coverageComplete": true,
  "recordType": "sec_form_d_query_outcome",
  "signalStatus": "NO_MATCH_OBSERVED",
  "recommendedAction": "REFINE_QUERY_OR_SCHEDULE_RECHECK",
  "failureDiagnostics": {
    "failureType": null,
    "retryable": false,
    "partial": false
  },
  "billing": {
    "event": null,
    "billable": false
  },
  "safeToAutomate": false
}
```

#### KVS `OUTPUT`

```json
{
  "schemaVersion": "1.0.0",
  "status": "COMPLETE",
  "input": {
    "requestedQueries": 2,
    "uniqueQueries": 1,
    "duplicateQueries": 1,
    "sinceDays": 180,
    "limitPerQuery": 3,
    "maxConcurrency": 1
  },
  "source": {
    "attemptedQueries": 1,
    "successfulQueries": 1,
    "failedQueries": 0
  },
  "candidates": {
    "searchHitRows": 3,
    "uniqueIdentifiedFilings": 3,
    "duplicateFilingRowsMerged": 0,
    "unidentifiedHits": 0
  },
  "delivery": {
    "deliveredRows": 3,
    "paidRows": 0,
    "localNonMonetizedRows": 3,
    "freeRows": 0,
    "withheldRows": 0,
    "linkedChargedCount": 0
  },
  "partial": false,
  "budgetStopped": false,
  "fatalError": null,
  "replaySafe": true,
  "safeToAutomate": false
}
```

On Apify, an accepted paid canary should move eligible delivered rows from `localNonMonetizedRows` to `paidRows` and record exact linked receipt counts. Do not infer settled platform PPE from a local run; inspect the run's charged-event receipt.

![SEC Form D Search Evidence: evidence-to-action workflow](https://raw.githubusercontent.com/TimmyZinin/apify-actor-assets/ca4f5809215176a16838b98c48e545499c1d9c21/commercial115/funding-round-tracker/readme-workflow.webp)

### Field dictionary

#### Compatibility fields

| Field | Meaning |
|---|---|
| `sourceQuery` | First normalized query associated with the row. Preserved for existing integrations. |
| `found` | `true` only for a hit with a valid accession and constructible SEC URL. |
| `matched` | SEC-reported total for the first query; use `queryMatches` for merged-query details. |
| `company` | Filer display name from the SEC hit, with the trailing CIK annotation removed. |
| `ciks` | Valid numeric SEC CIK strings observed in the hit. |
| `filedAt` | SEC file date from the search result. |
| `form` | SEC form value, normally `D`; do not infer round type from it. |
| `accessionNumber` | Stable SEC submission identifier and primary cross-query dedupe key. |
| `url` | Constructed direct SEC index URL for the validated CIK/accession pair. |
| `summary` | Human-readable description of the narrow observation or query failure. |
| `checkedAt` | UTC time this run observed the source outcome. |
| `error` | Source, shape, or run notice text for free outcome rows; otherwise `null`. |

#### Scope and provenance

| Field | Meaning |
|---|---|
| `sourceQueries` | All normalized submitted queries merged into this accession row. |
| `queryMatches` | Per-query SEC total and lower-bound flag. |
| `searchUrl` | Exact bounded SEC full-text URL used for the first query. |
| `retrievedCount` | Hit objects in the returned SEC page before the buyer limit. |
| `resultLimit` | Buyer-selected maximum rows per query. |
| `coverageComplete` | Whether the exact SEC total fits inside the selected hit set. |
| `matchedIsLowerBound` | Whether SEC marked the total as `gte`. |
| `evidence` | Machine-readable SEC source receipt with evidence ID and observation time. |
| `evidenceCoverage` | Coverage of the row's narrow identity observation, not coverage of all possible offerings. |

#### Stable identity and time

| Field | Meaning |
|---|---|
| `entityId` | Stable filing ID for identified rows: `sec-filing:<accession>`. |
| `observationId` | Stable hash of entity plus observation time. |
| `eventId` | Stable hash of observation semantics for event routing. |
| `observedAt` | Run-level UTC observation time shared by source results. |
| `freshness.status` | `fresh`, `recent`, `older`, or `unknown` from SEC file date. |
| `freshness.filingAgeDays` | Whole UTC days between filing and observation when both parse. |
| `change` | Explicit single-observation contract; this Actor does not pretend it has a previous baseline. |

#### Interpretation and action

| Field | Meaning |
|---|---|
| `filingExistenceConfidence` | Confidence in the accession/CIK/date/URL filing identity. |
| `issuerMatchConfidence` | Confidence that the full-text match is the company the buyer intended; intentionally much lower without independent attribution. |
| `matchBasis` | `sec_full_text_keyword_or_name_match`, not a verified domain match. |
| `fundingClaimStatus` | Explicit statement that the row is not a verified funding round. |
| `confidence` | Evidence-support score, level, reasons, and risks. |
| `dataGaps` | Material facts the source response and Actor do not establish. |
| `recommendedAction` | Deterministic review route. |
| `actionPriority` | Review urgency based on filing age or operational failure. |
| `actionReason` | Plain-language explanation of the next step. |
| `safeToAutomate` | Always `false` for external business, legal, financial, or outreach action. |
| `failureDiagnostics` | Failure type, retryability, and partial-state flag. |
| `billing` | Event eligibility, unit definition, and why the row is paid or free. |
| `observationSemantics` | What the Actor observed and what it explicitly does not prove. |

### Pricing and spend control

The current base tier charges:

- `$0.005` for the Actor start event;
- `$0.005` for each unique identified filing row delivered as `result-found`.

Current volume tiers reduce each event price to `$0.00475` (Bronze), `$0.00450` (Silver), `$0.00425` (Gold), `$0.00410` (Platinum), and `$0.00400` (Diamond). Always check the Store pricing tab for the tier applied to your account.

At the base tier, 100 unique delivered filing rows in one run are approximately `$0.505` including one minimum start event. No-match, source-failure, incomplete-identity, and budget-notice rows are not charged as `result-found`.

The runtime reads live pricing before source work. It refuses paid work when `result-found` is not priced, refuses all Dataset writes when free notice rows cannot be proven free, checks the buyer's maximum charge before each paid row, serializes the check-and-deliver critical section, and fails closed on an ambiguous linked receipt.

Set a small `maxTotalChargeUsd` during integration. A broad query can return many matches; `limit` and the charge cap control different risks and should both be bounded.

### API and integration examples

Use environment variables or your platform secret store for tokens. Never paste an Apify token into a README, spreadsheet cell, webhook URL, or committed source file.

#### HTTP API

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/zinin~funding-round-tracker/runs?token=$APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["artificial intelligence"],
    "sinceDays": 180,
    "limit": 10,
    "maxConcurrency": 1
  }'
```

After the run finishes, retrieve Dataset items and KVS `OUTPUT` from the URLs in the Actor output schema. Treat a terminal `FAILED` or `TIMED-OUT` run as an operational event, not as evidence of no filing.

#### JavaScript client

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('zinin/funding-round-tracker').call({
  queries: ['artificial intelligence'],
  sinceDays: 180,
  limit: 10,
  maxConcurrency: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const output = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('OUTPUT');

const reviewQueue = items.filter((row) =>
  row.found && row.recommendedAction === 'VERIFY_ISSUER_AND_READ_FILING'
);
console.log({ reviewQueue, reconciliation: output?.value });
```

#### Python client

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("zinin/funding-round-tracker").call(run_input={
    "queries": ["artificial intelligence"],
    "sinceDays": 180,
    "limit": 10,
    "maxConcurrency": 1,
})

rows = client.dataset(run["defaultDatasetId"]).list_items().items
output = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("OUTPUT")["value"]
review_queue = [row for row in rows if row.get("recommendedAction") == "VERIFY_ISSUER_AND_READ_FILING"]
print(len(review_queue), output["status"], output["replaySafe"])
```

#### Google Sheets

Export the Dataset directly or append rows through an automation. Keep `entityId` as the dedupe key, `accessionNumber` and `url` as evidence columns, confidence and gaps visible, and a separate reviewer/status column. Do not flatten away `sourceQueries` if overlapping query panels matter.

#### n8n

1. Start the Actor with an HTTP Request or Apify node.
2. Wait for a terminal run state.
3. Fetch KVS `OUTPUT`; stop the workflow if `fatalError` is non-null or `replaySafe=false`.
4. Fetch Dataset rows.
5. Upsert by `entityId`.
6. Route `failureDiagnostics.failureType` to operations and filing rows to human verification.
7. Permit an external action only from your separately approved review state.

#### Make

Use an Apify module to run the Actor, retrieve Dataset items, and create a review record. Filter on `found=true` and keep the evidence URL, confidence risks, gaps, and run ID together. A Make scenario should not send outreach directly from `found=true`.

#### Apify schedules and webhooks

Schedules repeat the current bounded search. Webhooks should trigger on terminal Actor state, then fetch both Dataset and KVS `OUTPUT`. Store the run ID with downstream rows. Use destination-level idempotency because a stateless repeated run can observe the same filing again.

#### MCP and AI agents

An agent may call the Actor, but its system or workflow policy should require:

- citations to `evidence[].sourceUrl`;
- preservation of `fundingClaimStatus` and `dataGaps`;
- no invented funding amount, round label, investor, valuation, domain match, contact, or intent;
- explicit human review for `safeToAutomate=false`;
- run-level rejection when `OUTPUT.replaySafe=false` or a fatal error exists.

### Operational checklist

#### Before the first production run

- Write the question in one sentence and decide whether a company-name or sector query actually answers it.
- Start with one or two distinctive queries, a short lookback, a low result limit, concurrency 1, and a small maximum charge.
- Decide which evidence will verify issuer-to-domain identity.
- Create staging fields rather than overwriting trusted CRM or research data.
- Define who reviews rows and what constitutes an approved funding claim.

#### During review

- Open the SEC filing URL.
- Confirm accession, CIK, legal issuer, form type, and date.
- Determine why the query matched.
- Check whether the filing is a new notice or amendment.
- Read offering details needed for your decision; do not infer them from the search card.
- Verify the company/domain relationship independently.
- Keep outreach legality, consent, suppression, and relevance as separate decisions.

#### In ongoing operation

- Monitor source failure rate, partial-hit rate, incomplete coverage, duplicate filing merge count, paid/free row count, and spend.
- Investigate sudden changes in SEC response shape or match volume.
- Preserve `OUTPUT` with the Dataset for reconciliation.
- Re-expand manual sampling after source, schema, query panel, or destination changes.
- Never blindly retry an ambiguous run when `replaySafe=false`; inspect the Dataset and charged-event receipt first.

### Privacy, retention, and responsible use

The Actor sends submitted queries to the public SEC full-text search service and stores queries in the Actor Dataset/KVS output. Do not submit secrets, private notes, personal contact lists, health information, authentication material, or data you are not authorized to process.

Form D filings are public records, but public availability does not remove obligations around data minimization, lawful use, outreach rules, suppression lists, discrimination, financial promotions, or jurisdiction-specific privacy requirements. This Actor provides collection and decision-support evidence; it does not provide legal, compliance, tax, or investment advice.

Apify storage retention and access are controlled by your account and platform settings. Export only the fields needed by the destination, protect API tokens, restrict Dataset access, and remove stale exports according to your own retention policy.

### Quality and troubleshooting

#### Source request fails

The row is free, `failureType=SOURCE_UNAVAILABLE`, `retryable=true`, and `safeToAutomate=false`. Retry later with the same bounded input. Do not convert a failed request into `found=false` business evidence.

#### A hit has no accession or valid CIK

The Actor does not sell it. It returns a free `SOURCE_SHAPE_PARTIAL` row with `INSPECT_SOURCE_SHAPE`. This is preferable to creating an unstable URL or billing for an unidentified document.

#### `matched` is larger than delivered rows

`matched` is the SEC total for the query, while `limit` caps selected hits and the source response itself is one page. Inspect `matchedIsLowerBound`, `retrievedCount`, `resultLimit`, and `coverageComplete` before describing coverage.

#### Two queries match the same accession

The Actor merges them before Dataset delivery and billing. `sourceQuery` keeps the first query for compatibility; `sourceQueries` and `queryMatches` preserve the combined explanation.

#### The budget stops the run

KVS `OUTPUT` records withheld rows and `partial=true`. A free run notice explains the stop when the Dataset channel is confirmed unpriced. Review the query breadth before raising the cap.

#### Delivery receipt is ambiguous

The run fails, `fatalError` is recorded, and `replaySafe=false`. The row may have reached the Dataset or billing service even though the SDK call did not return the exact receipt. Inspect the original run before any retry.

### Funding Round Tracker versus Funding Alert

| Need | This Actor: SEC Form D Search Evidence | [Funding Alert](https://apify.com/zinin/funding-alert) |
|---|---|---|
| Current bounded search window | yes | yes, as part of watch evaluation |
| Returns recent identified matches | yes | primarily new identities relative to baseline |
| Actor-managed named baseline | no | yes |
| Stateless repeatability | yes | no; watch state matters |
| Cross-query accession dedupe in one run | yes | watch-specific identity logic |
| Best use | discovery, enrichment, research panels | repeated alerting for newly observed filing identities |

Do not run both by default. Choose the stateless search product for current-window evidence and the stateful alert product when you explicitly need Actor-managed change detection.

#### Related tools

| Actor | When to use it |
|---|---|
| [Funding Alert](https://apify.com/zinin/funding-alert) | Maintain a named baseline and emit newly observed Form D identities. |
| [SEC Filing Watcher](https://apify.com/zinin/sec-edgar-watcher) | Watch public-company ticker filings such as 10-K, 10-Q, 8-K, and S-1. |
| [Insider Trading Tracker](https://apify.com/zinin/insider-trading-tracker) | Track Form 3/4/5 insider transaction filings by ticker. |
| [13F Portfolio Tracker](https://apify.com/zinin/thirteen-f-tracker) | Research institutional manager holdings by CIK or manager identity. |
| [Patent Filing Monitor](https://apify.com/zinin/patent-monitor) | Monitor patent-grant keywords instead of securities filings. |

### FAQ

#### Does a Form D prove a completed funding round?

No. It is an official notice of an exempt offering and is valuable primary evidence, but the search hit alone does not establish your preferred round definition, final amount, valuation, investor participation, close status, or commercial interpretation.

#### Is every Form D a venture-capital round?

No. Issuers and offerings vary, amendments exist, and the Actor does not classify security or financing type from the document body.

#### Does an exact quoted query guarantee issuer-name matching?

No. The phrase is sent to full-text search. It may appear outside the issuer display name. Confirm why the document matched.

#### Can I search a company domain?

You can submit a domain-like string, but this Actor does not resolve domains to legal issuers. Prefer a verified legal name or CIK-driven workflow and confirm identity manually.

#### Why is issuer-match confidence only 30?

Because the Actor has strong evidence for the SEC filing identity but only a full-text phrase relationship to the buyer's intended company. Keeping those confidences separate prevents a real filing from becoming a false company attribution.

#### Why is overall confidence medium on an identified filing?

The narrow filing observation is strong, while the commercial interpretation remains incomplete. Confidence measures support for the delivered claim, not the attractiveness or materiality of the issuer.

#### Can I treat `matched=0` as proof that the company did not raise?

No. It means the bounded SEC full-text query returned no match in the configured window. Different names, spellings, CIKs, dates, exemptions, foreign transactions, or non-Form-D paths remain outside that negative result.

#### Does the Actor parse offering amount or amount sold?

No. It intentionally returns search-result filing identity and decision metadata. Read and parse the filing body in a separate reviewed enrichment step.

#### Are amendments included?

Do not assume complete amendment coverage. The current source request uses the SEC `forms=D` filter and preserves any form value the endpoint returns. If your workflow requires every amendment, validate that requirement against SEC filing history separately.

#### How fresh is the data?

`observedAt` records request time and `filedAt` comes from the SEC hit. `freshness` is derived from those two timestamps. It does not promise real-time completeness or publication latency.

#### Does it require an SEC API key?

No. The public EDGAR full-text endpoint is keyless. The Actor sends a descriptive user agent and bounded requests.

#### Does it use proxies or an LLM?

No. It uses direct public SEC JSON and deterministic transformation.

#### Can I schedule it?

Yes. Remember that it is stateless and can return the same accessions again. Upsert by `entityId`, or use Funding Alert when you need an Actor-managed baseline.

#### How should I deduplicate?

Within one run the Actor merges by accession number. Across runs, use `entityId` or `accessionNumber`. Do not use company display name as the only key.

#### Are no-match and source-error rows billed?

They are not billed as `result-found`. Runtime pricing checks must confirm the unnamed Dataset channel is free before those rows are written.

#### Can the same filing be billed twice in one run?

Not when it has the same valid accession number. Query results are aggregated and deduplicated before the serialized delivery/billing stage.

#### What if a filing appears under two different accession numbers?

They are different SEC submission identities and remain separate rows. Review whether one is an amendment or another filing; the Actor does not collapse distinct accessions by company name.

#### Is this investment advice?

No. It is public-filing search evidence and workflow metadata. Investment, legal, tax, and compliance decisions require appropriate primary evidence and qualified review.

#### Can I automatically contact every filer?

No. `safeToAutomate=false`. Verify identity, relevance, contact source, consent or lawful basis, jurisdiction, and suppression requirements first.

#### What should I include in a bug report?

Provide the Actor run ID, a redacted input, accession or affected field, expected behavior, KVS `OUTPUT`, and whether the SEC URL still reproduces. Never include API tokens, private customer data, or credentials.

***

Built by [zinin](https://apify.com/zinin) for evidence-first research workflows. Review material facts at the cited primary source before acting.

# Actor input Schema

## `queries` (type: `array`):

Company names or sector keywords to watch for new Form D filings (e.g. `artificial intelligence`, `biotech`, or a specific company name). One or more filing rows per query.

## `sinceDays` (type: `integer`):

Only include filings from the last N days.

## `limit` (type: `integer`):

Max number of filings to return per query.

## `maxConcurrency` (type: `integer`):

How many SEC search queries to process in parallel. Dataset delivery and billing remain serialized so one accession is not sold twice.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence",
    "biotech"
  ],
  "sinceDays": 90,
  "limit": 20,
  "maxConcurrency": 3
}
```

# Actor output Schema

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

API URL for unique identified filing rows and free source/no-match/budget outcomes.

## `output` (type: `string`):

KVS OUTPUT with requested/unique queries, source outcomes, duplicate accessions merged, paid/free/withheld delivery, partial status, fatal error and replay safety.

# 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 = {
    "queries": [
        "artificial intelligence",
        "biotech"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/funding-round-tracker").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 = { "queries": [
        "artificial intelligence",
        "biotech",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zinin/funding-round-tracker").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 '{
  "queries": [
    "artificial intelligence",
    "biotech"
  ]
}' |
apify call zinin/funding-round-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zinin/funding-round-tracker"
        }
    }
}

```

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/EEHXaTIeTV6e6WEDF/builds/f0CCbAPsWFaOPjLI6/openapi.json