# PineDrama Scraper - Short-Drama Series, Episodes & Views (`abotapi/pinedrama-scraper`) Actor

Scrape the PineDrama short-drama catalogue: series with watch counts, episode counts, categories, theme tags, covers, language, hot/new/free labels, creator ids and full episode lists. Filter by keyword or category in 17 languages, or paste links. Incremental runs and MCP export.

- **URL**: https://apify.com/abotapi/pinedrama-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 series records

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?

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 Scraper: Short-Drama Series, Episodes & Views

PineDrama Scraper turns the PineDrama short-drama catalogue into a clean data feed. Get every series with its watch count, episode count, categories, theme tags, cover, language, hot, new and free labels, plus creator ids, full episode lists and, optionally, each series' synopsis, first-episode play, like and comment counts and creator profile. Browse the whole catalogue or narrow it by keyword and category in 17 languages, or paste catalogue and series links, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Two ways in.** Walk the catalogue with optional keywords and category filters, or paste landing, catalogue, series and recommendation links. No URL building needed.
- **Engagement at a glance.** Exact watch counts and episode counts per series, with hot, new and limited-free labels, so charting titles are easy to spot.
- **Full episode depth.** Every enriched series carries its creator id, shortcut count, first-episode video id and the complete episode list with free or paid and intro flags.
- **Video and creator stats.** Switch on **Fetch first-episode video stats** to add the synopsis, caption, play, like, comment, share and save counts, duration, publish time and the creator's handle, name, bio and follower count.
- **17 languages.** Category and tag names come back localized, and each series reports its own spoken language.
- **Category filter list attached.** Every series lists the filter entries that match it, with ids, so rows join cleanly to the site's own category list.
- **Built for schedules.** Incremental mode returns only new and changed series on recurring runs, and a run whose connection is refused fails loudly instead of returning an empty dataset.

### Use Cases

- **Content analysts:** track which short dramas are charting by watch count, category and tag.
- **Studios and licensors:** map trope and theme coverage, episode counts and free windows across the catalogue.
- **Marketing and growth teams:** spot new and hot releases early and watch how fast counts move.
- **AI agents and dashboards:** feed structured catalogue and episode data into your own tools.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `collection_id` | `"0000000000000000000"` |
| `title` | `"Sample Drama"` |
| `cover_url` | cover image link |
| `cover_width` / `cover_height` | `720` / `720` |
| `episode_count` | `60` |
| `watched_count` | `1250000` |
| `categories` | `["CEO", "Urban"]` |
| `theme_tags` | `["CEO", "Urban"]` |
| `category` | `1` |
| `category_filters` | matching filter entries with `category_id`, `name`, `name_en` |
| `is_limited_free` | `true` |
| `label_hot` / `label_new` | `false` / `false` |
| `language_code` | `"en"` (spoken language of the series) |
| `language` | `"en"` (language of category names) |
| `scene` / `page` | `1` / `1` |
| `keyword` | the keyword that matched, when keywords are used |
| `video_id` | `"0000000000000000000"` (first episode) |
| `creator_id` / `short_cut_num` | `"0000000000000000000"` / `24` |
| `episodes` | number, sequence id, video id, intro flag, paid flag, free window |
| `description` / `video_text` / `video_url` | series synopsis, first-episode caption and public link (video stats option) |
| `video_play_count` / `video_like_count` / `video_comment_count` | engagement of the first episode, plus share, save, duration and publish time (video stats option) |
| `total_duration_seconds` / `theme_tags_en` / `theme_tag_keys` | `7469`, English tag names and their stable keys, e.g. `["Sample Tag A"]` / `["tag_Sample_Plot"]` (video stats option) |
| `creator_username` / `creator_nickname` / `creator_followers` | creator handle, display name, reach, bio and profile link (video stats option) |
| `source_collection_id` | the series a recommendation came from |
| `changeType` / `changedFields` | `"NEW"` / `[]` in incremental mode |

### How to Use

1. Pick a **mode**: `Search the catalogue` or `Paste links`.
2. For search, optionally add keywords, category filters and a language; for links, paste your links.
3. Switch **Fetch episode lists** on or off depending on whether you need episodes.
4. Set **Max items** to control run size and cost, then click **Start**.
5. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Catalogue with episode lists:**

```json
{
  "mode": "search",
  "fetchDetails": true,
  "maxItems": 20
}
```

**Keyword and category filter, cards only:**

```json
{
  "mode": "search",
  "keywords": ["CEO"],
  "categoryFilters": ["Revenge"],
  "fetchDetails": false,
  "maxItems": 100
}
```

**Localized category names:**

```json
{
  "mode": "search",
  "language": "fr",
  "maxItems": 50
}
```

**Paste links:**

```json
{
  "mode": "url",
  "urls": [
    { "url": "https://shortdrama.tiktok.com/gb" }
  ],
  "fetchDetails": true,
  "maxItems": 50
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/pinedrama-scraper").call(run_input={"mode": "search", "maxItems": 10})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["watched_count"], item["episode_count"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/pinedrama-scraper').call({ mode: 'search', maxItems: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### How keywords and categories work

The catalogue is read page by page (12 series each) and narrowed as it is read, so a rare keyword or category can take many pages before enough matches are found. Set **Max items** for the result you want and optionally cap the walk with **Max pages**. Matching is case-insensitive against the title, categories and theme tags, in the language you picked.

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one interrupted run: paste its run ID and the actor skips everything already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for scheduled runs over the same scope. Each series is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED` or `EXPIRED` (only with `emitExpired`, only after a scan that covered the whole scope, and never billed past your `maxItems`). Compared: title, episode count, categories, theme tags, labels, free window, creator id, shortcut count and the episode list. Ignored: watch count, signed cover link and scrape time. `stateKey` names or shares the stored state. With incremental mode off, output is exactly as before.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` walks the catalogue; `url` scrapes pasted links. |
| `keywords` | array | (none) | Keep series whose title, categories or tags contain one of these words. |
| `categoryFilters` | array | (none) | Keep series tagged with one of these categories or tags. |
| `language` | string | `en` | Language of category and tag names (17 supported). |
| `urls` | array | 7 sample links | Landing, catalogue, series, recommendation and category-filter links for URL mode. |
| `fetchDetails` | boolean | `true` | Fetch each series' episode list, creator id and shortcut count. Adds the detail-enrichment charge per series. |
| `fetchVideoStats` | boolean | `false` | Also read each series' first episode video page: synopsis, engagement counts, duration, publish time and creator profile. Needs episode lists; same detail-enrichment charge, heavier per series. |
| `maxPages` | integer | unlimited | Optional page limit per link or search; blank or `0` = unlimited. Does not cap results. |
| `maxItems` | integer | `20` | Stop after this many series (`0` = no limit). |
| `proxy` | object | residential | Connection setting. Residential is the default and recommended. |
| `resumeFromRunId` | string | (none) | Continue one interrupted run. |
| `incrementalMode` | boolean | `false` | Return only new and changed series on scheduled runs. |
| `stateKey` | string | (none) | Name or share an incremental-mode state. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) unchanged series. |
| `emitExpired` | boolean | `false` | Also return (and bill) expired series; only after a scan that covered the whole scope. |
| `ignoreFieldsForChanges` | array | (none) | Extra fields that never mark a series as updated. |
| `mcpConnectors` | array | (none) | Pipe result summaries into your apps via MCP connectors. |
| `notionParentPageUrl` | string | (none) | Notion parent page for the Notion connector. |
| `maxNotifyListings` | integer | `50` | Cap on items written per connector. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

**Series record** (the video and creator keys appear only with `fetchVideoStats`; a few series are not shown on the web and keep them empty):

```json
{
  "recordType": "series",
  "collection_id": "0000000000000000000",
  "title": "Sample Drama",
  "cover_url": "https://example.com/cover.jpeg",
  "cover_width": 720,
  "cover_height": 720,
  "episode_count": 60,
  "watched_count": 1250000,
  "categories": ["CEO", "Urban"],
  "theme_tags": ["CEO", "Urban"],
  "category": 1,
  "is_limited_free": true,
  "label_hot": false,
  "label_new": false,
  "language_code": "en",
  "scene": 1,
  "category_filters": [{ "category_id": "0000000000000000000", "name": "Urban", "name_en": "urban" }],
  "keyword": null,
  "video_id": "0000000000000000000",
  "creator_id": "0000000000000000000",
  "short_cut_num": 24,
  "description": "Sample synopsis (video stats option)",
  "video_url": "https://example.com/video",
  "video_play_count": 1250000,
  "video_like_count": 68000,
  "video_duration_seconds": 103,
  "creator_username": "sample.creator",
  "creator_followers": 169000,
  "episodes": [{ "episode_number": 1, "sequence_id": 1, "video_id": "0000000000000000000", "is_intro": false, "is_paid": false }],
  "changeType": "NEW"
}
```

The **Series**, **Series detail**, **Video and creator** and **Incremental changes** dataset views are available in the output tab.

### Plan Requirement

The default connection is Apify Residential, which the data source serves reliably; this is the recommended setting. Datacenter proxies are cheaper but the data source answers its catalogue, recommendation and category routes with empty pages on datacenter exits, so they are only suitable for light use. If a datacenter run keeps getting empty pages, the actor retries with backoff on fresh connections and then escalates automatically to residential for the rest of the run (capped per run, billed to your Apify plan), returning to datacenter when it serves again.

Apify free plans do not include residential proxies. On a free plan the run logs a one-time notice and continues on a backup connection; some pages may still be unavailable. For residential access, upgrade at https://apify.com/pricing or supply your own proxy URLs. If no connection can load any results page, the run fails with a clear message instead of returning an empty result.

### FAQ

#### How much does it cost?

You pay per series returned, with episode-list enrichment billed only when you switch it on. The **Pricing** tab shows the current rates. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape PineDrama?

This actor collects only publicly available catalogue data: titles, counts, categories and episode lists. You are responsible for how you use it: follow the site's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Titles and counts are generally facts, but cover art and videos may be subject to third-party rights.

#### Can I get only new or changed series on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new and updated series, and unchanged ones are not billed.

#### Why did a run return fewer series than the site shows?

The run stops at **Max items**. Set it higher, or to `0`, to collect more. With keywords or category filters only matching series are returned. Episodes attached to a series do not count toward `maxItems`.

#### Why are the video stats empty for some series?

The platform does not show the first episode of some series on the web, so no public video page exists to read. Those rows keep the catalogue and episode data and leave the video and creator fields empty.

#### Why did my run fail instead of returning an empty dataset?

If every connection tried returns an empty page, the run stops with a clear message so "no results" is never confused with "nothing could be read". Run it again in a few minutes.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 More scrapers you might like

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🧩 <a href="https://apify.com/abotapi/goodshort-catalog-scraper"><b>GoodShort Scraper</b></a><br>Scrape the GoodShort short-drama catalog: titles with exact views, follows, genres and...</td><td>🧩 <a href="https://apify.com/abotapi/webtoons-com-scraper"><b>WEBTOON Scraper</b></a><br>Scrape the WEBTOON catalog into structured data. Extract series, genres, rankings and...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/anghami-catalog-scraper"><b>Anghami Scraper</b></a><br>Scrape Anghami's public catalog by keyword or player URL. Rows carry their kind (song...</td><td>🤖 <a href="https://apify.com/abotapi/suno-music-scraper"><b>Suno Scraper</b></a><br>Collect public Suno music data: songs with lyrics, style tags, model version, play and...</td></tr>
<tr><td>⚽ <a href="https://apify.com/abotapi/hotstar-com-scraper"><b>JioHotstar Scraper</b></a><br>Scrape the JioHotstar catalog by content type or URL. Extract shows, movies, episodes...</td><td>🧩 <a href="https://apify.com/abotapi/pikabu-scraper"><b>Pikabu Scraper</b></a><br>Scrape Pikabu (Пикабу): keyword search, hot/new/best feeds, communities, tags, full story...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support & custom scrapers

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/pinedrama-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com> or message [Telegram @abotapi](https://t.me/abotapi).
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Search walks the whole short-drama catalogue, optionally narrowed by keywords and category filters. URL mode scrapes the links you paste in the URL section.

## `keywords` (type: `array`):

Only keep series whose title, categories or theme tags contain one of these words (case-insensitive). The catalogue is walked and narrowed as it is read, so a rare keyword can take many pages. Leave empty for every series.

## `categoryFilters` (type: `array`):

Only keep series tagged with one of these categories or theme tags, for example Revenge, Zero to hero or Werewolf. Names are matched in the language chosen below. Leave empty for every category.

## `language` (type: `string`):

Language of the category and tag names. The series titles themselves stay in each series' own language (see language_code).

## `urls` (type: `array`):

Multi-URL, search fields ignored. Accepts the short-drama landing page (also a country page or the sitemap) and series links. A series link returns that series with its episode list.

## `fetchDetails` (type: `boolean`):

Fetch each series' episode list: creator id, shortcut count, first-episode video id and every episode with its number, free or paid status and intro flag. Adds the detail-enrichment charge per series. Without it you still get the catalogue card: title, cover, counts, categories, tags and labels.

## `fetchVideoStats` (type: `boolean`):

Also read the public page of each series' first episode video (needs Fetch episode lists): series synopsis, caption, play, like, comment, share and save counts, duration, publish time, and the creator's handle, name, bio, followers and profile link. Heavier per series; counted in the same detail-enrichment charge. Off by default.

## `maxPages` (type: `integer`):

Optional limit on catalogue pages walked per link or search. This does NOT cap results and has no default (blank or 0 = unlimited); it defers to Max items, which is the single cap on a run.

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

The one cap on a run (default 20): stop after this many series records. Episodes nested inside a series do not count as items. Set 0 for no limit. Max pages does not cap results and defers to this field.

## `proxy` (type: `object`):

Residential is the default and recommended. Datacenter is cheaper but the data source often answers it with empty pages, so choose it only for light use. If the selected connection is refused the run continues on a backup connection; on a free Apify plan (no proxy access) some pages may be unavailable.

## `resumeFromRunId` (type: `string`):

ID of an interrupted run to continue. The run skips series already saved. Leave empty for a fresh run.

## `incrementalMode` (type: `boolean`):

Compare series against the previous run for the same scope (state key) and only emit NEW or UPDATED rows (plus optional EXPIRED tombstones). Compared: title, episode count, categories, theme tags, labels, free window, creator id, shortcut count and the episode list (number, id, paid flag, intro flag). Ignored: watch count, signed cover URL, scrape time. Unchanged series are skipped and not charged.

## `stateKey` (type: `string`):

Name of the remembered baseline for incremental mode. Defaults to a hash of the current scope, so two runs with the same settings compare against each other automatically.

## `emitUnchanged` (type: `boolean`):

In incremental mode, also emit rows classified UNCHANGED (handy for full snapshots or debugging).

## `emitExpired` (type: `boolean`):

In incremental mode, emit an EXPIRED row for series present in the baseline but missing from this run. Only a scan that walked the whole scope expires anything: a run stopped by Max items, Max pages, an error, or started mid-catalogue never does. Tombstones respect Max items.

## `ignoreFieldsForChanges` (type: `array`):

Extra dataset fields that must NOT mark a record UPDATED when they change (watch count, cover URL and scrape time are ignored by default).

## `mcpConnectors` (type: `array`):

Optionally send the results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per series, not the full JSON, the complete record stays in the dataset. Leave empty to skip.

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "CEO"
  ],
  "language": "en",
  "urls": [
    {
      "url": "https://shortdrama.tiktok.com/"
    },
    {
      "url": "https://shortdrama.tiktok.com/gb"
    },
    {
      "url": "https://shortdrama.tiktok.com/sitemap.xml"
    }
  ],
  "fetchDetails": true,
  "fetchVideoStats": false,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

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

No description

## `changes` (type: `string`):

No description

## `video` (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 = {
    "mode": "search",
    "keywords": [
        "CEO"
    ],
    "language": "en",
    "urls": [
        {
            "url": "https://shortdrama.tiktok.com/"
        },
        {
            "url": "https://shortdrama.tiktok.com/gb"
        },
        {
            "url": "https://shortdrama.tiktok.com/sitemap.xml"
        }
    ],
    "fetchDetails": true,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/pinedrama-scraper").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 = {
    "mode": "search",
    "keywords": ["CEO"],
    "language": "en",
    "urls": [
        { "url": "https://shortdrama.tiktok.com/" },
        { "url": "https://shortdrama.tiktok.com/gb" },
        { "url": "https://shortdrama.tiktok.com/sitemap.xml" },
    ],
    "fetchDetails": True,
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/pinedrama-scraper").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 '{
  "mode": "search",
  "keywords": [
    "CEO"
  ],
  "language": "en",
  "urls": [
    {
      "url": "https://shortdrama.tiktok.com/"
    },
    {
      "url": "https://shortdrama.tiktok.com/gb"
    },
    {
      "url": "https://shortdrama.tiktok.com/sitemap.xml"
    }
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call abotapi/pinedrama-scraper --silent --output-dataset

```

## MCP server setup

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

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/S5Uw261tBGbG6A2Hy/builds/rk2yEXAsVN7Nf2vCJ/openapi.json