# 123movies Downloader (`serpdownloaders/123movies-downloader`) Actor

Browser extension for capturing 123movies mirror streams as local MP4 files with in-browser processing, retries, and offline playback support.

- **URL**: https://apify.com/serpdownloaders/123movies-downloader.md
- **Developed by:** [SERP Downloaders](https://apify.com/serpdownloaders) (community)
- **Categories:** Videos, Automation, Social media
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## 123Movies Downloader  (Browser Extension)

> Browser extension that detects and saves videos from 123Movies and all its mirror sites as standard MP4 files — directly in your browser, no extra software required.

SERP 123Movies Downloader is the only browser extension built specifically for saving videos from 123Movies and every one of its mirror sites. 

- Save movies and shows from any 123Movies mirror for offline viewing on flights, commutes, or anywhere without internet
- Never worry about disappearing mirrors — download and keep your own local copy before the domain goes offline
- Skip the technical hassle — no command-line tools, no desktop software, no manual configuration
- Works on every 123Movies domain variant automatically, including new mirrors as they appear

![123Movies Downloader extension](https://imagedelivery.net/lnCkkCGRx34u0qGwzZrUBQ/99229979-5d3f-4f6f-9e7b-9a6b73775c00/public)

If you have ever tried to download 123Movies videos and hit a wall because the stream would not save, this tool handles it.

### Preview

![123Movies Downloader workflow preview](assets/workflow-preview.webp)

### Links

- :rocket: Get it here: [123Movies Downloader](https://serp.ly/123movies-downloader)
- :new: Latest release: [GitHub Releases](https://github.com/serpapps/123movies-downloader/releases/latest)
- :question: Help center: [SERP Help](https://help.serp.co/en/)
- :beetle: Report bugs: [GitHub Issues](https://github.com/serpapps/123movies-downloader/issues)
- :bulb: Request features: [Feature Requests](https://github.com/serpapps/123movies-downloader/discussions)

### Why 123Movies Downloader

123Movies sites deliver video through streaming protocols that cannot be saved with a right-click or a simple "Save As." That alone stops most people. But the bigger problem is that 123Movies mirror domains rotate and change constantly, which means a generic downloader that worked yesterday might not recognize the site today. SERP 123Movies Downloader is purpose-built to solve both issues: it automatically identifies every 123Movies domain variant and mirror, detects the video stream as soon as playback starts, and converts it to a downloadable MP4 — all without any command-line tools, desktop software, or technical setup.

Generic downloaders typically fail on 123Movies because they cannot find or process the streaming format these sites use. This extension was designed from the ground up to handle that specific behavior, so detection and conversion happen reliably in your browser every time.

### Features

- **Auto stream detection** — Finds the video stream the moment you press play on any 123Movies mirror site
- **In-browser MP4 conversion** — Converts streaming video to standard MP4 files entirely in your browser, no external tools needed
- **Quality selector** — Pick from available resolutions (720p, 480p, 360p) or default to the best option
- **Built-in download manager** — Real-time progress bar so you always know where your download stands
- **Full mirror coverage** — Works across all 123Movies domains and mirror variants automatically, no manual configuration
- **Dark-themed UI** — Clean popup interface that fits right into the browsing experience
- **Auto-update notifications** — Get notified when new versions are released
- **3 free trial downloads** — No credit card required to get started

### How It Works

1. **Add the extension** — Install SERP 123Movies Downloader from your browser's extension store, or download the latest version from [GitHub Releases](https://github.com/serpapps/123movies-downloader/releases/latest) and load it manually
2. **Visit any 123Movies site** — Navigate to any 123Movies mirror and start playing the video you want to save
3. **Wait for detection** — The extension icon highlights in your toolbar the moment a downloadable video is found
4. **Choose quality and save** — Click the icon, select your preferred resolution from the dropdown, and hit Download to save the video as MP4

### Supported Formats

All downloads are saved as standard **MP4** files that play on any device or media player. Available quality depends on the source — most 123Movies mirrors offer 720p, 480p, and 360p options. The extension selects the best available quality by default, or you can pick manually.

### Step-by-Step Tutorial: How to Download Videos from 123Movies

Downloading from 123Movies is tricky because these sites use streaming protocols that prevent normal saving, and the mirror domains keep changing. SERP 123Movies Downloader solves both problems. Here is how to use it from start to finish.

**What you need:** A supported browser — Chrome, Edge, Brave, Firefox, or Opera — and an internet connection.

**Step 1 — Install the extension.** Open your browser's extension store, search for "Downloader for 123Movies," and click Add to Browser. Alternatively, download the latest release from [GitHub](https://github.com/serpapps/123movies-downloader/releases/latest) and load it manually in your browser's extension settings. The extension icon will appear in your toolbar once the install completes.

**Step 2 — Sign in.** Click the extension icon and enter your email address. You will receive a one-time verification code in your inbox. Enter that code to activate your 3 free trial downloads.

**Step 3 — Find your video.** Navigate to any 123Movies site — it does not matter which mirror or domain variant you use, the extension recognizes them all. Start playing the video you want to save. This is how you download 123Movies to MP4: the extension needs playback to begin before it can find the stream.

**Step 4 — Download.** Once the video is playing, click the extension icon in your toolbar (it highlights when a video is detected). Select your preferred quality from the dropdown and press Download. The file saves directly to your default Downloads folder as an MP4.

**Tips:** This 123Movies downloader Chrome extension works on every mirror automatically, so you never have to worry about which domain is current. Use the built-in download manager to track progress in real time. If you want to save movies from 123Movies browser without taking up too much storage, pick a lower resolution like 480p.

**Troubleshooting:** Video not detected? Make sure you pressed play first. Still not working? Refresh the page and try again. If the problem continues, check that the extension is enabled in your browser's extension settings.

### Who It's For

- **Casual viewers on 123Movies mirror sites** who want a simple, one-click way to save videos for offline viewing — no technical skills or extra software required
- **Travelers and commuters** who want to download movies or shows ahead of time so they have something to watch on a flight, train, or anywhere without a reliable internet connection
- **Users tired of disappearing mirrors** who want to archive content locally before the current domain goes offline
- **Non-technical users** who do not want to deal with command-line tools, desktop software, or complicated setup processes
- **Anyone who has tried generic downloaders** that could not detect or save videos from 123Movies sites and needs a tool that actually works

### Common Use Cases

- Save a movie or show from 123Movies for offline viewing on a flight, train, or road trip where you will not have internet access
- Archive content from a 123Movies mirror that might go offline tomorrow — keep your own local copy before the domain disappears
- Download videos from any 123Movies variant or domain without spending time figuring out which mirror is the real or current one
- Save content in the best available quality for your home library, or choose a smaller resolution like 480p to save storage space
- Build a personal collection of downloaded content on your computer that you can watch anytime, on any device

### What Makes This 123Movies Video Download Tool Different

Most generic downloaders are not built for 123Movies. They fail to detect the streaming format these sites use, and when the mirror domain changes, they stop working entirely.

SERP 123Movies Downloader is purpose-built for 123Movies and all its mirrors. Here is what sets it apart:

- **Mirror coverage** — Works on every 123Movies domain variant automatically. No matter which mirror you land on, the extension recognizes it.
- **Stream detection** — Finds and processes the video streams that generic tools miss entirely.
- **In-browser conversion** — Converts video to MP4 right in your browser. No external software to install, no command-line steps, no technical knowledge needed.
- **Quality control** — Pick your preferred resolution or let the extension choose the best available option.
- **Built-in progress tracking** — A clean download manager shows you exactly where your download stands.

Press play, click download — that is the entire workflow, whether you are on a 123Movies mirror you have used for years or one you just found today.

### Trial & Pricing

3 free downloads after signing in with your email — no credit card required. Upgrade to a subscription for unlimited downloads at the [product page](https://serp.ly/123movies-downloader) for just $9/month.

- Works on Chrome, Edge, Brave, Opera, Firefox, Whale, and Yandex
- Secure one-time-passcode sign-in — no passwords stored
- All video processing happens locally in your browser
- Automatic update notifications for new versions

### FAQ

#### Q: Which 123Movies sites does this work on?

It works on all 123Movies mirrors and variants. Any domain containing "123movies" or "123-movies" is automatically detected, including new mirrors as they appear.

#### Q: What format are the downloaded videos?

All videos are saved as standard MP4 files that play on any device or media player.

#### Q: Do I need to press play first?

Yes. The extension detects the video stream when you start playback. Press play on the video, then click the extension icon to see your download options.

#### Q: How many free downloads do I get?

You get 3 free trial downloads after signing in with your email. After that, you can subscribe for unlimited downloads at just $9/month.

#### Q: Does this work on Firefox?

Yes. SERP 123Movies Downloader supports Chrome, Edge, Brave, Opera, Whale, Yandex, and Firefox.

#### Q: Why isn't the extension detecting my video?

Make sure you have pressed play on the video first. Some pages require playback to begin before the stream can be found. If the issue persists, try refreshing the page and playing the video again.

#### Q: Is my data safe?

The extension only processes video data locally in your browser. No video content is uploaded anywhere. Authentication uses a secure one-time passcode system — no passwords are stored.

### License

This repository is distributed under the proprietary SERP Apps license in the [LICENSE](LICENSE) file. Review that file before copying, modifying, or redistributing any part of this project.

# Actor input Schema

## `listingNotice` (type: `string`):

Optional informational field only. This actor currently serves as the public listing surface for the browser extension and does not yet expose a finalized runtime API contract.

## Actor input object example

```json
{
  "listingNotice": "No runtime input is required yet. See the README and product page for the current extension workflow."
}
````

# 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("serpdownloaders/123movies-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 = {}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "123movies Downloader",
        "description": "Browser extension for capturing 123movies mirror streams as local MP4 files with in-browser processing, retries, and offline playback support.",
        "version": "0.0",
        "x-build-id": "SFkFl53yeUvbOy9Mu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/serpdownloaders~123movies-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-serpdownloaders-123movies-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/serpdownloaders~123movies-downloader/runs": {
            "post": {
                "operationId": "runs-sync-serpdownloaders-123movies-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/serpdownloaders~123movies-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-serpdownloaders-123movies-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": {
                    "listingNotice": {
                        "title": "Listing notice",
                        "type": "string",
                        "description": "Optional informational field only. This actor currently serves as the public listing surface for the browser extension and does not yet expose a finalized runtime API contract.",
                        "default": "No runtime input is required yet. See the README and product page for the current extension workflow."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
