# CapCut Template Video Downloader (`automation-lab/capcut-shared-video-downloader`) Actor

Resolve supplied public CapCut template URLs to preview-media links, title, author, thumbnail, duration and use count for authorized preview inventory and archiving.

- **URL**: https://apify.com/automation-lab/capcut-shared-video-downloader.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.44 / 1,000 template resolveds

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

## CapCut Template Video Downloader

Resolve supplied public CapCut template URLs into metadata and available preview-media links. This **capcut template video downloader** supports authorized preview inventory and downstream archiving—not private projects, edited-video exports, watermark removal, or guaranteed quality variants.

### What does it do?

Each genuine template yields one dataset row with its identity, title, creator, thumbnail, duration, dimensions, usage counts and current preview link where exposed. The Actor returns links, not binary video files. It never substitutes recommended templates or a generic promotional video for your input.

### Who is it for?

- Rights holders maintaining a reference inventory of their public previews.
- Creative operations teams refreshing licensed template links.
- Analysts comparing public use counts for an explicitly supplied template list.

Public availability alone does not grant permission to copy or redistribute a preview.

### Why use it?

You keep an explicit input list rather than mixing template discovery with retrieval. Exact template IDs remain strings to avoid precision loss. Results deduplicate by template ID, and dead links appear separately in a resolution report. Anonymous HTTP retrieval avoids full browser and media-download overhead.

### Getting started

1. Supply public CapCut template URLs you are authorized to process.
2. Choose the maximum number of distinct input URLs to attempt.
3. Run the Actor and open the **Template previews** dataset.
4. Inspect **Resolution summary and failures** before treating a batch as complete.
5. Export JSON, CSV, Excel or other supported Apify dataset formats; fetch permitted media downstream before source links expire.

```json
{
  "startUrls": [{"url": "https://www.capcut.com/template-detail/7518257722391825725"}],
  "maxItems": 10
}
```

### Inputs and limits

| Field | Meaning |
| --- | --- |
| `startUrls` | 1–1000 `{ "url": "https://..." }` entries. Supports `capcut.com` and `www.capcut.com`, `/template-detail/<id>`, `/template-detail/<title>/<id>` and `/t/<code>`. |
| `maxItems` | Global cap on distinct normalized supplied URLs attempted in input order. Default 100; range 1–1000. Failed URLs consume the cap. No zero or unlimited mode. |

Tracking queries and fragments are stripped. HTTPS is required. Redirects remain restricted to supported CapCut template paths. There is no search, pagination, creator discovery, location filter, authentication or user cookie input. Results can be fewer than inputs because aliases deduplicate, templates are unavailable, or the charge budget stops work.

### Extracted data

| Field | Description |
| --- | --- |
| `inputUrl`, `sourceUrl` | Normalized input and canonical matching template URL |
| `templateId` | Exact source ID as a string |
| `title`, `description` | Trimmed public title and optional description |
| `authorName`, `authorProfileUrl` | Public creator name and available profile link |
| `thumbnailUrl` | Available source thumbnail link; may expire |
| `durationSeconds` | Source duration converted from milliseconds |
| `aspectRatio`, `width`, `height` | Available source preview format metadata |
| `useCount`, `likeCount` | Public cumulative counters at retrieval |
| `previewMediaUrl` | Available preview link, not a stored file |
| `mediaStatus` | `link_available` or `not_available`; not a playback test |
| `scrapedAt` | UTC retrieval timestamp |

Optional fields are null when unavailable. Duration is a template duration, not independently measured playback time. Counters are not historical time series.

### Output example

The current control returned `new template`, 11.733 seconds, 9:16, 714×1280 pixels and approximately 274,000 uses. The shortened example below anonymizes creator and signed link values; actual rows retain current public values.

```json
{
  "templateId": "7518257722391825725",
  "title": "new template",
  "authorName": "Example Creator",
  "durationSeconds": 11.733,
  "aspectRatio": "9:16",
  "width": 714,
  "height": 1280,
  "useCount": 274199,
  "previewMediaUrl": "https://example.com/source-issued-preview.mp4",
  "mediaStatus": "link_available"
}
```

### How much does it cost to resolve CapCut template previews?

Pay per event: a **$0.06 start event per valid run**, plus a **$0.002392 BRONZE item event per unique template record delivered**. The available preview link is included without a separate charge. Failed URLs, aliases and duplicate templates have no item event charge. No-result valid runs can still incur the start charge.

| Spend tier | Item price |
| --- | ---: |
| FREE | $0.0027508 |
| BRONZE | $0.002392 |
| SILVER | $0.0018658 |
| GOLD | $0.0014352 |
| PLATINUM | $0.0014352 |
| DIAMOND | $0.0014352 |

BRONZE examples: 1 result costs approximately $0.062392; 10 approximately $0.08392; 100 approximately $0.2992. Spend tiers reflect qualifying aggregate Apify Store spend, not the size of this Actor's batch. Your applicable platform terms determine any additional platform charges; examples are estimates, not guaranteed invoices. The current Store pricing is authoritative.

### Failure behavior and troubleshooting

Network errors, HTTP 429 and 5xx responses receive up to three attempts with backoff. Deterministic missing templates, unsupported redirects and malformed state are not blindly retried. Requests run sequentially, with a 20-second timeout and five-hop redirect limit. Parsed HTML must be no larger than 2 MB; this is a parser acceptance limit, not a transfer guarantee.

A mixed batch returns useful rows and lists failed inputs in the SUMMARY key-value record. A wholly unsuccessful batch fails rather than claiming an empty successful archive. The report includes attempted, saved and failed counts, plus a budgetStopped flag. Partial output is not proof of full completion.

If a short link redirects to a generic CapCut landing page, supply a current exact template-detail URL. If media stops working later, re-resolve the template; source signatures expire. No URL is promised to be permanent or playable in every country.

### Integrations

Export the default dataset to a spreadsheet or downstream data pipeline. Schedule the same explicit URL list in Apify to refresh signatures and snapshots, then compare by `templateId` in your own database. The Actor does not itself detect new templates, retain historical snapshots, send alerts or store video binaries.

### API usage

Use your own Apify token in an environment variable, not in source code. Start a run and retain its run/storage IDs; poll the same run to a terminal status, then fetch bounded dataset pages.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~capcut-shared-video-downloader/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.capcut.com/template-detail/7518257722391825725"}],"maxItems":10}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/capcut-shared-video-downloader').call({
    startUrls: [{ url: 'https://www.capcut.com/template-detail/7518257722391825725' }], maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });
console.log(items);
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/capcut-shared-video-downloader').call(run_input={
    'startUrls': [{'url': 'https://www.capcut.com/template-detail/7518257722391825725'}], 'maxItems': 10,
})
print(client.dataset(run['defaultDatasetId']).list_items(limit=10).items)
```

### MCP setup

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/capcut-shared-video-downloader"
```

For Claude Desktop, Cursor, and VS Code, use the equivalent HTTP MCP configuration in your client's supported settings format:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/capcut-shared-video-downloader"}}}
```

Authenticate through the client's supported Apify connection. This stable scoped selection also exposes run/data helpers; discover the actual names and argument schemas with read-only `tools/list`.

Example prompt: “Resolve these authorized public CapCut template URLs with maxItems 10, then show title, duration and use count.” Start once and keep the returned run ID; it is metadata, not rows. If nonterminal, check that same run with bounded 2/4/8-second backoff, capped at 10 seconds and a 120-second total deadline. Recover a known run after timeout; never blindly start another. Report pending or failed status honestly.

After success, fetch untransformed pages of 20 dataset rows using explicit limit, offset and fields, at most 100 rows and 64 KiB serialized UTF-8 content admitted to model context. Enforce this byte budget host-side; if your client cannot intercept oversized responses, do not promise a hard byte ceiling. State returned count, continuation offset and partial/truncated status. Keep full exports outside model context. Client discovery and caching behavior varies; no token-savings guarantee is made.

### Legality, responsible use and non-affiliation

Process public previews only where you have the necessary rights and permission. Do not use this Actor to evade access restrictions, extract private drafts or remove watermarks. CapCut is a third-party mark used only to identify the supported source; this Actor is independently developed and is not affiliated with or endorsed by CapCut or ByteDance. Standard Apify terms apply; no additional custom end-user terms are imposed.

### Data handling and diagnostics

No AI models, paid external APIs, proxies or user credentials are used by the runtime. Input URLs are sent to CapCut to retrieve public state. Public creator names and profile links are included only as attribution; author biographies, recommendations and raw HTML are not exported. Run datasets, input and SUMMARY are stored in your Apify run storage under your account's retention and deletion settings; no cross-run cache or company archive is created. Delete runs/storage using your Apify controls when no longer needed.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed and reports are retained for 30 days. Output preview URLs may contain source-issued signatures; keep exports within your authorized workflow. Logs contain normalized source URLs and concise errors, not raw response bodies, author identities or authentication headers.

### FAQ

**Does this download edited projects or full-quality original videos?** No. It exports public template preview metadata and available links. Binary downloads and editing are downstream responsibilities.

**Can a public template lack a media link?** Yes. Its metadata row remains useful with `previewMediaUrl: null` and `mediaStatus: not_available`.

**Why are there fewer rows than URLs?** Input normalization, template-ID deduplication, dead links, the attempted-URL cap, timeout or charge budget can reduce output. Inspect SUMMARY.

**Where do I report a problem?** Open an issue on this Actor's Apify Store page with a safe input and run link. Never post private tokens or signed exports publicly.

### Related Actors

For different-source authorized preview/link workflows, see [Dailymotion Public Video Downloader](https://apify.com/automation-lab/dailymotion-public-video-downloader) and [Vimeo Video Downloader](https://apify.com/automation-lab/vimeo-video-downloader). These are alternatives for their own sources, not additional CapCut coverage.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/capcut-shared-video-downloader/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Supply 1–1000 HTTPS capcut.com /template-detail/<id> (optionally with a title slug) or /t/<code> URLs. Use {url} objects in the input editor. Tracking queries are stripped. No discovery or private projects; dead short links are reported in SUMMARY.

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

Global cap on distinct normalized supplied URLs attempted, in input order; default 100, range 1–1000, no zero/unlimited mode. Failed inputs consume this cap. Results additionally deduplicate by template ID, so output can be smaller. There is no pagination or discovery.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.capcut.com/template-detail/7518257722391825725"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Unique matching template records.

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

Attempted, saved, failed and budget-stop counts with failed input URLs.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.capcut.com/template-detail/7518257722391825725"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/capcut-shared-video-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 = {
    "startUrls": [{ "url": "https://www.capcut.com/template-detail/7518257722391825725" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/capcut-shared-video-downloader").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 '{
  "startUrls": [
    {
      "url": "https://www.capcut.com/template-detail/7518257722391825725"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/capcut-shared-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/capcut-shared-video-downloader"
        }
    }
}
```

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/GXcOuUbs4sLRkqBqn/builds/GwdwduzmNhOf9Qakt/openapi.json