# MEGA File Downloader | Bypass Limit (`easytools/mega-downloader-bypass-limit`) Actor

Download MEGA files and folders fast, bypass common MEGA download limits, and get a ready-to-download file or ZIP.

- **URL**: https://apify.com/easytools/mega-downloader-bypass-limit.md
- **Developed by:** [Easy Tools](https://apify.com/easytools) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 3,932 total users, 29 monthly users, 87.7% runs succeeded, 5 bookmarks
- **User rating**: 2.09 out of 5 stars

## Pricing

$5.50/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#rental-actors

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## MEGA download limit bypass — download public MEGA files and folders 🚀

This Actor is built for **MEGA download limit bypass** workflows with public `mega.nz` file and folder links. It helps you quickly download files, grab full folders as ZIP archives, and avoid the usual manual workarounds when you just want the file on your computer.

You pay only standard Apify platform usage. Every run returns a structured result plus a direct file download option. ✅

**What you get after each run 🎁**

- **Dataset:** one final result item per input URL, ready to export as JSON, CSV, Excel, XML, RSS, or HTML tables in Apify. 📊
- **Files:** a ready-to-download file or ZIP link for every successful item. 🗄️

**Modes / Features ⚙️**

- **Download mode** — downloads a public MEGA file or a full public folder tree so you can download the final file or ZIP. 📦
- **Check-only mode** — validates access, detects file or folder type, and returns sizes without downloading content. 🔎

> 💡 **Tip:** Use check-only mode first when you want a quick mega.nz transfer quota exceeded fix workflow, cost estimate, or file-size check before downloading.

If you need dedicated proxy routing or downloads above 60 GB, contact us and we can enable a PRO mode for your use case.

***

### Table of contents 📚

- Key features
- What this Actor does
- Use cases
- Quick start
- How it works
- Input
- Output
- Pricing
- Statuses & error codes
- Best practices
- FAQ
- Bugs, fixes, updates, and changelog
- Support

***

### Key features ✨

- Download public `mega.nz` file links without signing in to a MEGA account.
- Download full public MEGA folders and package the whole tree into one ZIP archive.
- Run bulk jobs from a list of public links and get one final Dataset item per input URL.
- Use `checkOnly` mode to inspect availability, file counts, and byte sizes before paying for a full download.
- Get a direct downloadable result for each successful file or folder.
- Supports optional Apify proxy configuration for custom routing scenarios.

### What this Actor does 🧠

- Accepts an array of public MEGA file and folder URLs in `megaUrls`.
- Normalizes and deduplicates the input list before processing.
- Detects whether each URL points to a file or a folder.
- In download mode, fetches a file as-is or turns a full folder tree into one ZIP you can download.
- In check-only mode, validates the link and returns total bytes plus file count without downloading content.
- Returns a final status for each input item such as `DELIVERED`, `FOUND`, `NOT_FOUND`, or `API_ERROR`.

### Use cases 🎯

- **Download large public MEGA files without manual tricks** — useful if you want a mega downloader bypass tool instead of browser workarounds.
- **Export public MEGA folders as one ZIP** — useful when you need to download large files from MEGA without account login and keep the folder structure together.
- **Pre-check link availability before download** — useful for a mega download limit fix workflow where you want size and accessibility first.
- **Replace manual troubleshooting** — useful if you normally search for how to bypass mega download limit, megasync bypass guide, or mega download limit bypass reddit threads.

### Quick start (UI) 🚀

1. Open the Actor in Apify Console.
2. Paste one or more public MEGA URLs into `megaUrls`.
3. Leave `checkOnly` as `false` if you want the final downloadable file or ZIP.
4. Set `checkOnly` to `true` if you only want validation, file count, and total size.
5. Optionally add `proxyConfiguration` if your workflow requires proxy routing.
6. Run the Actor.
7. Open the run output and download the file or ZIP from the provided result link.

### How it works 🔁

1. The Actor validates and normalizes the input list.
2. It loads public MEGA metadata for each file or folder.
3. It checks resource limits and decides whether to run check-only or full download mode.
4. For folders, it downloads the full tree and creates a ZIP archive.
5. It prepares a downloadable result for each successful item.
6. It writes one final Dataset item per input URL.

### Input ⌨️

#### Fields

- `megaUrls` (`string[]`, required): Public MEGA file or folder URLs to process.
- `checkOnly` (`boolean`, optional, default `false`): If `true`, the Actor validates and inspects resources without downloading them.
- `proxyConfiguration` (`object`, optional): Standard Apify proxy configuration object.

#### Input rules

- Maximum `100` input URLs per run.
- Empty, non-string, and duplicate items are removed during normalization.
- Input payload for `megaUrls` must stay within the Actor input size limit enforced in code.
- Public MEGA links only. Invalid or unsupported link formats return `INVALID_INPUT`.
- Current public Actor limits:
  - maximum `10 GB` per single file,
  - maximum `60 GB` total accepted volume per run.

#### Input examples ✅

**Example 1 — download one folder and one file**

```json
{
  "megaUrls": [
    "https://mega.nz/folder/PQ8ihaSK#mifSYy5C2c3NdTb4D7tfiQ",
    "https://mega.nz/file/ujoTnKwC#boaT1YnjINGRoHzKLqUQ0OPBHDXaj-Bd7v-xU7X0J1M"
  ],
  "checkOnly": false
}
```

**Example 2 — check sizes without downloading**

```json
{
  "megaUrls": [
    "https://mega.nz/folder/PQ8ihaSK#mifSYy5C2c3NdTb4D7tfiQ"
  ],
  "checkOnly": true
}
```

**Example 3 — run with Apify Proxy**

```json
{
  "megaUrls": [
    "https://mega.nz/file/ujoTnKwC#boaT1YnjINGRoHzKLqUQ0OPBHDXaj-Bd7v-xU7X0J1M"
  ],
  "checkOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Output 📦

#### Where output is stored 🗂️

- **Dataset:** one final item per input URL.
- **Key-Value Store:** final binary artifact for each successful download, such as a file or ZIP.
- **Cloud runs:** `apifyDownloadUrl` points to the stored artifact.
- **Local runs:** `apifyDownloadUrl` is `null`, but the artifact is still saved in local storage.

#### Example output item

```json
{
  "id": "e702c06abe3e5281",
  "status": "DELIVERED",
  "resourceType": "folder",
  "checkOnly": false,
  "artifactKey": "artifact-e702c06abe3e5281.zip",
  "apifyDownloadUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/artifact-e702c06abe3e5281.zip",
  "fileCount": 7,
  "totalBytes": 165462766,
  "errorCode": null,
  "message": null
}
```

#### Output fields

- `id`: stable hashed identifier derived from the normalized input URL.
- `status`: final item status.
- `resourceType`: `file` or `folder`.
- `checkOnly`: whether the item was processed in validation-only mode.
- `artifactKey`: Key-Value Store record key for the final file or ZIP.
- `apifyDownloadUrl`: direct API URL for the artifact on cloud runs.
- `fileCount`: number of delivered or detected files.
- `totalBytes`: total bytes for the file or full folder tree.
- `errorCode`: machine-friendly error code if the item did not complete successfully.
- `message`: human-readable summary for failures or warnings.

### Pricing 💸

> ### ⚠️ Important pricing note
>
> - This Actor does **not** add a custom per-item fee.
> - You pay only standard Apify platform usage such as compute and transfer.
> - `checkOnly=true` is usually cheaper because it skips content download and ZIP creation.
> - Invalid or unavailable links can still consume a small amount of compute because the Actor must validate them first.

- Full downloads are best when you want a practical bypass mega limit workflow and a file you can download right away.
- Check-only runs are best when you want to estimate size, verify availability, or test a link before downloading.
- If you need proxy-heavy routing, very large custom jobs, or files above the public limit, contact us for PRO mode.

### Statuses & error codes 🧾

#### Statuses

- `DELIVERED` — the file or folder was downloaded and saved successfully.
- `FOUND` — the resource exists and metadata was returned in check-only mode.
- `NOT_FOUND` — the resource is unavailable or no longer accessible.
- `INVALID_INPUT` — the input is not a supported public MEGA URL.
- `LIMIT_EXCEEDED` — the item exceeded a configured file-size or run-size limit.
- `API_ERROR` — the Actor hit a temporary or unrecoverable remote/network problem.
- `SKIPPED_FAILSAFE` — the Actor skipped the item after repeated system-level failures earlier in the same run.

#### Error codes

- `INVALID_FORMAT` — unsupported or malformed public MEGA link.
- `NOT_FOUND` — the resource could not be resolved.
- `FILE_TOO_LARGE` — at least one file exceeded the per-file limit.
- `RUN_SIZE_LIMIT` — the remaining run-size budget was exceeded.
- `MEGA_BANDWIDTH_LIMIT` — remote bandwidth limit was reached.
- `API_ERROR` — generic remote or networking failure.
- `FAILSAFE_STOP` — item skipped after repeated system errors.

#### Run-level failures

- `INVALID_INPUT_EMPTY` — nothing valid remained after normalization.
- `INPUT_TOO_LARGE` — serialized input exceeded the configured payload limit.
- `INPUT_TOO_MANY_URLS` — more than `100` URLs were supplied.
- `CONFIG_INVALID_PROXY` — the provided proxy configuration could not be initialized.

### Best practices ✅

- Use `checkOnly=true` before full downloads when you are testing new links or estimating cost.
- Group only the links you actually need; one oversized batch can hit the run-size limit sooner.
- Prefer public links that you already verified manually once if you are automating recurring jobs.
- If you are evaluating best vpn for mega download limit or free proxy for mega download options, test them first in check-only mode before running large batches.

### FAQ ❓

#### How to bypass mega download limit with this Actor?

Paste one or more public MEGA links into `megaUrls` and run the Actor. Files are returned as downloadable files, folders are returned as downloadable ZIP archives. This gives you a simple workflow for how to bypass mega download limit without building your own script.

#### Can this help with mega.nz transfer quota exceeded fix scenarios?

Yes, for public links. If a public file or folder is accessible, the Actor can validate it in check-only mode or download it in full mode so you can grab the result. If the remote side itself blocks or rate-limits access, you may still see `MEGA_BANDWIDTH_LIMIT` or `API_ERROR`.

#### Can I download large files from MEGA without account login?

Yes, as long as you have a public MEGA link. The Actor does not require MEGA login for the public version.

#### Is it free?

No. This Actor uses standard Apify platform billing. There is no extra per-item actor fee, but compute and storage usage still apply. If you only need validation, `checkOnly=true` is the cheaper option.

#### How much does it cost?

It depends on run duration, downloaded volume, and stored artifact size. In practice, check-only runs are cheaper than full downloads. If you need low-cost planning for large files, run a check-only job first and then download only what you need.

#### Where do I download the final output?

On Apify cloud runs, each successful Dataset item includes `artifactKey` and `apifyDownloadUrl`. Use that link to download the final file or ZIP.

#### Does this replace a MegaSync bypass guide, VPN workaround, or Chrome extension?

It replaces many manual steps, but it is not a browser extension. If you normally search for megasync bypass guide, mega download limit bypass chrome extension, or mega.nz bandwidth limit bypass advice, this Actor gives you a structured cloud workflow instead of a manual browser process.

#### Do I need a VPN or proxy?

Not always. Many public links work without any proxy. But if your use case needs custom routing, geo-specific behavior, or higher-volume jobs, contact us about PRO mode instead of relying on random free proxy lists.

### Bugs, fixes, updates, and changelog 🛠️

This Actor is under active development. If you have a bug report or feature request, open an issue here: https://apify.com/apify/mega-downloader-bypass-limit/issues/open

### Support 🤝

If you need help, send:

- Run ID
- input JSON with sensitive values removed
- the status or `errorCode`
- 1 or 2 example MEGA links that reproduce the issue

Direct contacts:

- Email: `artur.novikk@gmail.com`
- Telegram: https://t.me/systorer

For support, use the Actor page in Apify Console or open an Apify issue:

- https://apify.com/apify/mega-downloader-bypass-limit/issues/open

# Actor input Schema

## `megaUrls` (type: `array`):

Public MEGA file or folder URLs to process.

## `checkOnly` (type: `boolean`):

Validate accessibility and size without downloading content.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy configuration.

## Actor input object example

```json
{
  "megaUrls": [
    "https://mega.nz/file/ujoTnKwC#boaT1YnjINGRoHzKLqUQ0OPBHDXaj-Bd7v-xU7X0J1M"
  ],
  "checkOnly": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "megaUrls": [
        "https://mega.nz/file/ujoTnKwC#boaT1YnjINGRoHzKLqUQ0OPBHDXaj-Bd7v-xU7X0J1M"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("easytools/mega-downloader-bypass-limit").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 = { "megaUrls": ["https://mega.nz/file/ujoTnKwC#boaT1YnjINGRoHzKLqUQ0OPBHDXaj-Bd7v-xU7X0J1M"] }

# Run the Actor and wait for it to finish
run = client.actor("easytools/mega-downloader-bypass-limit").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 '{
  "megaUrls": [
    "https://mega.nz/file/ujoTnKwC#boaT1YnjINGRoHzKLqUQ0OPBHDXaj-Bd7v-xU7X0J1M"
  ]
}' |
apify call easytools/mega-downloader-bypass-limit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,easytools/mega-downloader-bypass-limit"
        }
    }
}

```

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/myH22HYHrWh52AUg6/builds/Ti0TdFDh2Dd1iAGZM/openapi.json