# Dailymotion Video Discovery by Topic & Channel (`dataspryva/dailymotion-video-discovery-by-topic-and-channel`) Actor

Search Dailymotion by keyword, browse trending or topic videos, or pull a channel's uploads, with language, country, and duration filters, views, likes, tags, and owner details per video.

- **URL**: https://apify.com/dataspryva/dailymotion-video-discovery-by-topic-and-channel.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Videos, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 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?

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

## Dailymotion Video Discovery by Topic & Channel

Dailymotion's catalog is organized into keyword search, trending feeds, 17 topic categories, channel pages and playlists. This actor reads whichever of those you point it at — plus specific video IDs and a channel/user keyword search — and returns one clean JSON record per video or channel, straight from Dailymotion's public API. No login, no API key, no proxy.

### What this actor does

- **Seven modes:** `search` videos by keyword, browse `trending`, walk a `byTopic` category, pull a `byUser` channel's uploads, read a `byPlaylist`, look up `byVideoIds`, or `searchUsers` for Dailymotion channels and creators.
- **Filters that match how the API really behaves:** language, country (search/trending), publish date range, tag, verified channels only, live streams only, and exact min/max duration.
- **More than 1,000 results per query:** setting `maxItems` above 1,000 makes the actor sweep Dailymotion's date windows automatically (newest-first or oldest-first), deduplicating as it goes — up to 10,000 records per run.
- **Engagement over time:** total views plus views in the last hour, day, week and month, so you can see velocity, not just the all-time number.
- **Full channel context per video:** owner ID, display name, profile URL, followers, following, total videos and playlists, country, language, join date, avatar, cover and verification.
- **Geo-blocking, hashtags and every thumbnail size** are returned when Dailymotion has them; fields the source doesn't carry are simply left out of that record.

### Output per video

| Field | Description |
|---|---|
| `videoId` | Dailymotion video ID. |
| `title` / `description` | Video title and description. |
| `ownerId` / `ownerUsername` / `ownerUrl` | Channel ID, display name and profile URL. |
| `ownerVideosTotal` / `ownerFollowers` / `ownerFollowing` / `ownerPlaylistsTotal` | Channel counters. |
| `ownerCountry` / `ownerLanguage` / `ownerCreatedAt` | Channel country, language and join date (ISO 8601). |
| `ownerVerified` / `ownerPartner` | Channel verification and partner status. |
| `ownerAvatarUrl` / `ownerAvatarUrlLarge` / `ownerCoverUrl` | Channel avatar (360/720 px) and cover image. |
| `views` | Total views. |
| `viewsLastHour` / `viewsLastDay` / `viewsLastWeek` / `viewsLastMonth` | Recent view counts (velocity). |
| `likes` / `bookmarks` | Like and bookmark counts. |
| `comments` | Comment count. Dailymotion no longer shows comments, so this is always 0 — kept for compatibility. |
| `duration` | Duration in seconds. |
| `publishedAt` / `updatedAt` / `uploadedAt` | Publish, last-update and upload timestamps (ISO 8601 UTC). |
| `thumbnailUrl` / `thumbnailUrlSmall` / `thumbnailUrlLarge` / `thumbnailUrlMax` | Thumbnails (default, 240 px, 720 px, 1080 px). |
| `firstFrameUrl` | 720 px first-frame image. |
| `videoUrl` / `tinyUrl` | Canonical video page and dai.ly short link. |
| `embedUrl` / `embedHtml` | Embeddable player URL and iframe snippet. |
| `allowEmbed` / `allowedInPlaylists` | Embedding and playlist permissions. |
| `width` / `height` / `aspectRatio` | Video dimensions and frame aspect ratio. |
| `availableFormats` | Available stream qualities, e.g. `sd`, `hq`, `hd720`, `hd1080`. |
| `tags` / `hashtags` | Searchable tags and uploader hashtags. |
| `channel` / `channelName` | Dailymotion category ID and label. |
| `language` / `country` | Video language and country codes. |
| `explicit` / `isCreatedForKids` | Content flags when set. |
| `mode` | `vod` for on-demand, `live` for livestreams. |
| `geoBlockingMode` / `geoBlockingCountries` | Geo-restriction mode (`allow`/`deny`) and the affected country codes. |
| `sourceUrl` | The search/topic/channel URL this record was found through, when the mode used one. |
| `recordType` | Always `"video"`. |
| `scrapedAt` | ISO 8601 timestamp of when the record was fetched. |

### Output per channel (mode = `searchUsers`)

| Field | Description |
|---|---|
| `channelId` | Dailymotion user/channel ID. |
| `username` / `screenname` | Handle and display name. |
| `description` | Channel bio, when present. |
| `verified` / `partner` | Verification and partner status. |
| `url` | Channel profile URL. |
| `followers` / `following` | Follower and following counts. |
| `videos` / `playlists` / `views` / `reposts` | Catalog and engagement totals. |
| `country` / `language` | Channel country and language. |
| `createdAt` | Join date (ISO 8601). |
| `avatarUrl` / `avatarUrlLarge` / `coverUrl` | Avatar (360/720 px) and cover image. |
| `sourceUrl` / `recordType` / `scrapedAt` | Provenance (`recordType` is `"channel"`) and fetch time. |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `search` | `search` / `trending` / `byTopic` / `byUser` / `byPlaylist` / `byVideoIds` / `searchUsers`. |
| `searchQueries` | array | – | One or more keywords (mode=search, searchUsers). The daily test uses `["technology news"]`. |
| `usernames` | array | `[]` | Channel usernames, profile URLs or IDs (mode=byUser). Multiple allowed. |
| `topic` | string (select) | `news` | One of Dailymotion's 17 categories (mode=byTopic). |
| `playlists` | array | `[]` | Playlist URLs or IDs (mode=byPlaylist). Multiple allowed. |
| `videoIds` | array | `[]` | Video IDs or URLs (mode=byVideoIds). |
| `sortBy` | string (select) | `relevance` | Result order; see the Sort section below. |
| `language` | string (select) | `""` (all) | Only videos in this language. |
| `country` | string (select) | `""` (all) | Only videos from this country (mode=search, trending). |
| `verifiedOnly` | boolean | `false` | Only videos from verified channels (mode=search, trending). |
| `liveOnly` | boolean | `false` | Only live streams. |
| `tag` | string | – | Only videos carrying this tag (mode=search, byTopic, byUser, byPlaylist). |
| `createdAfter` / `createdBefore` | string | – | Publish date window, `YYYY-MM-DD` (mode=search, trending, byTopic, byUser). Long ranges are fetched automatically in overlapping windows. |
| `minDuration` / `maxDuration` | integer | – | Only videos within this duration range, in seconds. |
| `maxItems` | integer | `20` | Maximum records to return (1–10,000). Values above 1,000 use automatic date-window partitioning in search/topic/channel modes. |

#### Sort order values

| Value | Works in | Notes |
|---|---|---|
| `relevance` | search, searchUsers | Default for search. |
| `recent` | every video mode | Newest first. |
| `trending` | every video mode | Dailymotion's trending order. |
| `visited` / `visited-hour` / `visited-today` / `visited-week` / `visited-month` | every video mode | Most-viewed windows. |
| `random` | every video mode | Random sample. |
| `old` / `id-asc` | search, byTopic, byUser, byPlaylist | Oldest first. |
| `popular` | searchUsers | Most-followed channels. |

Picking a value a mode can't honor (e.g. `relevance` in `trending`) falls back to that mode's default order, and the run's status message tells you it did. Runs with `maxItems` above 1,000 always use a `recent` or `old` time-ordered sweep (the status message says so); `byVideoIds` keeps your input order.

#### Example: keyword search

```json
{
    "mode": "search",
    "searchQueries": ["electric cars", "solar power"],
    "sortBy": "visited-week",
    "language": "en",
    "maxItems": 100
}
```

#### Example: a large channel sweep (more than 1,000 videos)

```json
{
    "mode": "byUser",
    "usernames": ["euronews-en"],
    "sortBy": "recent",
    "maxItems": 8000
}
```

The actor walks the channel's history in automatically-sized date windows and removes overlaps, so the dataset contains 8,000 distinct videos (or every video the channel has, whichever comes first).

#### Example: a channel's uploads, by profile URL

```json
{
    "mode": "byUser",
    "username": "https://www.dailymotion.com/user/euronews-en",
    "createdAfter": "2026-01-01",
    "maxItems": 200
}
```

#### Example: a playlist

```json
{
    "mode": "byPlaylist",
    "playlist": "https://www.dailymotion.com/playlist/x6pu6c",
    "maxItems": 50
}
```

#### Example: specific videos by ID

```json
{
    "mode": "byVideoIds",
    "videoIds": ["x4d4447", "https://www.dailymotion.com/video/x3gmshg"],
    "maxItems": 10
}
```

#### Example: channels and creators by keyword

```json
{
    "mode": "searchUsers",
    "searchQueries": ["space news"],
    "sortBy": "popular",
    "maxItems": 30
}
```

### Use cases

- **Channel monitoring** — track a publisher's new uploads and their first-day view velocity.
- **Topic and trend research** — compare the most-viewed videos across categories and languages.
- **Competitive benchmarking** — collect follower, catalog and engagement counts for a set of channels.
- **Media analysis** — build duration-bucketed datasets of short clips vs long-form content.
- **Archival and licensing research** — map playlists, creators and geo-restrictions across a catalog.
- **Dashboards and alerting** — feed fresh upload metadata into BI tools on a schedule.

### FAQ

**Do I need a Dailymotion account or API key — and will this keep working when Dailymotion moves to API v2?**
No account or key is needed: the actor reads Dailymotion's public read API without credentials, cookies or proxy setup. That API is still documented and supported (no sunset announced as of 2026-10). API v2 targets authenticated publisher workflows and requires private API keys, so a credential-free actor cannot use it; if Dailymotion ever announces a sunset for the public read API, this actor will need a rework. Current behaviour is tracked in the project research notes.

**How many records can one run return?**
Up to 10,000 per run. Dailymotion's API itself returns at most 1,000 results per query, so the actor fetches more by sweeping the query's date range in overlapping windows (newest-first or oldest-first) and removing overlaps — the run's status message tells you how many windows were used. `byPlaylist` and `searchUsers` modes stay at 1,000 per query, because the playlist and user-search endpoints don't accept date filters. The date filters are applied by Dailymotion in roughly five-minute buckets, so at a day boundary a window can include up to five minutes of neighbouring content; the actor never fabricates or drops records because of it and reports what the source returned.

**Which modes, filters and sort orders does Dailymotion's API actually support?**
Playlist search by keyword is not available — the public API supports keyword search only for videos and channels/users (the actor reads playlists by URL or ID, `mode=byPlaylist`). The country filter is accepted only together with a keyword search or the trending order; elsewhere it is ignored and the run's status message says so. Likewise, the `old`/`id-asc` orders are rejected for the plain trending feed and for keyword searches outside a mode that supports them — the actor falls back to the mode's default order and notes it in the status message.

**Why do some videos have no `tags`, `description`, `firstFrameUrl`, or channel no `ownerCoverUrl`?**
Dailymotion only stores those fields for some uploads, and those artifacts genuinely don't exist for every video or channel — the player metadata returns empty first-frame sets for the same videos, and channels without a cover get a generated gradient on the site. When a field is missing from the source it is left out of the record entirely: records never contain empty placeholders and nothing is faked.

**Why is `comments` always 0?**
Dailymotion removed public comments from its platform; the API reports 0 for every video and the comments endpoint returns an empty list (re-verified 2026-10-17 across 300 videos). The field is kept so existing integrations don't break.

**What do the `viewsLastHour` / `viewsLastDay` / `viewsLastWeek` / `viewsLastMonth` fields mean — and are the numbers accurate?**
They are Dailymotion's own rolling view counters for the 60 minutes / 24 hours / 7 days / 30 days before the request, and the actor reads the video's metrics from the same API the video page uses. They usually nest inside each other, but because Dailymotion updates the total and window counters independently, a window counter can occasionally exceed `views` by a count or two; the actor reports the API's numbers as-is rather than correcting them.

**Can I download videos or get direct stream URLs?**
No. This actor is for discovery and analytics: it returns metadata, thumbnails and embed links, not media files. Stream/download URLs require authenticated publisher access that Dailymotion doesn't grant to public integrations.

**What topics can I browse?**
All 17 built-in categories: News, Sports, Music, Tech, Animals, Cars, Celeb, Comedy & Entertainment, Creative, Education, Gaming, Kids, Lifestyle & How-to, Movies, Travel, TV and Webcam.

**Are private or unlisted videos included?**
No — only publicly accessible videos are returned. Unavailable IDs passed to `byVideoIds` are skipped, and the run status reports how many could not be accessed.

**Is this affiliated with Dailymotion?**
No. This actor is an independent tool that reads Dailymotion's public API and is not affiliated with or endorsed by Dailymotion.

# Actor input Schema

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

What to fetch from Dailymotion.

## `searchQueries` (type: `array`):

One or more keywords to search (mode=search, mode=searchUsers). Each query is paginated up to Max items. Existing tasks with the old `searchQuery` field keep working.

## `topic` (type: `string`):

Dailymotion category to browse (mode=byTopic).

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

Specific videos to look up (mode=byVideoIds). Accepts bare IDs (`x4d4447`), dailymotion.com/video/... links, or dai.ly links. Unavailable IDs are skipped.

## `sortBy` (type: `string`):

Result order. Values apply where the Dailymotion API supports them: `relevance` needs mode=search/searchUsers; `popular` is mode=searchUsers only; `old`/`id-asc` are not available in trending mode. Unsupported values fall back to the mode's default order and the run note says so. Runs with maxItems above 1,000 always use a recent/old time-ordered sweep.

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

Only include videos in this language. Leave as All languages for every language.

## `country` (type: `string`):

Only include videos published from this country (mode=search, trending). Leave as All countries for every country.

## `verifiedOnly` (type: `boolean`):

Only include videos from verified Dailymotion channels (mode=search, trending).

## `liveOnly` (type: `boolean`):

Only include live streams instead of on-demand videos.

## `tag` (type: `string`):

Only include videos carrying this tag (mode=search, byTopic, byUser, byPlaylist). Example: `jazz`.

## `createdAfter` (type: `string`):

Only include videos published on or after this date, as `YYYY-MM-DD` (mode=search, trending, byTopic, byUser). Long ranges are fetched automatically in overlapping windows. Dailymotion applies date filters in ~5-minute buckets, so a day boundary can include up to five minutes of neighbouring content.

## `createdBefore` (type: `string`):

Only include videos published on or before this date, as `YYYY-MM-DD` (mode=search, trending, byTopic, byUser). Long ranges are fetched automatically in overlapping windows. Dailymotion applies date filters in ~5-minute buckets, so a day boundary can include up to five minutes of neighbouring content.

## `minDuration` (type: `integer`):

Only include videos at least this many seconds long.

## `maxDuration` (type: `integer`):

Only include videos at most this many seconds long.

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

Maximum number of records to return. Up to 1,000 comes from a single query; higher values automatically sweep Dailymotion's date windows (search/topic/channel modes, newest-first or oldest-first order). Playlist and channel-search modes stay capped at 1,000 per query.

## `usernames` (type: `array`):

One or more Dailymotion channels to fetch uploads from (mode=byUser). Accepts usernames (`euronews-en`), profile URLs (`https://www.dailymotion.com/user/euronews-en`), or profile IDs. Existing tasks with the old `username` field keep working.

## `playlists` (type: `array`):

One or more playlists to fetch (mode=byPlaylist). Accepts playlist URLs (`https://www.dailymotion.com/playlist/x6pu6c`) or bare playlist IDs. Existing tasks with the old `playlist` field keep working.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "technology news"
  ],
  "topic": "news",
  "videoIds": [],
  "sortBy": "relevance",
  "language": "",
  "country": "",
  "verifiedOnly": false,
  "liveOnly": false,
  "maxItems": 3,
  "usernames": [],
  "playlists": []
}
```

# Actor output Schema

## `videos` (type: `string`):

Dataset containing all scraped Dailymotion video records (and channel records for mode=searchUsers).

# 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",
    "searchQueries": [
        "technology news"
    ],
    "videoIds": [],
    "sortBy": "relevance",
    "verifiedOnly": false,
    "liveOnly": false,
    "maxItems": 3,
    "usernames": [],
    "playlists": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/dailymotion-video-discovery-by-topic-and-channel").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",
    "searchQueries": ["technology news"],
    "videoIds": [],
    "sortBy": "relevance",
    "verifiedOnly": False,
    "liveOnly": False,
    "maxItems": 3,
    "usernames": [],
    "playlists": [],
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/dailymotion-video-discovery-by-topic-and-channel").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",
  "searchQueries": [
    "technology news"
  ],
  "videoIds": [],
  "sortBy": "relevance",
  "verifiedOnly": false,
  "liveOnly": false,
  "maxItems": 3,
  "usernames": [],
  "playlists": []
}' |
apify call dataspryva/dailymotion-video-discovery-by-topic-and-channel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/dailymotion-video-discovery-by-topic-and-channel"
        }
    }
}
```

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/XGXbbohKOjk6aa6HB/builds/KvXY5wmZ1cYMdDI41/openapi.json