# Erome Video Scraper (`datawatcher/erome-scraper`) Actor

Scrapes public video data from erome.com: creator, tags, views, likes, date, duration, thumbnail and the direct video file URLs. Or just the video page and file URLs.

- **URL**: https://apify.com/datawatcher/erome-scraper.md
- **Developed by:** [DataWatcher](https://apify.com/datawatcher) (community)
- **Categories:** Videos
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 video results

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

## Erome Video Scraper

Scrape **Erome albums** from erome.com by keyword search, creator profile or album URL, and get clean data as JSON, CSV or Excel, or through the **API**. **One row per media file (video or image) of an album**, and every video row has the direct link to the video file (`.mp4`). You also get the album title, the creator, views, likes, duration, poster and thumbnail. No login, no browser.

- Direct video links: `videoFileUrl` (`.mp4`, the site's HD file).
- Image files are rows with `mediaType` `image` and the full-size picture in `imageUrl`.
- Searches and profiles are read page by page until your `maxResults` or another cap in the input is reached.

The actor reads public data and returns the links to the files. The `.mp4` files of erome.com need the header `Referer: https://www.erome.com/` when you open or save them.

Want the files saved, named albumId_mediaId.ext, with that header handled? Use Erome Video Downloader (it charges per saved file).

### ⭐ Why this one

> **1️⃣ One schema across video sites.**
> All our video actors share one output schema and one input schema. Build your pipeline once: our other video actors ([Redgifs Video Scraper](https://apify.com/datawatcher/redgifs-scraper), [XFree Video Scraper](https://apify.com/datawatcher/xfree-scraper), [Erome Video Downloader](https://apify.com/datawatcher/erome-video-downloader), [RedGIFs Video Downloader](https://apify.com/datawatcher/redgifs-video-downloader), [XFree Video Downloader](https://apify.com/datawatcher/xfree-video-downloader)) take the same input and return the same fields, so adding a site means changing the actor name, not your code.

- **Low price, no start fee.** $1.00 per 1,000 videos; the median Erome scraper charges $2.00, and 4 of 5 add a start fee. You pay only for rows you get.
- **Every media file of the album.** One row per video or image, so a full album gives you all its files, in page order.
- **A direct video link on every video row.** `videoFileUrl` comes with the data, so you can play or save the file at no extra request.
- **Links-only mode.** Turn on `onlyVideoUrls` for rows with just the album page and the direct links: the fastest run, at the same price per row.
- **Honest runs.** A run summary with a list of failed inputs, and a health status (`ok`, `degraded` or `failed`) with the reason.
- **Creator data included.** Username and profile link on every row.

### 🔎 What it extracts

One row per unique media file. The page types it reads:

| Page type | Example URL | Input to use |
|---|---|---|
| Search | `https://www.erome.com/search?q=example+words` | `searchQueries` or `startUrls` |
| Profile | `https://www.erome.com/CreatorName` | `usernames` or `startUrls` |
| Album page | `https://www.erome.com/a/AlbumId1` | `videoUrls` or `startUrls` |

- Search filter: `all` (default) or `post`. A search finds albums by title.
- A search returns at most 50 pages, about 1,800 albums (a limit of the site).
- A search URL with `o=new` reads the newest albums first.
- A profile gives the posts and reposts of the creator.
- Views and likes are the numbers the site shows; the site rounds views (for example 25.5K).

### 🚀 How to scrape Erome videos

1. Open the actor on Apify and click **Try for free**.
2. Fill in a search, creators or album URLs, or paste erome.com URLs into `startUrls`.
3. Click **Start**.
4. Download the **Erome video data** as JSON, CSV or Excel from the Output tab, or fetch it with the Apify API.

Example inputs:

```json
{ "searchQueries": [{ "query": "example words", "filter": "all" }], "maxResults": 50 }
```

```json
{ "usernames": ["CreatorName"], "maxResults": 100 }
```

### 🤖 Use with AI agents (MCP)

AI assistants (Claude, ChatGPT, Cursor…) can run this actor through Apify's MCP server. Connect the server in your assistant, then ask, for example:

```text
Use the Erome Video Scraper to get the videos of the creator CreatorName with their direct .mp4 links.
```

### 🔌 Run it your way

- **Schedule it** with Apify schedules.
- **Call it from the Apify API** and its clients (Python, JavaScript).
- **Connect it** to Make, n8n, Zapier, webhooks or Google Sheets.
- **Ask an AI agent to run it**: see [Use with AI agents (MCP)](#-use-with-ai-agents-mcp).

### 🔀 Mixing inputs and duplicates

You can use the source inputs `startUrls`, `searchQueries`, `usernames` and `videoUrls` in one run.

| Rule | What happens |
|---|---|
| One row per media file | Matched by `id` over the whole run: a file found by a search and by its creator is written once. |
| First input kept | `sourceType` and `sourceUrl` keep the first input that found it. |
| Same input twice | Read once. |
| `maxResults` | One cap for the run, split fairly over the inputs still to read. |
| Input check | Every input is checked: valid ones run, others get a clear message. |

### 🎬 Direct video links

> **`videoFileUrl` is the direct link to the video file**, e.g. `https://v83.erome.com/1234/AlbumId1/MediaId1_720p.mp4`.
> Send the header `Referer: https://www.erome.com/` when you open or save it: without it the site answers 403.

- The links come with every row at no extra request.
- `url` is the album page on erome.com, shared by all rows of the album, not the file.
- Image rows have no video link: their `videoFileUrl` and `durationSeconds` are `null` and `imageUrl` holds the picture. Images open without the header.
- The site offers one video file per media, so `previewVideoUrl` is `null`.
- The site can change file links at any time: use the links soon after the run.

### ⚡ Links-only mode (`onlyVideoUrls`)

With `onlyVideoUrls` set to `true`, each row has only the album page and the direct link. It is the fastest run. The price per row is the same as for a full row.

### ⚙️ Input

| Input | Type | Default | Range | Meaning |
|---|---|---|---|---|
| `startUrls` | list of URLs | none | erome.com URLs | Search, profile or album URLs. The kind is found from the URL. |
| `searchQueries` | list | none | – | Items `{"query": "...", "filter": "all" \| "post"}`. A plain text line means `{"query": text, "filter": "all"}`. |
| `usernames` | list of text | none | – | Creator names, with or without `@`, or profile URLs. Every album of each creator. |
| `videoUrls` | list of URLs | none | – | Album page URLs. Every media file of the album. |
| `onlyVideoUrls` | yes/no | `false` | – | Rows are only `url`, `videoFileUrl`, `previewVideoUrl`. |
| `maxResults` | integer | `100` | 1 to 1,000 | Maximum rows returned over all inputs. The free Apify plan returns up to 1,000 results per run. |
| `maxRequests` | integer | `200` | 1 to 1,000 | Maximum requests of the run (list pages and albums). |
| `maxPagesPerSource` | integer | `100` | 1 to 100 | Maximum list pages for one search or profile. |
| `maxScrollsPerPage` | integer | `100` | 1 to 100 | Not used on this site (pages are numbered). |
| `maxRequestRetries` | integer | `2` | 0 to 5 | Retries after a network error or a server error. |
| `requestTimeoutSecs` | integer | `30` | 5 to 120 | Time limit of one request, in seconds. |

Use at least one of `startUrls`, `searchQueries`, `usernames` or `videoUrls`. The inputs `tags` and `tagSort` are shared by all our video actors and are not used here, because erome.com has no tags. When a cap ends the run, `stopReason` says which (see Run stats).

### 📦 Output: Erome video data

Every full row has all of these fields. A missing text, number or object is `null`. A missing list is `[]`.

| Field | Type | Meaning |
|---|---|---|
| `recordType`, `schemaVersion`, `source` | text | Always `video`; the output schema version; the site (`erome`). |
| `id` | text | The site's id of the media file. |
| `url` | text | The album page on erome.com (not the file). |
| `mediaType` | text | `video` or `image`. |
| `imageUrl` | text or null | Direct link to the full-size image when `mediaType` is `image`; empty for videos. |
| `sourceType` | text | `search`, `profile` or `direct_video`. |
| `sourceUrl` | text | The input that first found the file. |
| `title` | text or null | The album title. |
| `creator` | object or null | `username`, `displayName`, `profileUrl` of the creator of the album. |
| `taggedAccounts` | list | Always `[]`: the site has no tagged accounts. |
| `views` | integer or null | Views of the album, rounded by the site. |
| `likes` | integer or null | Likes of the album. |
| `durationSeconds` | number or null | Length of a video in seconds; `null` for images. |
| `width`, `height` | integer or null | Size in pixels (images). |
| `hasAudio` | yes/no or null | Always `null`: the site does not say. |
| `thumbnailUrl` | text or null | Small preview image URL. |
| `posterUrl` | text or null | Preview image URL of a video. |
| `tags` | list | Always `[]`: the site has no tags. |
| `videoFileUrl` | text or null | **Direct link to the video file** (`.mp4`). `null` for images. |
| `previewVideoUrl` | text or null | Always `null`: the site has one video file per media. |
| `dates` | object | `posted` (derived from the image upload time of the album; `null` for albums of videos only) and `scraped` (when the row was made), ISO 8601 UTC. |

#### Example: a full row

```json
{
  "recordType": "video",
  "schemaVersion": "4.4.0",
  "source": "erome",
  "id": "MediaId1",
  "url": "https://www.erome.com/a/AlbumId1",
  "mediaType": "video",
  "sourceType": "search",
  "sourceUrl": "https://www.erome.com/search?q=example+words",
  "title": "Example album",
  "creator": { "username": "CreatorName", "displayName": "CreatorName", "profileUrl": "https://www.erome.com/CreatorName" },
  "views": 25500,
  "likes": 69,
  "durationSeconds": 9,
  "thumbnailUrl": "https://s83.erome.com/1234/AlbumId1/MediaId1.jpg",
  "posterUrl": "https://s83.erome.com/1234/AlbumId1/MediaId1.jpg",
  "videoFileUrl": "https://v83.erome.com/1234/AlbumId1/MediaId1_720p.mp4",
  "dates": { "posted": "2025-10-24T06:51:38Z" }
}
```

### 📊 Run stats

Each run saves two records in the key-value store. `OUTPUT`:

| Key | Meaning |
|---|---|
| `status` | `success`, `partial` (some inputs failed, rows kept) or `failed`. |
| `sourcesProcessed` | Inputs read. |
| `listingPagesVisited` | List pages read. |
| `videoCardsFound` | Media files seen, before dedupe. |
| `uniqueVideosEmitted` | Rows written. |
| `duplicatesSkipped` | Files already written. |
| `mediaUrlsFound`, `mediaUrlsMissing` | Rows with / without a `videoFileUrl` (images count as missing). |
| `requestsUsed` | Requests made. |
| `stoppedEarly` | `true` when a cap ended the run. |
| `stopReason` | The cap: `maxResults`, `maxRequests`, `maxPagesPerSource` or `chargeLimit`; else `null`. |
| `sourceErrors` | List of inputs that failed, with the message. |
| `sources` | One entry per input: type, URL, status, pages, rows. |
| `chargedEvents` | How many times each billing event was charged. |

`RUN_HEALTH`: `{"status": "ok" | "degraded" | "failed", "reason": ...}`. `reason` says why a run is not `ok`.

### 💰 Pricing

Pay per event. There is no start fee. Free plan: each run returns up to 1,000 videos; upgrade your Apify plan for more.

| Event | Price | When it is charged |
|---|---|---|
| `video-scraped` | $0.0010 ($1.00 per 1,000) | Each unique media row written, with its direct link. Links-only rows too. |

- 1,000 rows, each with its direct link: $1.00.
- Duplicate rows are free. The links are included in the price.

### 🎯 Use cases

- Build a list of direct `.mp4` links for a keyword or creator and hand it to your own player or downloader.
- Track a creator's new albums on a schedule, with views and likes.
- List every video and image of an album with its title and creator.
- Research which albums get the most views and likes.
- Run the same pipeline over several video sites, since they share one schema.

### ❓ FAQ

#### How do I export Erome videos to Excel or CSV?

Run the actor, open the Output tab and pick Excel or CSV in the export options. JSON, XML and HTML are there too, and the Apify API returns the same data.

#### How do I get direct .mp4 links in my Erome video data?

Every video row has `videoFileUrl`. Turn on `onlyVideoUrls` for rows with only the links, the fastest run. Send the header `Referer: https://www.erome.com/` when you save the file, or use the downloader actor.

#### Can I get Erome data through an API?

Yes. Call the actor from the Apify API or its clients (Python, JavaScript), then read the rows from the run's dataset.

#### How much does it cost?

$1.00 per 1,000 rows with their direct links, no start fee. Duplicate rows are free.

#### Can I combine it with other video sites?

Yes. All our video actors share one output schema and one input schema, so rows from different sites fit one table. See the list below.

### Data notice

This actor returns only what the site shows publicly at run time. We don't store or keep that data and are not its controller — you decide how you use it.

### 🔗 Other video scrapers (same schema)

#### Erome (this site)

- [Erome Video Downloader](https://apify.com/datawatcher/erome-video-downloader): saves the video files (.mp4)

#### RedGIFs

- [Redgifs Video Scraper](https://apify.com/datawatcher/redgifs-scraper): links and data
- [RedGIFs Video Downloader](https://apify.com/datawatcher/redgifs-video-downloader): saves the video files (.mp4)

#### XFree

- [XFree Video Scraper](https://apify.com/datawatcher/xfree-scraper): links and data
- [XFree Video Downloader](https://apify.com/datawatcher/xfree-video-downloader): saves the video files (.mp4)

### 💬 Feedback and custom work

Need another portal, a field or a custom feed? Open an issue on the Issues tab.

# Changelog

This Actor's version history is a separate document: https://apify.com/datawatcher/erome-scraper/changelog.md

# Actor input Schema

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

Site URLs of any supported kind: search, account profile, tag or video page. The kind is found from the URL.

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

Searches, each {"query": "...", "filter": "all" | "post" | "tag"} (filter optional, default "all"). A plain text line is read as {"query": text, "filter": "all"}.

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

Account handles, with or without "@", or profile URLs. Every video of each account.

## `tags` (type: `array`):

Tag names exactly as the site writes them (case and prefixes kept, e.g. pl-Amatorzy), or tag page URLs.

## `tagSort` (type: `string`):

The order of tag pages. Empty - the site's default order.

## `videoUrls` (type: `array`):

Video page URLs. Each is read directly; one row per video.

## `onlyVideoUrls` (type: `boolean`):

Each row is only the three video links {"url", "videoFileUrl", "previewVideoUrl"}: the video page and its direct .mp4 files. Same price per video.

## `maxResults` (type: `integer`):

Maximum number of videos returned, in total. Shared fairly over the inputs (each search, profile, tag or video URL gets its part; what one cannot fill goes to the others). Free plan Apify users get at most 1000 videos per run, whatever is set here (paying users have no cap).

## `maxRequests` (type: `integer`):

Maximum number of page requests the run makes, in total (listing pages and load-more steps; a direct video URL is one request).

## `maxPagesPerSource` (type: `integer`):

Maximum number of listing pages read for one search, profile or tag.

## `maxScrollsPerPage` (type: `integer`):

Maximum number of "Show more" / load-more steps on one listing page.

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

Retries of a request that failed on a network error or a server error. A block (403, 429, a challenge page) is never retried.

## `requestTimeoutSecs` (type: `integer`):

Time limit of one page request.

## Actor input object example

```json
{
  "onlyVideoUrls": false,
  "maxResults": 100,
  "maxRequests": 200,
  "maxPagesPerSource": 100,
  "maxScrollsPerPage": 100,
  "maxRequestRetries": 2,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `results` (type: `string`):

One row per item.

## `runSummary` (type: `string`):

OUTPUT: status, sources, requests used, early stop and its reason, source errors, charged events.

## `runHealth` (type: `string`):

{status, reason}: ok, degraded, or failed.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("datawatcher/erome-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("datawatcher/erome-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 '{}' |
apify call datawatcher/erome-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datawatcher/erome-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/cvX4XQAOmK8LbvzUa/builds/9Y6X8mfgLtqQ0bT0Y/openapi.json