# NetShort 1080p Video URL Scraper – Batch Free Episodes (`spider_studio/netshort-drama-playback-urls`) Actor

Batch-extract highest-quality 1080p NetShort playback URLs, episode IDs, subtitles, and metadata for every episode available to free users.

- **URL**: https://apify.com/spider\_studio/netshort-drama-playback-urls.md
- **Developed by:** [NewLai](https://apify.com/spider_studio) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 successful drama playback results

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?

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

### What does NetShort 1080p Video URL Scraper – Batch Free Episodes do?

**NetShort 1080p Video URL Scraper** batch-extracts the highest-quality playback links currently available for free episodes of a [NetShort](https://netshort.com/) short drama. Enter one `short_play_id` and receive episode IDs, episode numbers, direct HTTPS video URLs, optional backup links, quality labels, subtitles, and supporting episode metadata in one structured Dataset result.

> **Availability limitation:** this Actor only returns episodes that a free NetShort user can currently play. It does not unlock, bypass, or extract paid and subscriber-only episodes. `playableEpisodeCount` can therefore be lower than `catalogEpisodeCount`.

The Actor returns playback URLs and metadata only. It does not download, copy, or store video files.

### Why use this NetShort 1080p video URL scraper?

- Collect the highest-quality available **1080p NetShort playback URLs** in bulk for one drama.
- Replace manual episode-by-episode URL collection with one Actor run.
- Match every link to a precision-safe `episodeId` and `episodeNo`.
- Capture primary and backup playback links where NetShort provides both.
- Export subtitle metadata, including subtitle language, format, expiry, and URL.
- Connect results to licensed playback workflows, media QA, transcription, localization review, or availability monitoring.
- Run through the Apify API, schedules, webhooks, integrations, or MCP-compatible workflows.

### What fields are included in the JSON output?

| JSON field | Type | Meaning |
| --- | --- | --- |
| `short_play_id` | string | NetShort drama ID supplied as input |
| `success` / `error` | boolean / string | Run result and safe failure message |
| `response.data.shortPlayId` | string | Confirmed NetShort short-drama ID |
| `catalogEpisodeCount` | integer | Number of episodes reported for the drama |
| `playableEpisodeCount` | integer | Number of free-user episodes with a usable URL |
| `requestedPlayClarity` | string | Requested highest quality, currently `1080p` |
| `episodes[].episodeId` | string | NetShort episode ID |
| `episodes[].episodeNo` | integer | Episode number in the drama |
| `episodes[].playUrl` | string or null | Primary direct HTTPS playback URL |
| `episodes[].backupPlayUrl` | string or null | Optional alternative playback URL |
| `episodes[].playClarity` | string or null | Quality actually returned for the episode |
| `episodes[].subtitleList` | array | Subtitle language, format, expiry, ID, and URL data |
| `episodes[].detail` | object | Additional episode metadata returned with the playable link |
| `response.data.drama` | object | Available drama-level metadata |

Signed playback and subtitle URLs can expire. Run the Actor again when you need fresh links.

### Which NetShort episodes can be extracted?

Only episodes available to a free NetShort user are included in `response.data.episodes`. If a drama reports 57 total episodes but only 10 are freely playable, the output will show:

```json
{
  "catalogEpisodeCount": 57,
  "playableEpisodeCount": 10
}
```

This difference is expected and is not treated as an error. Paid, locked, subscription-only, or otherwise unavailable episodes are omitted from the playable URL list.

### How to batch-extract NetShort episode playback URLs

1. Obtain a NetShort `shortPlayId` from a search, recommendations, or drama metadata result.
2. Open the Actor Input tab.
3. Paste the ID into `short_play_id`.
4. Click **Start** and wait for the run to finish.
5. Open Output and read `response.data.episodes`.
6. Use `playUrl` as the primary link and `backupPlayUrl` when it is available.

No episode IDs, episode numbers, quality settings, or additional configuration are required.

### Input

`short_play_id` is the only input. Supply it as a string containing 1–32 digits to preserve large NetShort identifiers correctly.

```json
{
  "short_play_id": "1894649306163933185"
}
```

### Output example based on a real Actor run

The following structure and counts come from a successful run. The signed URL is shortened because live playback links expire:

```json
{
  "short_play_id": "1894649306163933185",
  "success": true,
  "error": null,
  "upstream_code": 200,
  "upstream_message": "操作成功",
  "response": {
    "code": 200,
    "data": {
      "shortPlayId": "1894649306163933185",
      "firstEpisodeId": "1894649306868576297",
      "catalogEpisodeCount": 57,
      "playableEpisodeCount": 10,
      "requestCount": 6,
      "stopReason": "no_new_playable_episodes",
      "codec": "h264",
      "requestedPlayClarity": "1080p",
      "episodes": [
        {
          "episodeId": "1894649306868576297",
          "episodeNo": 1,
          "episodeType": 1,
          "playUrl": "https://ns-aws-cdn.netshort.com/...",
          "backupPlayUrl": null,
          "playClarity": "1080p",
          "subtitleList": [
            {
              "subtitleLanguage": "...",
              "format": "...",
              "expireTime": "...",
              "url": "https://..."
            }
          ],
          "detail": {}
        }
      ]
    }
  }
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. JSON is recommended because episode details and subtitles are nested.

### Can I use this as a NetShort playback URL API?

Yes. Run the Actor through Apify's HTTP API, JavaScript or Python client, CLI, OpenAPI specification, or MCP integration. The API tab provides ready-to-use examples for synchronous and asynchronous runs.

Use asynchronous runs for workflows that store the Dataset ID and process URLs later. Because links may expire, avoid long delays between extraction and authorized playback or analysis.

### Common use cases

- Validate which episodes are currently available to free viewers.
- Prepare licensed media review or quality-assurance workflows.
- Collect subtitle URLs for authorized localization and accessibility checks.
- Enrich an internal short-drama catalog with episode-level availability.
- Refresh expired links before an approved playback or processing task.
- Compare `catalogEpisodeCount` with `playableEpisodeCount` over time.

### Cost and responsible use

The Actor uses pay-per-event pricing and charges once for each successfully saved `short_play_id` result containing at least one free-user playback URL:

- **Free Apify plan:** $0.004 per successful drama playback result.
- **Bronze, Silver, Gold, Platinum, and Diamond plans:** $0.003 per successful result.
- **Platform usage:** runtime, storage, proxy, and data-transfer costs are paid separately by the user.

Failures, dramas with no free-user playback URLs, retries, and results blocked by the run's maximum charge limit are not charged. There is no separate start fee. Saving the Dataset row and charging the `successful-drama-playback` event are performed together so a successful event charge always corresponds to a stored result.

Playback URLs may provide access to copyrighted media. Use them only when you have the necessary authorization and in accordance with NetShort's terms, copyright law, privacy obligations, and other applicable rules. The Actor does not grant content rights.

### FAQ and support

#### Why are fewer episodes returned than the drama's episode count?

`catalogEpisodeCount` describes the full drama, while `playableEpisodeCount` includes only episodes a free user can play. Locked and paid episodes are intentionally excluded.

#### Does the Actor always return 1080p?

The Actor requests the highest configured quality of 1080p. Check each episode's `playClarity` field to confirm the quality NetShort actually returned.

#### Does this Actor download NetShort videos?

No. It returns direct playback URLs and metadata but does not download or store video files.

#### Why did a previously working link expire?

NetShort playback and subtitle URLs can be signed and time-limited. Start a new run to obtain fresh URLs.

For reproducible problems, use the Actor Issues tab and include the input ID, run ID, and safe error message. Do not post active playback URLs or private credentials.

# Actor input Schema

## `short_play_id` (type: `string`):

Required NetShort short-play ID. The Actor discovers episode IDs and playable URLs automatically.

## Actor input object example

```json
{
  "short_play_id": "1894649306163933185"
}
```

# Actor output Schema

## `dataset` (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 = {
    "short_play_id": "1894649306163933185"
};

// Run the Actor and wait for it to finish
const run = await client.actor("spider_studio/netshort-drama-playback-urls").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 = { "short_play_id": "1894649306163933185" }

# Run the Actor and wait for it to finish
run = client.actor("spider_studio/netshort-drama-playback-urls").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 '{
  "short_play_id": "1894649306163933185"
}' |
apify call spider_studio/netshort-drama-playback-urls --silent --output-dataset

```

## MCP server setup

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

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/b2HNnzxkxFf8J71Zy/builds/ubI09yLk2oUEXo8FL/openapi.json