# TED Talk Downloader (`agentx/ted-talk-downloader`) Actor

Process one publicly accessible TED Talk page for structured metadata and an optional stored video file.

- **URL**: https://apify.com/agentx/ted-talk-downloader.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** Videos, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#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

TED Video Downloader turns one public TED Talk page into structured media metadata and, when requested, a video file stored with the run.

- One URL keeps each record traceable to a specific talk page.
- Metadata mode supports lightweight cataloging before any file transfer.
- The Dataset presents artwork first and preserves a 26-key cross-video shape.
- Comments are outside the TED contract, so no comment limit is advertised.

**[Prepare a test run](https://apify.com/agentx/ted-video-downloader)**

**[Read the Apify API reference](https://apify.com/agentx/ted-video-downloader/api)**

Publish the Actor and replace .

### Why Choose This API

A TED Talk page combines editorial text, speaker attribution, artwork, timing, and playable media. This Actor translates the available pieces into a normalized row suitable for a research index, learning catalog, review queue, or downstream media workflow.

The public contract starts from a known talk. It does not search TED, enumerate playlists, crawl a series, collect transcripts, or discover related speakers. Although the bundled extractor library recognizes additional TED page types, this Actor deliberately promises only an individual public Talk page so its Store description matches a testable unit.

`metadata` is the prudent first pass: it verifies identity and availability without storing a video. The other three values ask for an available rendition. They cannot create 4K media when the source provides less.

### Quick Start Guide

Use the following URL-shaped sample to understand the request:

```json
{
  "video_url": "https://www.ted.com/talks/ken_robinson_do_schools_kill_creativity",
  "video_quality": "metadata"
}
```

`example_talk` is intentionally not presented as a real talk. Replace it with the canonical page for a public TED Talk you may process. Confirm the page loads and plays in a private browser session, then compare the Actor’s title, speaker, thumbnail, ID, and duration with the source.

Do not substitute a TED search result, topic page, series, playlist, event landing page, or embedded player in release testing. If a media copy is needed, request it only after the metadata result points to the intended talk.

### Input Parameters

| Name | Kind | Required | Accepted meaning |
|---|---|---:|---|
| `video_url` | string | Yes | Canonical, publicly accessible TED Talk page. |
| `video_quality` | string | No | `metadata`, `low`, `medium`, or `high`; omission selects metadata behavior. |

The required field carries the same placeholder in `prefill` and `example`. The optional selector has no preselected value or example, preserving the caller’s explicit intent.

No transcript language, speaker, topic, event, playlist, login, cookie, comment, search, or batch option is exposed. The schema rejects undeclared properties.

### Output Data Schema

One result may contain 39 fields arranged for review:

| Concern | Keys |
|---|---|
| Talk identity | `thumbnail`, `id`, `platform`, `title`, `description`, `duration`, `published_at` |
| Speaker/source | `author`, `author_id`, `author_url` |
| Classification and metrics | `categories`, `tags`, `view_count`, `like_count`, `shares_count`, `dislike_count`, `comment_count` |
| Technical media | `width`, `height`, `fps`, `audio_title`, `audio_artist`, `video` |
| Processing context | `comments`, `processed_at`, `processor` |

Illustrative output for :

```json
{
  "id": "example_talk",
  "platform": "TedTalk",
  "title": "Illustrative TED Talk",
  "author": "Illustrative speaker",
  "thumbnail": "https://example.com/ted-talk-cover.jpg",
  "comments": [],
  "video": ""
}
```

The values above are documentation, not observations from TED. Some general video counters or audio fields may be null because the Talk page does not supply them. An empty `video` is expected for metadata-only work. The reserved comments array does not imply a TED comment collector.

Source-dependent fields also present in every item:

| Field | Meaning |
|---|---|
| `source_url` | Canonical page URL of the item on its own platform |
| `media_type` | Kind of media the source reports, such as video or audio |
| `live_status` | Whether the item is a recording, currently live, or a finished stream |
| `availability` | Source visibility, such as public, unlisted, or needs\_auth |
| `age_limit` | Minimum viewer age the source enforces; zero means no restriction |
| `followers` | Follower or subscriber count of the author at processing time |
| `is_verified` | Whether the author's account carries a verified badge |
| `saves_count` | Times viewers saved the item, on sources that expose it |
| `file_ext` | Container extension of the selected media, such as mp4 or webm |
| `file_size` | Size of the selected media in bytes, exact or approximate |
| `chapters` | Chapter markers with title and start and end time in seconds |

### Integration Examples

The intended handle is `agentx/ted-video-downloader`. It currently has no Store-backed ID. A future HTTP call for the same fictional scenario would look like this:

```bash
curl -X POST "https://api.apify.com/v2/acts/agentx~ted-video-downloader/runs?token=$APIFY_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"video_url":"https://www.ted.com/talks/ken_robinson_do_schools_kill_creativity","video_quality":"metadata"}'
```

The equivalent MCP configuration retains those arguments:

```json
{
  "mcpServers": {
    "ted-talk-media": {
      "url": "https://mcp.apify.com?tools=agentx/ted-video-downloader",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  },
  "exampleToolArguments": {
    "video_url": "https://www.ted.com/talks/ken_robinson_do_schools_kill_creativity",
    "video_quality": "metadata"
  }
}
```

Keep credentials outside source control. The [Apify MCP documentation](https://docs.apify.com/integrations/mcp) explains hosted authentication and tool exposure.

### Pricing & Cost Calculator

The repository declares the following local event schedule; it is not yet a public Store offer:

| Event key | Local definition | Amount |
|---|---|---:|
| `actor_usage` | Runtime, proxy, and storage metering | $0.00001 |
| `metadata` | One processed talk without saved video | $0.05 |
| `download` | One processed talk with saved video | $0.22 |

On those declarations, the minimum metadata example is $0.05 plus metered usage, while a download begins at $0.22 plus metered usage.

### Use Cases & Applications

Learning teams can register authorized talks in a course catalog. Researchers can attach normalized source metadata to citations. Editors can queue a permitted video for review. Accessibility or language systems can hand an allowed file to a separate transcription or caption workflow.

For change tracking, retain each dated Dataset item and compare outside the Actor. This tool neither watches TED nor discovers new talks.

### Limits & Troubleshooting

TED can remove a talk, change its page, restrict playback, provide only certain renditions, or alter embedded media delivery. Geographic access, network throttling, and extractor changes may also affect a run. There are no login, cookie, or region inputs.

When a request fails, first replace the placeholder and open the canonical Talk page privately. Confirm the page is an individual talk rather than a collection. Retry using metadata. If metadata is correct but storage is empty, check the requested quality, logs, and key-value store.

Release regression should cover a current public Talk, an event or playlist URL expected to be rejected by the documented scope, a removed page, and one authorized file run. Record the extractor key, talk ID, thumbnail, mode, final status, and stored-file result.

### FAQ

#### Will this search TED by topic or speaker?

No. Supply the exact talk page yourself.

#### Does it return the official transcript?

Transcript retrieval is not part of this Actor’s inputs or output promise.

#### Can it download a whole TED series?

No. The public unit is one Talk page per run.

#### Are comments collected?

No comment control exists, and the compatibility array is normally empty.

#### Is the selected resolution guaranteed?

No. The quality value is constrained by renditions TED actually exposes.

#### Why might metrics be null?

The normalized model includes cross-platform keys that an individual TED page may not publish.

#### Can a scheduler rerun a talk?

Yes; each scheduled run processes the supplied page again.

#### Does the returned language field describe the audio or the subtitles?

`language` reports the primary spoken language TED publishes for the talk. Translated caption tracks are listed separately in `subtitles` as language codes. A talk can therefore report English audio while offering dozens of subtitle codes, and neither field implies that a translated audio track exists.

### Legal & Responsible Use

Download or retain a Talk only when you have the necessary rights. Callers remain responsible for TED terms, speaker and publisher rights, copyright, privacy, applicable law, and retention decisions.

### Related Tools

- [Video Transcript](https://apify.com/agentx/video-transcript) creates text from permitted media.
- [Video Captions Downloader](https://apify.com/agentx/video-captions-downloader) retrieves available caption tracks.
- [Video to Social Post](https://apify.com/agentx/video-to-social-post) helps draft from authorized source media.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper) provides a general multi-site interface.

### Support & Community

The 404 Store result means there is no verified Actor ID, public review record, issue history, usage count, or Store run to cite yet.

- [AgentX community](https://t.me/Apify_Actor)
- [Message AgentX](https://t.me/AiAgentApi)
- [Create or open an Actor](https://apify.com/agentx/ted-video-downloader)
- [REST API docs](https://apify.com/agentx/ted-video-downloader/api)
- [MCP integration docs](https://docs.apify.com/integrations/mcp)

After launch, provide the stable ID, redacted Talk URL, exact input, and run ID when requesting support.

**[Prepare a test run](https://apify.com/agentx/ted-video-downloader)**

**[Read the Apify API reference](https://apify.com/agentx/ted-video-downloader/api)**

# Actor input Schema

## `video_url` (type: `string`):

Publicly accessible TED Talk page URL.

## `video_quality` (type: `string`):

Preferred download quality, or metadata-only mode without a video file.

## Actor input object example

```json
{
  "video_url": "https://www.ted.com/talks/ken_robinson_do_schools_kill_creativity"
}
```

# Actor output Schema

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

All video details and optional download links with full engagement stats and comments

# 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 = {
    "video_url": "https://www.ted.com/talks/ken_robinson_do_schools_kill_creativity"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/ted-talk-downloader").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 = { "video_url": "https://www.ted.com/talks/ken_robinson_do_schools_kill_creativity" }

# Run the Actor and wait for it to finish
run = client.actor("agentx/ted-talk-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "video_url": "https://www.ted.com/talks/ken_robinson_do_schools_kill_creativity"
}' |
apify call agentx/ted-talk-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=agentx/ted-talk-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/ycypqInIRun90HIlD/builds/wGhnXOxu0r4NgGJMr/openapi.json