# Dailymotion Public Video Downloader (`automation-lab/dailymotion-public-video-downloader`) Actor

Resolve public Dailymotion video URLs or IDs into normalized metadata, advertised stream qualities, thumbnails, and currently exposed signed HLS media manifests.

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

## Pricing

from $1.44 / 1,000 dailymotion video resolveds

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

## Dailymotion Public Video Downloader

Resolve public **Dailymotion videos** into normalized metadata, advertised stream qualities, and currently exposed signed HLS media manifest URLs.
This Dailymotion video downloader accepts exact video URLs or IDs and creates typed records for authorized archiving, inventory, and downstream media workflows.

No Dailymotion account, cookies, browser, proxy, or user API key is required.
Private, password-protected, deleted, login-only, and videos without an anonymously exposed HLS manifest are outside scope.

### What can the Dailymotion Public Video Downloader do?

- Process exact `dailymotion.com/video/...` URLs.
- Process short `dai.ly/...` URLs.
- Accept compact Dailymotion video IDs such as `x84sh87`.
- Combine URLs and IDs in one run.
- Deduplicate repeated video IDs before charging.
- Export title, owner, duration, timestamps, language, country, channel, and tags.
- Export the largest exposed thumbnail URL.
- Export advertised stream heights and format names.
- Export the current signed HLS media manifest URL.
- Report Dailymotion's protected-delivery flag without bypassing it.
- Continue after an individual invalid or unavailable input.
- Process up to 100 unique supplied videos per run.

This is a supplied-video resolver.
It does not search Dailymotion, crawl channels, copy HLS segments, decrypt streams, or bypass access controls.

### Who is this Actor for?

**Creators and rights holders** can inventory public Dailymotion videos they are authorized to archive.

**Editorial and production teams** can turn approved source URLs into a consistent spreadsheet or database feed.

**Researchers and journalists** can preserve source metadata and retrieval timestamps for reviewed public videos.

**Data engineers** can resolve a bounded batch of URLs or IDs before sending manifests to an authorized media pipeline.

**Records teams** can schedule repeat snapshots and detect when a public video or manifest is no longer exposed.

### Why use this Dailymotion video downloader?

A copied URL alone does not provide structured source provenance.
This Actor keeps the canonical video ID, owner, timestamps, qualities, manifest, status, and retrieval time in one record.

The implementation calls Dailymotion's public player metadata surface directly.
It avoids browser rendering and automatic paid proxy traffic, which keeps fixed runtime and platform usage small.

Unlike a generic page scraper, the output schema is designed specifically for Dailymotion media inventory.
Failed and duplicate inputs do not receive the per-item event charge.

### Supported Dailymotion inputs

Supported forms include:

```text
https://www.dailymotion.com/video/x84sh87
https://www.dailymotion.com/video/x84sh87_optional-slug
https://dai.ly/x84sh87
x84sh87
```

The video must remain anonymously available and expose an HLS manifest in public player metadata.
The Actor normalizes every successful input to:

```text
https://www.dailymotion.com/video/<video-id>
```

URLs from other domains and malformed IDs are rejected with a bounded failure row.

### Extracted Dailymotion video data

| Field | Meaning |
| --- | --- |
| `videoId` | Canonical Dailymotion video ID |
| `title` | Public video title |
| `ownerName` | Public owner display name |
| `ownerUsername` | Public owner username |
| `ownerUrl` | Public owner profile URL |
| `durationSeconds` | Video duration in seconds |
| `createdAt` | Video creation timestamp |
| `language` | Reported language code |
| `country` | Reported country code |
| `channel` | Dailymotion channel classification |
| `tags` | Public source tags |
| `thumbnailUrl` | Largest currently exposed thumbnail |
| `availableQualities` | Advertised stream-height labels |
| `streamFormats` | Height-to-format map |
| `manifestUrl` | Current signed HLS manifest URL |
| `manifestContentType` | Reported manifest content type |
| `protectedDelivery` | Dailymotion delivery-protection flag |
| `sourceUrl` | Canonical source page |
| `retrievalStatus` | `resolved` or `failed` |
| `error` | Per-input failure reason, otherwise `null` |
| `retrievedAt` | ISO 8601 retrieval timestamp |

Missing upstream values are returned as `null` or empty collections and are never guessed.

### How to resolve public Dailymotion videos

1. Confirm each video opens anonymously and that you may process it.
2. Copy its full Dailymotion URL or compact video ID.
3. Open this Actor in Apify Console.
4. Add URLs under **Dailymotion video URLs**, IDs under **Dailymotion video IDs**, or both.
5. Set **Maximum videos** to a safe batch size.
6. Keep the default bounded retry count unless the source is temporarily unstable.
7. Click **Start**.
8. Open the default dataset to inspect resolved and failed records.
9. Export JSON, CSV, Excel, XML, or RSS through Apify dataset tools.

The prefilled URL is Dailymotion's real public demo video and is suitable for a first run.
Public source availability can still change.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | array | empty | Exact public `dailymotion.com` or `dai.ly` video URLs |
| `videoIds` | string array | empty | Compact Dailymotion IDs; combined with URLs |
| `maxItems` | integer | `10` | Maximum unique videos processed, from 1 to 100 |
| `maxRequestRetries` | integer | `2` | Retries for transient network, HTTP 429, and HTTP 5xx failures |

At least one URL or ID is required.
Invalid filters fail closed instead of silently changing scope.

Example URL input:

```json
{
  "startUrls": [
    { "url": "https://www.dailymotion.com/video/x84sh87" }
  ],
  "maxItems": 1,
  "maxRequestRetries": 2
}
```

Example ID batch:

```json
{
  "videoIds": ["x84sh87", "x84sh85", "x8nphw7"],
  "maxItems": 3
}
```

### Output example

This abbreviated record reflects Dailymotion's public demo video:

```json
{
  "videoId": "x84sh87",
  "title": "Dailymotion demo video",
  "ownerName": "Dailymotion",
  "ownerUsername": "dm-support-policy",
  "durationSeconds": 25,
  "createdAt": "2021-10-11T15:48:50.000Z",
  "language": "en",
  "country": "FR",
  "channel": "creation",
  "tags": [],
  "availableQualities": ["380", "480", "720", "1080"],
  "streamFormats": {
    "380": "mpegts",
    "480": "mpegts",
    "720": "mpegts",
    "1080": "mpegts"
  },
  "manifestUrl": "https://cdndirector.dailymotion.com/cdn/manifest/video/x84sh87.m3u8?...",
  "manifestContentType": "application/x-mpegURL",
  "protectedDelivery": false,
  "sourceUrl": "https://www.dailymotion.com/video/x84sh87",
  "retrievalStatus": "resolved",
  "error": null,
  "retrievedAt": "2026-08-23T20:10:00.000Z"
}
```

Signed query parameters are shortened in this documentation only.
Actual dataset records contain the complete URL returned for that run.

### How much does it cost to resolve Dailymotion videos?

The Actor uses pay-per-event pricing: one **$0.005** start event per run and one `item` event per successfully resolved public video.
Failed and duplicate inputs have no item charge.

Current per-item tiers are:

| Tier | Successful video record |
| --- | ---: |
| FREE | $0.0027508 |
| BRONZE | $0.002392 |
| SILVER | $0.0018658 |
| GOLD | $0.0014352 |
| PLATINUM | $0.0009568 |
| DIAMOND | $0.00066976 |

At BRONZE, one successful record is about **$0.007392**, 10 are about **$0.02892**, and 100 are about **$0.2442**.
Normal Apify platform usage can add a small amount based on runtime and storage.

### Signed manifest URLs and media delivery

`manifestUrl` is a signed, time-sensitive source URL, not durable file storage.
Resolve it close to the time an authorized downstream system will use it.

Dailymotion can enforce geography, rights, expiry, referrer, delivery, or other controls at request time.
A metadata resolution does not guarantee that every client or region can fetch every media segment.
The Actor does not copy segments, remove signatures, decrypt content, or bypass those controls.

### Batch and scheduled archive workflows

Save a reviewed batch as an Apify Task and schedule it for recurring metadata snapshots.
Use `videoId` as the stable key in your destination.
Compare `retrievalStatus`, title, qualities, and manifest availability between runs.

A later failed status can indicate removal, privacy changes, delivery changes, or a temporary source failure.
The Actor records the observation but does not infer its legal or editorial meaning.

The Actor does not discover newly uploaded channel videos or compare historical runs automatically.
Perform comparison in your database, spreadsheet, or workflow tool.

### Spreadsheet and data-pipeline integrations

Send dataset records to:

- Google Sheets, Airtable, or Notion for a reviewed media inventory;
- Amazon S3, Google Cloud Storage, or Azure for an authorized archive workflow;
- a webhook for transcription, cataloging, or editorial review;
- a database keyed by `videoId`;
- Make, Zapier, or n8n for scheduled downstream automation.

Use the dataset API when a destination needs JSON.
Use Apify exports for CSV, Excel, XML, or RSS.

### Run with the Apify API

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~dailymotion-public-video-downloader/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"videoIds":["x84sh87"],"maxItems":1}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/dailymotion-public-video-downloader').call({
  videoIds: ['x84sh87', 'x84sh85'],
  maxItems: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/dailymotion-public-video-downloader").call(run_input={
    "startUrls": [{"url": "https://www.dailymotion.com/video/x84sh87"}],
    "maxItems": 1,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Keep API tokens in environment variables or an approved secret manager.

### Use with Apify MCP

Add the Actor to Claude Code:

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

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code clients can use this HTTP MCP configuration:

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

Example prompts:

- "Resolve these approved Dailymotion video IDs and return title, owner, and manifest URL."
- "Create a CSV-ready inventory for these public Dailymotion URLs."
- "Check which reviewed Dailymotion videos still expose an HLS manifest."

### Reliability and retries

The Actor retries only temporary network failures, rate limits, and Dailymotion server errors.
Malformed URLs, unsupported domains, deleted videos, private videos, and missing manifests are deterministic failures and are not retried blindly.

A failed input produces a typed, uncharged row so batch consumers retain source-level evidence.
If every unique input fails, the run exits with a failure status rather than reporting false success.

Keep batches bounded and rerun only after checking the error field and logs.
No residential proxy fallback is enabled.

### Limitations

- Input is limited to supplied video URLs and IDs; there is no search or channel crawl.
- A signed HLS manifest can expire quickly.
- Metadata fields can be absent or changed by Dailymotion.
- Geography and content rights can affect downstream media retrieval.
- The Actor does not save video bytes or HLS segments.
- The Actor does not support private, password-protected, deleted, or login-only videos.
- The Actor does not bypass DRM, protected delivery, CAPTCHA, or access controls.
- Up to 100 unique videos are processed per run.

### Responsible and legal use

Use this Actor only for videos and workflows you are authorized to process.
Public availability does not automatically grant copyright, redistribution, privacy, or reuse rights.

Follow Dailymotion's terms, applicable law, contractual obligations, and source-specific restrictions.
Do not use the Actor to evade access controls or distribute content without permission.
The user is responsible for downstream handling, retention, and sharing.

### FAQ and troubleshooting

#### The run says no videos resolved

Check that at least one input opens anonymously, uses a supported Dailymotion URL or ID, and still exposes a public HLS manifest.
Read each failure row and the run log before retrying.

#### A manifest URL no longer works

Run the Actor again to resolve a fresh signed URL.
If it still fails, geography, rights, expiry, or delivery controls may prevent retrieval from that client.

#### A duplicate URL is missing from output

Duplicates are collapsed by canonical `videoId` within a run.
This prevents duplicate records and duplicate item charges.

#### Why is a field null?

Dailymotion did not expose that value in public player metadata for the video.
The Actor does not infer missing source data.

### Related Automation Lab Actors

- [Vimeo Public Video Downloader](https://apify.com/automation-lab/vimeo-public-video-downloader) for authorized anonymously playable Vimeo MP4 archives.
- [Twitch Public Video Downloader](https://apify.com/automation-lab/twitch-public-video-downloader) for public Twitch clips and VOD workflows.
- [Reddit Public Video Downloader](https://apify.com/automation-lab/reddit-public-video-downloader) for public Reddit post media archives.

Choose this Actor when the source is Dailymotion and the required product is normalized metadata plus the currently exposed HLS manifest.

# Actor input Schema

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

HTTPS dailymotion.com/video/... or dai.ly/... URLs. Private, password-protected, deleted, and login-only videos are rejected.

## `videoIds` (type: `array`):

Video IDs such as x84sh87. IDs and URLs are combined and deduplicated.

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

Maximum number of unique public Dailymotion videos to resolve.

## `maxRequestRetries` (type: `integer`):

Retries for temporary rate limits, server errors, and network failures. Invalid or unavailable videos are not retried blindly.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.dailymotion.com/video/x84sh87"
    }
  ],
  "videoIds": [],
  "maxItems": 10,
  "maxRequestRetries": 2
}
```

# Actor output Schema

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

Resolved records and bounded failure rows in the default dataset.

# 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.dailymotion.com/video/x84sh87"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dailymotion-public-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.dailymotion.com/video/x84sh87" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dailymotion-public-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.dailymotion.com/video/x84sh87"
    }
  ]
}' |
apify call automation-lab/dailymotion-public-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/dailymotion-public-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/kDtC6orSlfxn7r9jQ/builds/9fOJkablm9nNACeVA/openapi.json