# Eporner Bulk Video Downloader (`serpxxx/eporner-bulk-video-downloader`) Actor

Bulk Eporner downloader for extracting public video metadata, direct media URLs, and optional Apify-hosted download links.

- **URL**: https://apify.com/serpxxx/eporner-bulk-video-downloader.md
- **Developed by:** [SERP XXX](https://apify.com/serpxxx) (community)
- **Categories:** Videos, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Eporner Bulk Video Downloader

Eporner Bulk Video Downloader

### Eporner Downloader for Direct Video Links and Metadata

This actor is built for bulk Eporner link extraction, video metadata collection, and optional per-video downloads. It turns public Eporner pages into clean dataset rows you can export, automate, schedule, or connect to downstream tools.

The default workflow focuses on extracting direct media links instead of downloading every file. That keeps runs lighter, faster, and cheaper. If you need Apify-hosted files, enable file downloads and the actor can store selected videos in Apify key-value storage and return clickable `storedFileUrl` links.

### Features

- Bulk process public Eporner video URLs
- Search Eporner and return matching public video results
- Extract video title, duration, thumbnails, and available media formats
- Resolve downloadable video formats where available
- Select preferred quality automatically or manually
- Return direct media URLs in structured Apify dataset rows
- Optional Apify-hosted file storage with per-video `storedFileUrl` links
- ZIP is guarded for small-file convenience only; individual file links are the primary download path
- Works through the Apify UI, API, schedules, webhooks, and integrations

### Benefits

- Save time compared with manually opening Eporner pages and copying media links
- Turn Eporner URLs and searches into structured rows for export or automation
- Keep default runs lightweight by extracting links instead of downloading large MP4 files
- Avoid the memory risk of huge ZIP archives by using per-video download links
- Store files in Apify only when you actually need hosted downloads
- Use one actor from no-code Apify runs or API-driven workflows

### Web Browser Extension Alternative

Need a simpler one-click downloader instead of a bulk Apify workflow? Use the Eporner web browser extension alternative for normal browser-based downloading.

👉 Get the browser extension alternative here: https://serp.ly/eporner-downloader

### Screenshots

Suggested screenshots for this lander:

- Apify input form with URL list, search query, and quality selector
- Dataset result showing title, thumbnail, selected format, and `directVideoUrl`
- Optional file-download result showing `storedFileUrl`
- Example CSV or JSON export from the Apify dataset

### Common Use Cases

- Extract direct downloadable Eporner video links from public video pages
- Build a structured dataset from a list of Eporner URLs
- Collect video metadata, thumbnails, durations, and format options
- Save selected public videos into Apify key-value storage for later download
- Feed Eporner media data into cataloging, research, moderation, or internal automation workflows
- Run repeatable Eporner searches through Apify schedules or API calls

### Output Fields

Each successful dataset item can include:

- `inputUrl`
- `sourceUrl`
- `canonicalUrl`
- `id`
- `title`
- `duration`
- `thumbnailUrl`
- `availableFormats`
- `selectedFormat`
- `directVideoUrl`
- `status`
- `errorMessage`
- `storedFileKey`, `storedFileUrl`, and `fileSizeBytes` when file downloads are enabled
- `zipFileKey`, `zipFileUrl`, `zipFileSizeBytes`, `zipEntryCount`, or `zipErrorMessage` when ZIP is requested and applicable

### Download Options

Default mode returns direct downloadable media links. This is the recommended workflow for Eporner because tube-site MP4 files can be large.

If `downloadFiles` is enabled, the actor attempts to store selected videos in Apify key-value storage and returns clickable `storedFileUrl` links. ZIP creation is not the main product promise for Eporner. Large files may skip ZIP safely and still return individual file links.

### FAQ

#### Can I download multiple Eporner videos at once?

Yes. Paste multiple Eporner video URLs or use search mode to process multiple results in one actor run.

#### Does this return direct video URLs?

Yes. The actor resolves available media formats and returns the selected direct media URL in `directVideoUrl` when available.

#### Why not focus on ZIP downloads?

Eporner videos can be hundreds of MB each. Per-video download links are safer, cheaper, and more reliable than promising large ZIP archives.

#### Can Apify host the downloaded files?

Yes. Enable `downloadFiles` to save selected videos into Apify key-value storage and receive clickable `storedFileUrl` links.

#### Is this affiliated with Eporner?

No. This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Eporner.

### How to Use

1. Open the bulk downloader here: https://serp.ly/eporner-bulk-video-downloader
2. Paste one or more public Eporner video URLs or enter a search query.
3. Choose your preferred quality and maximum number of results.
4. Run the actor.
5. Open the dataset results and use `directVideoUrl` for the source media link.
6. If file downloads are enabled, use `storedFileUrl` as the clickable Apify-hosted download link.

### Links

- Run it here: https://serp.ly/eporner-bulk-video-downloader
- Browser extension alternative: https://serp.ly/eporner-downloader

# Actor input Schema

## `urls` (type: `array`):

Eporner video URLs to process.
## `urlText` (type: `string`):

Optional textarea input with one Eporner video URL per line.
## `searchQuery` (type: `string`):

Optional Eporner public API search query.
## `maxItems` (type: `integer`):

Maximum number of discovered URLs to process.
## `downloadFiles` (type: `boolean`):

Download selected media into the default key-value store. Keep false for smoke tests.
## `createZip` (type: `boolean`):

When downloadFiles is true, create one ZIP in the default key-value store containing all successfully downloaded media files.
## `preferredQuality` (type: `string`):

Requested quality label, for example 720p. Use best for highest available.
## `useApifyProxy` (type: `boolean`):

Route page/media requests through Apify Proxy. Recommended for cloud runs.
## `proxyGroups` (type: `array`):

Optional Apify Proxy groups, for example RESIDENTIAL if enabled on the account.

## Actor input object example

```json
{
  "urlText": "https://www.eporner.com/embed/o2OiiRdukpB/\nhttps://www.eporner.com/embed/nrUXQe04V2L/",
  "maxItems": 2,
  "downloadFiles": false,
  "createZip": false,
  "preferredQuality": "best",
  "useApifyProxy": false
}
````

# 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 = {
    "urlText": `https://www.eporner.com/embed/o2OiiRdukpB/
https://www.eporner.com/embed/nrUXQe04V2L/`,
    "maxItems": 2,
    "downloadFiles": false,
    "createZip": false,
    "preferredQuality": "best",
    "useApifyProxy": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("serpxxx/eporner-bulk-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 = {
    "urlText": """https://www.eporner.com/embed/o2OiiRdukpB/
https://www.eporner.com/embed/nrUXQe04V2L/""",
    "maxItems": 2,
    "downloadFiles": False,
    "createZip": False,
    "preferredQuality": "best",
    "useApifyProxy": False,
}

# Run the Actor and wait for it to finish
run = client.actor("serpxxx/eporner-bulk-video-downloader").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urlText": "https://www.eporner.com/embed/o2OiiRdukpB/\\nhttps://www.eporner.com/embed/nrUXQe04V2L/",
  "maxItems": 2,
  "downloadFiles": false,
  "createZip": false,
  "preferredQuality": "best",
  "useApifyProxy": false
}' |
apify call serpxxx/eporner-bulk-video-downloader --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=serpxxx/eporner-bulk-video-downloader",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eporner Bulk Video Downloader",
        "description": "Bulk Eporner downloader for extracting public video metadata, direct media URLs, and optional Apify-hosted download links.",
        "version": "0.1",
        "x-build-id": "jO7HXH538Jvg8R1yE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpxxx~eporner-bulk-video-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpxxx-eporner-bulk-video-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/serpxxx~eporner-bulk-video-downloader/runs": {
            "post": {
                "operationId": "runs-sync-serpxxx-eporner-bulk-video-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/serpxxx~eporner-bulk-video-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-serpxxx-eporner-bulk-video-downloader",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "Video URLs",
                        "type": "array",
                        "description": "Eporner video URLs to process.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "urlText": {
                        "title": "Video URLs, one per line",
                        "type": "string",
                        "description": "Optional textarea input with one Eporner video URL per line."
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional Eporner public API search query."
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of discovered URLs to process.",
                        "default": 20
                    },
                    "downloadFiles": {
                        "title": "Download files",
                        "type": "boolean",
                        "description": "Download selected media into the default key-value store. Keep false for smoke tests.",
                        "default": false
                    },
                    "createZip": {
                        "title": "Create ZIP",
                        "type": "boolean",
                        "description": "When downloadFiles is true, create one ZIP in the default key-value store containing all successfully downloaded media files.",
                        "default": false
                    },
                    "preferredQuality": {
                        "title": "Preferred quality",
                        "type": "string",
                        "description": "Requested quality label, for example 720p. Use best for highest available.",
                        "default": "best"
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route page/media requests through Apify Proxy. Recommended for cloud runs.",
                        "default": false
                    },
                    "proxyGroups": {
                        "title": "Apify Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups, for example RESIDENTIAL if enabled on the account.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
