# Earnings Call Transcript API (`khadinakbar/earnings-call-transcript-api`) Actor

Scrape public earnings call transcripts by ticker or URL. Motley Fool full Q\&A primary, SEC EDGAR transcript-exhibit fallback. Returns speakers, prepared remarks, Q\&A, and provenance. MCP-ready, HTTP-only, no login.

- **URL**: https://apify.com/khadinakbar/earnings-call-transcript-api.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 earnings call transcript scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Earnings Call Transcript API

Turn a US stock ticker or Motley Fool transcript path into **one structured earnings-call transcript row** with prepared remarks, Q\&A text, speakers, fiscal period, and a public source URL. Built for finance researchers, NLP / RAG pipelines, and MCP agents that need **source-cited call text**.

The Motley Fool and the U.S. Securities and Exchange Commission are trademarks of their respective owners. This independent Actor is not affiliated with, associated with, or endorsed by The Motley Fool or the SEC.

### Best fit for this Actor

- Research and RAG pipelines that need full public earnings-call Q\&A text for a known ticker
- MCP / agent workflows that start from tickers and expect dated transcript provenance
- Batch collection of Motley Fool transcript article URLs already on a research desk
- Optional SEC EDGAR transcript-labeled exhibit recovery when Motley Fool coverage is thin

When you need earnings *dates*, EPS estimates, and Yahoo quote context next, continue with [Yahoo Finance Scraper](https://apify.com/khadinakbar/yahoo-finance-scraper). For broader SEC filings beyond transcript exhibits, continue with [SEC EDGAR All-in-One Scraper](https://apify.com/khadinakbar/sec-edgar-all-in-one-scraper). For live quotes after you extract tickers from a call, continue with [Stock Price Tracker](https://apify.com/khadinakbar/stock-price-tracker).

### Practical scenario

A quant researcher sets `tickers` to `["AAPL"]`, `maxTranscriptsPerTicker` to `1`, and prefers Motley Fool as the primary source. The Actor opens the Motley Fool quote page, finds the newest transcript URL, parses participants and speaker turns, then writes one dataset row with `fullText`, `qaText`, `fiscalPeriod`, and `sourceUrl` for summarization.

### Quick start input

```json
{
  "tickers": ["AAPL"],
  "maxTranscriptsPerTicker": 1,
  "maxItems": 1,
  "sources": ["motley_fool", "sec_edgar"],
  "includeFullText": true,
  "includeSpeakerSegments": true
}
```

### Input reference

| Field | Type | What it controls |
|---|---|---|
| `tickers` | array | US symbols such as `AAPL` or `MSFT`. Discovers Motley Fool quote-page transcript links. |
| `transcriptUrls` | array | Direct Motley Fool earnings transcript article URLs. |
| `scrapeLatest` | boolean | Walk the public Motley Fool earnings-call listing for newest articles. |
| `dateFrom` / `dateTo` | string | Optional `YYYY-MM-DD` bounds on Motley Fool article path dates. |
| `maxTranscriptsPerTicker` | integer | Cap per ticker after discovery. Default 4. |
| `maxItems` | integer | Hard billed-row cap for the run. Default 20. |
| `sources` | array | `motley_fool` (full Q\&A) and/or `sec_edgar` (transcript-labeled exhibit fallback). |
| `includeFullText` | boolean | Persist prepared remarks, Q\&A, and full text (default true). |
| `includeSpeakerSegments` | boolean | Attach ordered speaker turns (default true). Included in the same charge. |
| `proxyConfiguration` | object | Optional Apify Proxy. Direct HTTP works in most cases. |

### What data you receive

One dataset item is one accepted public transcript. Download JSON, CSV, Excel, or HTML from the Dataset tab.

```json
{
  "recordType": "transcript",
  "ticker": "AAPL",
  "companyName": "Apple",
  "fiscalPeriod": "Q3 2026",
  "callDate": "Thursday, Aug. 7, 2026 at 5 p.m. ET",
  "publishedAt": "2026-08-07T21:15:00.000Z",
  "source": "motley_fool",
  "sourceUrl": "https://www.fool.com/earnings/call-transcripts/2026/08/07/apple-aapl-q3-2026-earnings-call-transcript/",
  "participants": [{ "role": "CEO", "name": "Tim Cook" }],
  "wordCount": 8293,
  "segmentCount": 119,
  "preparedRemarksText": "…",
  "qaText": "…",
  "fullText": "…",
  "speakerSegments": [
    { "segmentIndex": 1, "section": "prepared", "speakerName": "Operator", "text": "Welcome…" }
  ],
  "scrapedAt": "2026-09-21T12:00:00.000Z"
}
```

| Field | Meaning |
|---|---|
| `ticker` + `companyName` + `fiscalPeriod` | Identity of the call |
| `source` + `sourceUrl` | Provenance (`motley_fool` or `sec_edgar`) |
| `participants` | Role + name list when the article lists them |
| `preparedRemarksText` / `qaText` / `fullText` | Transcript body |
| `speakerSegments` | Ordered speaker turns with `prepared` or `qa` section |
| `wordCount` / `segmentCount` | Size metrics |
| `filingAccession` | SEC accession when `source` is `sec_edgar` |

Every run also writes `OUTPUT` and `RUN_SUMMARY` with outcome, `itemsPushed`, and charge counts.

### Coverage contract

- Motley Fool is the primary full Q\&A path for public earnings-call articles.
- SEC EDGAR is used only for exhibits whose description looks like a transcript.
- Seeking Alpha full bodies stay outside this Actor’s public HTTP contract.
- Well-formed tickers with no public Motley Fool match (and no transcript-labeled SEC exhibit) finish as `VALID_EMPTY` with no `transcript-scraped` charge.
- Empty or non-ticker input finishes as `INVALID_INPUT`.

### Pricing

Pay per event + platform usage pass-through. Callers pay the named events below and the underlying Apify compute. The live Pricing tab is the source of truth if amounts ever change.

| Event | When it charges | Price |
|---|---|---:|
| `apify-actor-start` | Once when the run starts | $0.00005 |
| `transcript-scraped` | Once per accepted transcript row | $0.008 |

Worked example: one AAPL transcript is about `$0.00005 + $0.008` in PPE events, plus a few seconds of 512 MB compute passed through at Apify platform rates. Empty matches and invalid input receive no `transcript-scraped` charge.

### How to use

1. Open the Actor in Apify Console and paste one or more US tickers (or Motley Fool transcript URLs).
2. Keep `maxTranscriptsPerTicker` at 1 for the newest call, or raise it for multi-quarter history.
3. Start the run, then export the dataset as JSON/CSV or read it from the API/MCP.

#### API example

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~earnings-call-transcript-api/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tickers":["AAPL"],"maxTranscriptsPerTicker":1,"maxItems":1,"sources":["motley_fool"]}'
```

#### Agent prompt card

> Use `khadinakbar/earnings-call-transcript-api` with `tickers: ["AAPL"]`, `maxTranscriptsPerTicker: 1`, and `sources: ["motley_fool"]`. Read dataset rows for `ticker`, `fiscalPeriod`, `sourceUrl`, `wordCount`, and `qaText`. Check `RUN_SUMMARY.outcome` and provenance fields before summarizing.

### Best results tips

- Prefer explicit `tickers` or `transcriptUrls` for focused research jobs.
- Keep `maxTranscriptsPerTicker` at 1–4 for quarterly monitoring.
- Use `sources: ["motley_fool"]` when you want full Q\&A only.
- Pair transcript collection with [Yahoo Finance Scraper](https://apify.com/khadinakbar/yahoo-finance-scraper) when the next step is earnings dates and estimates.

### Builder's note

I found that Motley Fool serves full transcript HTML over plain HTTP with stable `h2` section IDs (`call-participants`, `full-conference-call-transcript`) and `<strong>Speaker:</strong>` turns, which is why Motley Fool is the reliable primary path. Seeking Alpha full bodies sit behind a login wall in my testing, so this Actor keeps that source out of the public contract. SEC EDGAR is wired only for exhibits whose description looks like a transcript; many 8-K EX-99 files are press releases, so those rows stay labeled `sec_edgar` instead of pretending to be Motley Fool Q\&A.

### Legal / responsible use

Use only for public data and lawful research, journalism, or internal analysis workflows. Respect Motley Fool site terms, SEC access policies, copyright, and applicable laws. Transcript text is third-party content — obtain a license before republishing wholesale.

### Support

Open an Issue on the Actor page with the run ID and input (no secrets). After transcript collection, continue with [SEC EDGAR All-in-One Scraper](https://apify.com/khadinakbar/sec-edgar-all-in-one-scraper) for related filings or [Stock Price Tracker](https://apify.com/khadinakbar/stock-price-tracker) for quotes on the same tickers.

# Actor input Schema

## `tickers` (type: `array`):

US stock tickers to resolve on Motley Fool quote pages, for example AAPL or MSFT. Each ticker discovers recent earnings-call transcript URLs then scrapes them. Maximum 50 per run.

## `transcriptUrls` (type: `array`):

Direct Motley Fool earnings transcript article URLs such as https://www.fool.com/earnings/call-transcripts/2026/08/07/apple-aapl-q3-2026-earnings-call-transcript/. Bypasses ticker discovery. Maximum 100 per run.

## `scrapeLatest` (type: `boolean`):

When true, also walk Motley Fool's public earnings-call-transcripts listing pages and scrape the newest articles up to maxItems. Use alone for a recent-feed pull, or with tickers.

## `dateFrom` (type: `string`):

Optional lower bound on Motley Fool article path date (YYYY-MM-DD). Transcripts dated before this day are skipped.

## `dateTo` (type: `string`):

Optional upper bound on Motley Fool article path date (YYYY-MM-DD). Transcripts dated after this day are skipped.

## `maxTranscriptsPerTicker` (type: `integer`):

Cap how many Motley Fool transcripts to scrape for each ticker after discovery. Default 4 (about one year of quarterly calls).

## `maxItems` (type: `integer`):

Hard cap on billed transcript rows for the whole run. Default 20.

## `maxListingPages` (type: `integer`):

When scrapeLatest is true, how many Motley Fool listing pages to walk. Default 5.

## `sources` (type: `array`):

Which public sources to use. motley\_fool is the full Q\&A transcript archive. sec\_edgar is a fallback for transcript-labeled 8-K exhibits only (not Seeking Alpha).

## `includeFullText` (type: `boolean`):

When true (default), persist preparedRemarksText, qaText, and fullText on each row. Turn off to keep metadata + speakers only and shrink dataset size.

## `includeSpeakerSegments` (type: `boolean`):

When true (default), attach a speakerSegments array (speaker turns with prepared/qa section) on each Motley Fool transcript row. Segments are included in the same transcript-scraped charge.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy. Direct HTTP works for Motley Fool and SEC in most cases; enable Residential only if you see blocks.

## Actor input object example

```json
{
  "tickers": [
    "AAPL"
  ],
  "scrapeLatest": false,
  "maxTranscriptsPerTicker": 2,
  "maxItems": 3,
  "maxListingPages": 5,
  "sources": [
    "motley_fool",
    "sec_edgar"
  ],
  "includeFullText": true,
  "includeSpeakerSegments": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset items with ticker, fiscal period, source URL, participants, full text, and speaker segments.

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

Compact machine contract with outcome, itemsPushed, charges, and warnings.

## `runSummary` (type: `string`):

Detailed run diagnostics including per-job results and billing counters.

# 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 = {
    "tickers": [
        "AAPL"
    ],
    "maxTranscriptsPerTicker": 2,
    "maxItems": 3,
    "sources": [
        "motley_fool",
        "sec_edgar"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/earnings-call-transcript-api").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 = {
    "tickers": ["AAPL"],
    "maxTranscriptsPerTicker": 2,
    "maxItems": 3,
    "sources": [
        "motley_fool",
        "sec_edgar",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/earnings-call-transcript-api").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 '{
  "tickers": [
    "AAPL"
  ],
  "maxTranscriptsPerTicker": 2,
  "maxItems": 3,
  "sources": [
    "motley_fool",
    "sec_edgar"
  ]
}' |
apify call khadinakbar/earnings-call-transcript-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/earnings-call-transcript-api"
        }
    }
}
```

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/KYhzAXDfYSkXIIxdF/builds/qxQgIE7qaCxNcZ5Y5/openapi.json