# PineDrama Transcript API | Timestamps & Opening Hooks (`spider_studio/pinedrama-transcript`) Actor

Extract PineDrama episode transcripts with timestamps, speaker labels and opening hooks. Transcribe full series or selected episodes and export structured JSON.

- **URL**: https://apify.com/spider_studio/pinedrama-transcript.md
- **Developed by:** [Tarique](https://apify.com/spider_studio) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.99 / 1,000 successful episode transcripts

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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

## PineDrama Transcript API

Extract **PineDrama short drama transcripts** with timestamps, speaker labels, and opening hooks. Transcribe an entire series or selected episodes, then collect structured JSON for dialogue search, content research, and creative analysis.

Each successful episode includes its full transcript and the first spoken sentence as an opening hook. Process up to **10 series or 1,000 unique episodes per run**.

### 🔗 Explore more PineDrama Actors

Build your PineDrama workflow, from finding a series to collecting episodes, video URLs, and transcripts.

| Actor | What you can do |
| --- | --- |
| 🔎 [PineDrama Search Scraper](https://apify.com/spider_studio/pinedrama-drama-search) | Find short dramas and series IDs by keyword. |
| 📖 [PineDrama Drama Details Scraper](https://apify.com/spider_studio/pinedrama-drama-details-scraper) | Get series information, episode lists, and first-episode IDs. |
| 📋 [PineDrama Episodes Scraper](https://apify.com/spider_studio/pinedrama-drama-episodes) | Collect episode IDs and their order for a series. |
| ▶️ [PineDrama Video URL Scraper](https://apify.com/spider_studio/pinedrama-episode-playback) | Get playable episode URLs and available video details. |
| ✨ [PineDrama Recommendations Scraper](https://apify.com/spider_studio/pinedrama-drama-recommendations) | Discover similar short dramas from a series ID. |

### What can you do with PineDrama transcripts?

- Build a searchable library of short drama dialogue.
- Compare opening lines, suspense, and conflict across episodes.
- Find spoken passages and their timestamps for clip research.
- Organize transcripts by series and episode.
- Collect results through Apify Console or the API for your own workflows.

### How to get started

1. Choose full-series transcription or selected episodes.
2. Enter the relevant PineDrama IDs using one of the examples below.
3. Review the price and set your maximum run spend.
4. Start the Actor and open the results when the run finishes.

Use [PineDrama Search](https://apify.com/spider_studio/pinedrama-drama-search) to find series IDs and [PineDrama Episodes](https://apify.com/spider_studio/pinedrama-drama-episodes) to find episode IDs. You can also explore [PineDrama Recommendations](https://apify.com/spider_studio/pinedrama-drama-recommendations) to discover related series.

### Input examples

#### Transcribe a full series

```json
{
  "collectionIds": ["7675963864189735957"]
}
```

Supply up to 10 unique series IDs. The combined series must contain no more than 1,000 unique episodes. Full-series mode uses the series title to help recognize dialogue.

#### Transcribe selected episodes

```json
{
  "episodes": [
    {
      "collection_id": "7675963864189735957",
      "video_id": "7675963864189752341"
    }
  ]
}
```

Supply up to 1,000 unique episodes. Each episode needs both its series ID (`collection_id`) and episode ID (`video_id`). This mode transcribes the audio without additional series-title context.

Choose either `collectionIds` or `episodes` in one run. IDs must be strings containing 1–20 digits. Duplicate entries are removed before input limits are checked. Example IDs show the required format; availability can change.

### Transcript output

The Dataset contains one row per unique episode. Results include:

| Field | What you receive |
| --- | --- |
| `seriesId`, `videoId` | PineDrama series and episode identifiers. `seriesId` corresponds to the input `collection_id`. |
| `episodeNumber`, `title`, `sourceSeriesIds` | Available episode number, series title, and associated series IDs. |
| `durationSeconds`, `language` | Audio duration and the detected language when available. |
| `transcript` | Recognized dialogue for the episode. |
| `hook` | The first non-empty recognized sentence in audio order. |
| `hookStartSeconds`, `hookEndSeconds` | Opening-hook timestamps when they can be determined reliably. |
| `segments` | Dialogue segments with start and end times, text, and speaker labels. |
| `wordsJsonUrl` | A link to word-level transcript data when available. |
| `status`, `errorCode` | Whether the episode succeeded, failed, or remains pending, with an error code when relevant. |
| `generatedAt` | When the transcript was originally generated. |

A shortened, fictional example:

```json
{
  "seriesId": "7675963864189735957",
  "videoId": "7675963864189752341",
  "episodeNumber": 1,
  "title": "Example Drama",
  "durationSeconds": 120,
  "language": "en",
  "transcript": "Why are you here? I came to find you.",
  "hook": "Why are you here?",
  "hookStartSeconds": 1.2,
  "hookEndSeconds": 2.8,
  "segments": [
    {
      "start": 1.2,
      "end": 2.8,
      "text": "Why are you here?",
      "speakerId": "speaker_0"
    }
  ],
  "status": "succeeded",
  "errorCode": null
}
```

The Actor delivers JSON transcripts. It does not generate SRT or VTT subtitle files. Speaker labels distinguish voices within an episode; they do not identify characters or match people across episodes. Fields that are unavailable may be `null`.

### Opening hook extraction

Collect the first spoken sentence alongside each full transcript to build an opening-line library, compare storytelling approaches, and research promotional clips. Hook extraction is included in the episode price.

The hook reflects recognized dialogue. It is not a generated headline, a plot summary, or a fixed three-second excerpt. Opening silence is skipped. When an exact sentence boundary cannot be timed reliably, its ending timestamp may be `null`.

### Pricing

The same event prices apply to **all Apify plans, including Free**.

| Charge | Price |
| --- | --- |
| Successful episode transcript, including the first 180 seconds | **$0.01499 per episode — $14.99 per 1,000 episodes** |
| Each started minute beyond 180 seconds | **$0.006 per additional minute** |
| Failed, speech-free, pending, or budget-skipped episode | **No successful-result event charge** |

Full transcripts, opening hooks, and available timestamps are included. A 4-minute-20-second episode costs `$0.01499 + 2 × $0.006 = $0.02699` in event charges. Full-series requests are priced per successful episode.

**Apify platform usage is charged separately**, including compute, storage, and proxies. Check the active prices in the Pricing tab before starting a run.

Duplicate episode IDs within one uninterrupted run produce one result and one set of result charges. Each new run is charged normally for successful results, including episodes processed previously or results that can be reused.

**Free-plan accounts can receive up to 10 successful episode results per UTC calendar month.** This is a usage cap, not a free-transcription allowance: the event prices above still apply. Successful results from repeat runs count toward the cap.

### Limits and result quality

Episodes can be up to 30 minutes long. A very low maximum run spend can cause an episode to be skipped before its duration is known. Input limits, the Free-plan monthly cap, and the maximum run spend are separate limits.

Background music, accents, overlapping speech, and recording quality can affect transcription. Review dialogue and timing before using them in published work. Unavailable episodes return a status and error code; other episodes can continue while budget and quota allow.

If a run is interrupted, completed results remain available in that run. Review its results and charge history before starting another run.

### Frequently asked questions

#### Can I transcribe an entire PineDrama series?

Yes. Use `collectionIds` for up to 10 series, with a combined maximum of 1,000 unique episodes. Each successful episode has its own result and price.

#### Do I need both IDs for a selected episode?

Yes. Each `episodes` entry requires `collection_id` and `video_id`. Use the related Search and Episodes Actors to obtain them.

#### Are previously processed episodes charged again?

Yes. Each new run charges for successfully delivered episode results at the same price. Duplicate episode IDs within the same uninterrupted run are counted once.

#### Is this a translation service?

No. The Actor transcribes spoken dialogue; it does not translate transcripts into a requested language.

### Support

Maintained by [spider_studio](https://apify.com/spider_studio), independently of PineDrama. For help, share your run URL through the Issues tab. See the API tab to connect this Actor to your application.

# Actor input Schema

## `collectionIds` (type: `array`):

Transcribe all episodes of up to 10 collections. Use this or episodes.

## `episodes` (type: `array`):

Up to 1000 episodes, each with collection_id and video_id. Use this or collectionIds.

## Actor input object example

```json
{
  "collectionIds": [
    "7675963864189735957"
  ],
  "episodes": []
}
```

# Actor output Schema

## `episodes` (type: `string`):

No description

## `files` (type: `string`):

No description

# 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 = {
    "collectionIds": [
        "7675963864189735957"
    ],
    "episodes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("spider_studio/pinedrama-transcript").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 = {
    "collectionIds": ["7675963864189735957"],
    "episodes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("spider_studio/pinedrama-transcript").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 '{
  "collectionIds": [
    "7675963864189735957"
  ],
  "episodes": []
}' |
apify call spider_studio/pinedrama-transcript --silent --output-dataset

```

## MCP server setup

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

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/wwaXXaNASYbKsdfNM/builds/10ChJn3iutHOFHutY/openapi.json