# SEC Account Briefs (`gtm_solutions/sec-account-briefs`) Actor

Turn a company's SEC filings into a decision-ready account brief: recent material events, leadership changes, financial signals, and risks — every sentence cited to an 8-K item with a sec.gov link. No-AI, bring-your-own-key, or managed modes.

- **URL**: https://apify.com/gtm\_solutions/sec-account-briefs.md
- **Developed by:** [Clance Hoskin](https://apify.com/gtm_solutions) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $350.00 / 1,000 account brief (extractive or your own key)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Account Briefs

**A decision-ready account brief for any US filer — every sentence cited to an SEC filing.**

Give it a company. Get back a structured brief: what changed recently, who came and went at the top, what the financial signals are, what to watch — each point tied to a specific 8-K item with a link to the filing on sec.gov. Run it with no AI at all (every line is a cited fact), with your own Anthropic key, or in managed mode where a bounded model writes two to four sentences per section and a validator throws out any sentence it can't cite.

![SEC Account Briefs — evidence in, cited brief out](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/sec-account-briefs-cover.png)

### Who it's for

- **Sales teams** doing pre-call research on enterprise accounts: the brief is the first page of your account plan, and every claim in it survives a "where did you read that?"
- **Account-research and investment-research teams** who need a repeatable, citable summary per company rather than a fresh reading of every filing.
- **Anyone who has been burned by an AI summary that made something up.** This one structurally cannot — see *How the citation guarantee works*.

### What you get

One dataset item per company:

| Part | What it holds |
|---|---|
| `company` | Name, ticker, CIK — as SEC names the registrant |
| `window` | The evidence window (`from`, `to`, `lookbackDays`) |
| `coverage` | How many filings the brief draws on, by form, with newest and oldest dates and cache freshness |
| `sections[]` | Four synthesized sections — *Recent material events*, *Management and governance*, *Operating and financial signals*, *Risks and watch items* — each a list of sentences with `citations` (`E1`, `E2`, …) |
| `citations[]` | Every cited evidence item: filing date, form, headline, `filingUrl`, `primaryDocumentUrl` |
| `limitations[]` | The window, caps hit, sections with no evidence, any section that fell back to extractive text and why, and the model cost if a cap was exceeded |
| `evidenceSet[]` | The exact events the brief was built from, with `retrievedAt` and `classifierVersion` — regenerate the same brief from the same evidence |
| `model` | `null` in extractive mode; otherwise the mode, model id, and effort |
| `costs` | Mode, model, tokens, estimated USD, cap, and an `exceeded` flag — BYOK and managed costs are never mixed |

Each section says where its text came from: `synthesized` (model sentences that passed validation), `extractive` (deterministic cited lines), or `empty` (no evidence in the window — stated, never filled).

#### Sample section (extractive mode, real run)

```json
{
  "id": "financial",
  "title": "Operating and financial signals",
  "source": "extractive",
  "sentences": [
    {"text": "2026-08-26 · 8-K Item 2.02 · Financial update — On August 26, 2026, NVIDIA Corporation, or the Company, issued a press release announcing its results for the quarter ended July 26, 2026.", "citations": ["E16"]},
    {"text": "2026-05-20 · 8-K Item 2.02 · Financial update — On May 20, 2026, NVIDIA Corporation, or the Company, issued a press release announcing its results for the quarter ended April 26, 2026.", "citations": ["E18"]}
  ]
}
```

![Sample brief](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/sec-account-briefs-sample.png)

### How the citation guarantee works

![How it works](https://api.apify.com/v2/key-value-stores/5mteKCldTFiJGpm2g/records/sec-account-briefs-how-it-works.png)

1. **Evidence first.** The brief's skeleton is built from the company's classified SEC events (from the companion *SEC Event Intelligence* cache). Each event becomes a numbered evidence item — `E1`, `E2`, … — with its quoted filing text and links.
2. **The extractive brief is complete on its own.** Every line is a dated, cited fact. In `extractive` mode this is the whole brief, and no model runs.
3. **Synthesis is bounded.** In `byok` or `managed` mode, one structured model call writes two to four sentences per section, using only the evidence it was given, and must tag every sentence with the evidence ids it rests on.
4. **The validator decides.** A sentence with no citation, a citation to an id that doesn't exist, or a citation to evidence from a different section rejects the whole section. A rejected section falls back to its extractive text, and `limitations` says why.

The model cannot add a fact, because a fact without a citation never reaches the output. This is enforced in code, not in a prompt.

### Input

```json
{
  "companies": [{ "cik": "0000320193", "ticker": "AAPL" }],
  "asOfDate": "2026-09-12",
  "lookbackDays": 365,
  "sections": ["material-events", "governance", "financial", "risks"],
  "detail": "standard",
  "aiMode": "extractive"
}
```

| Field | Notes |
|---|---|
| `companies` | 1–10 companies by SEC CIK. Ticker and legal name are display hints. |
| `asOfDate`, `lookbackDays` | The evidence window: `lookbackDays` (1–1095) ending at `asOfDate` (default today). |
| `sections` | Which synthesized sections to include. Coverage, citations, and limitations are always included. |
| `detail` | `brief` (up to 5 events per section) or `standard` (up to 12). |
| `aiMode` | `extractive` — no model. `byok` — your Anthropic API key, passed as a secret input. `managed` — the operator's model. |
| `anthropicApiKey` | BYOK only. Stored as a secret; never written to the dataset or logs. |
| `model` | BYOK only: `claude-opus-5` (default), `claude-sonnet-5`, or `claude-haiku-4-5`. |
| `maxModelCostCents` | Managed only: 1–20 cents per brief. A brief that exceeds it is still delivered, and flagged. |

### Pricing

Pay per brief, charged only for a completed brief:

| Mode | Event | Price | Model cost |
|---|---|---|---|
| Extractive | `byokBrief` | **US$0.35** | none |
| BYOK | `byokBrief` | **US$0.35** | on your key; the brief reports estimated tokens and USD at list price |
| Managed | `managedBrief` | **US$0.50** | included, capped at US$0.20 per brief |

#### Prepaid volume blocks

For teams buying ahead, prepaid blocks are consumed in 500-brief increments.
These are commercial bundle prices; the Actor's Apify pay-per-event event
prices remain US$0.35 for extractive/BYOK and US$0.50 for managed.

| Briefs | BYOK | Managed |
|---:|---:|---:|
| 500 | US$175 (US$0.35/brief) | US$250 (US$0.50/brief) |
| 1,000 | US$325 (US$0.325/brief) | US$475 (US$0.475/brief) |
| 2,500 | US$750 (US$0.30/brief) | US$1,100 (US$0.44/brief) |
| 5,000 | US$1,400 (US$0.28/brief) | US$2,000 (US$0.40/brief) |

Bundle pricing is separate from the Actor's fixed event prices and does not
change Apify pay-per-event billing.

A company with no events in the window still yields a (mostly empty) brief; it is charged as a completed brief because the coverage, citations, and limitations sections are real answers.

If the run reaches the spend limit you set when starting it, the dataset holds only the briefs you were charged for, and the run summary reports `charging.limitReached: true` with the counts.

### Limits — please read

- **Coverage follows the SEC Event Intelligence cache.** A brief reports `freshness.lastCheckedAt` and `freshness.stale`; when it is stale or the company has never been checked, run SEC Event Intelligence for that company first — the brief itself never fetches from SEC.
- **Evidence is the 8-K item section**, not the exhibits. Earnings numbers, for example, live in the press-release exhibit; the brief will tell you results were announced and link the filing, not restate the figures.
- **Sections with no evidence stay empty.** The brief never fills a gap with outside knowledge.
- **In managed mode, sentences are the model's words — but every one is cited.** Read the citations; the `evidenceSet` lets you regenerate the brief from exactly the same inputs.
- **Model cost is estimated from list prices**, reported separately for BYOK and managed, and never blended with the brief price.
- **No advice, no predictions.** Sentences describe what filings say.

### Compared with alternatives

| | Reading the filings | A generic AI summary | SEC Account Briefs |
|---|---|---|---|
| Time per account | 30–60 minutes | seconds | seconds |
| Can you verify a claim? | yes, by hand | usually not | every sentence carries `citations` → `primaryDocumentUrl` |
| Can it invent a fact? | no | yes | no — uncited sentences are rejected in code |
| Repeatable | no | no | `evidenceSet` + model metadata on every brief |

### FAQ

**Which mode should I start with?** `extractive`. It is free of model cost, every line is a fact, and it shows you exactly what the brief would be built from. Switch to `managed` when you want prose.

**What's the difference between BYOK and managed?** Same brief structure and the same validator. BYOK uses your Anthropic key and you pay Anthropic directly; managed uses ours with a hard cost cap per brief.

**What happens if the model refuses or errors?** The brief is still delivered, fully extractive, with the reason in `limitations`. The run does not fail.

**Can it brief any company?** Yes, once SEC Event Intelligence has fetched it; the brief tells you when it has not.

**Where do the events come from?** The companion Actor, **SEC Event Intelligence** — same cache, same classifier, same evidence.

### Support

Use the Actor's **Issues** tab. For a wrong or unsupported sentence in managed mode, include the `eventId`s from `evidenceSet` — the brief is reproducible from them.

### Changelog

- **0.1** — Private build. Extractive, BYOK, and managed modes; citation validator with extractive fallback; per-brief model-cost cap.

# Actor input Schema

## `companies` (type: `array`):

One to ten companies by SEC CIK (1–10 digits, normalized to ten). Ticker and legal name are optional display hints.

## `asOfDate` (type: `string`):

Inclusive end of the evidence window (YYYY-MM-DD). Defaults to today.

## `lookbackDays` (type: `integer`):

Length of the evidence window ending at the as-of date (1–1095).

## `sections` (type: `array`):

Synthesized sections to include. Coverage, citations and limitations are always included.

## `detail` (type: `string`):

How many events each section may draw on: brief (5) or standard (12).

## `aiMode` (type: `string`):

extractive: no model, every line cited. byok: your Anthropic key synthesizes each section. managed: the operator's model does, within the per-brief cost cap.

## `anthropicApiKey` (type: `string`):

Required for byok mode. Stored as a secret; never written to the dataset.

## `model` (type: `string`):

Optional model for byok mode.

## `maxModelCostCents` (type: `integer`):

Managed mode: a brief whose model cost exceeds this is still delivered and flagged. 1–20 cents; the operator ceiling is 20.

## Actor input object example

```json
{
  "companies": [
    {
      "cik": "0000320193",
      "ticker": "AAPL"
    }
  ],
  "lookbackDays": 365,
  "sections": [
    "material-events",
    "governance",
    "financial",
    "risks"
  ],
  "detail": "standard",
  "aiMode": "extractive",
  "maxModelCostCents": 20
}
```

# Actor output Schema

## `briefs` (type: `string`):

The briefs, one item per company: company, window, coverage, sections, citations, limitations, evidenceSet, model, costs.

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

Companies requested and briefed, sections synthesized or fallen back, estimated model cost and the charging block.

# 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 = {
    "companies": [
        {
            "cik": "0000320193",
            "ticker": "AAPL"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gtm_solutions/sec-account-briefs").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 = { "companies": [{
            "cik": "0000320193",
            "ticker": "AAPL",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("gtm_solutions/sec-account-briefs").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 '{
  "companies": [
    {
      "cik": "0000320193",
      "ticker": "AAPL"
    }
  ]
}' |
apify call gtm_solutions/sec-account-briefs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gtm_solutions/sec-account-briefs"
        }
    }
}
```

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/1L2d0ne59k0nCZwLl/builds/9vlf0dvgk2ldqyTuH/openapi.json