# 9gag Media Downloader (`scraperoka/9gag-media-downloader`) Actor

📺 9gag Media Downloader helps you save memes & videos from 9gag fast and hassle-free. ⚡ Download high-quality content in seconds with a simple, user-friendly interface. ✅ Perfect for sharing, backups, and offline viewing.

- **URL**: https://apify.com/scraperoka/9gag-media-downloader.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Videos, Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### 9GAG Media Downloader 📥 — Download 9GAG videos, images, and post details in bulk

Manually visiting each 9GAG post to save media takes too long and kills momentum. **9GAG Media Downloader 📥** collects video and image assets plus core post details for you from a list of 9GAG links—ideal for marketers, recruiters, and growth teams that need speed. This **9GAG media downloader** helps you download 9GAG videos, save 9GAG images, and build datasets from 9GAG posts with less busywork—so you can process thousands of records in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "url": "https://9gag.com/gag/aND4YA4",
  "result": {
    "url": "https://9gag.com/gag/aND4YA4",
    "source": "ninegag",
    "title": "Example 9GAG Post Title",
    "thumbnail": "http://images-cdn.9gag.com/photo/12345_ogimage.jpg",
    "medias": [
      {
        "url": "https://example.com/path/to/media.mp4",
        "quality": "HD",
        "extension": "mp4",
        "type": "video"
      }
    ],
    "type": "single",
    "error": false,
    "time_end": 842
  }
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | The input 9GAG post URL associated with this result |
| `result.url` | string | The same post URL returned as the record source |
| `result.source` | string | Confirms the data source as `ninegag` |
| `result.title` | string | The post title you can use for labeling or categorization |
| `result.thumbnail` | string | A thumbnail image URL for quick previews |
| `result.medias` | array | The downloadable media items found on the post |
| `result.medias[].url` | string | Direct media URL you can save to use later |
| `result.medias[].quality` | string | Media quality label returned by the actor (e.g., `HD`) |
| `result.medias[].extension` | string | File type/extension (for images it matches the image URL suffix) |
| `result.medias[].type` | string | Whether the media is `video` or `image` |
| `result.type` | string | Always returned as `single` for each processed post |
| `result.error` | boolean | Whether the actor encountered an error for this specific post |
| `result.error_message` | string | Error details when something fails (or the actor exception message) |
| `result.time_end` | number | Processing time in milliseconds for this post |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why 9GAG Media Downloader 📥?

There are a lot of ways to pull data from 9GAG—here's what sets **9GAG Media Downloader 📥** apart.

#### Built for “media download” workflows

If you’re looking to **download 9GAG videos**, save **9GAG GIF downloader**-style media, or gather **9GAG image downloader** outputs, this actor returns a structured `medias` list with direct URLs, quality, extension, and media type.

#### Clean, structured output per post

Each 9GAG link you provide becomes one result object with consistent keys (`title`, `thumbnail`, and `medias`). That makes **9GAG post downloader** use cases easier to plug into analysis, tagging, or downstream automation.

#### Resilient per-link error handling

If a specific post can’t be processed, the actor still returns a record with `error: true` and an `error_message`, so you can keep going through mixed-quality inputs instead of losing your whole batch.

#### Built for bulk link processing

You submit a list of 9GAG post URLs, and the actor processes them and writes results as it goes—handy when you want **best 9GAG downloader** results across many posts, not just one-off saves.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "links": [
    "https://9gag.com/gag/aND4YA4",
    "https://9gag.com/gag/anotherExampleId"
  ]
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `links` | ✅ | List of 9GAG post URLs to process (each item becomes one output record) |

***

### Core Capabilities

#### Bulk post URL intake

Provide your 9GAG links in the `links` array, and the actor returns a separate result object for each post. This is perfect for workflows like building a **9GAG reels downloader**-style media catalog or running a **9GAG post downloader** job across campaigns.

#### Video and image media extraction

The actor collects downloadable media details for posts categorized as `Animated` or `Video` (returned as `type: "video"` with `extension: "mp4"`), and image-based posts (returned as `type: "image"` with the image URL-derived `extension`).

#### Thumbnail + metadata included

Alongside media URLs, each record includes `title` and a `thumbnail` URL so you can preview content quickly. That makes it easier to organize **9GAG media save** outputs without additional lookups.

#### Per-post processing time and error visibility

Each result includes `time_end` (milliseconds) and reports failures via `error: true` and `error_message`. This helps analysts measure throughput and troubleshoot problematic links.

#### Ready for automation and dataset export

Because outputs are written as structured JSON records, **9GAG media downloader** results are straightforward to export from Apify and feed into your pipeline—ideal when you’re building repeatable media datasets (e.g., **save 9GAG videos offline** catalogs).

***

### Who Gets the Most Out of This

**Marketing and Brand Teams** — Use 9GAG Media Downloader 📥 to quickly compile media from a list of posts, so creative teams can shortlist assets and speed up campaign ideation.

**Content Ops and Community Managers** — When you need a **9GAG image downloader** or **9GAG post downloader** workflow for reposting candidates, you can turn URLs into organized `title`, `thumbnail`, and `medias` records without manual downloading.

**Sales and Partnerships Researchers** — Build a structured archive of content references across many links, so your team can reference media when prepping outreach or partner proposals.

**Data Analysts and Researchers** — Run the actor on a curated dataset of 9GAG URLs and analyze extracted media metadata (types, extensions, processing time) using exports from Apify.

**Developers and Automation Specialists** — Trigger the actor with a list of post URLs and consume the resulting dataset programmatically, making **download 9GAG videos** and media collection repeatable.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run 9GAG Media Downloader 📥 from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open **9GAG Media Downloader 📥**.
2. **Enter your inputs** — add your 9GAG post URLs in the `links` field (from the configuration table above).
3. **Configure proxy settings** — set your proxy preferences in the Apify UI for reliable scraping runs.
4. **Hit Run and watch the live log** — monitor progress as each URL is processed.
5. **View results in the dataset tab** — each post produces a structured JSON record with `title`, `thumbnail`, and `medias`.
6. **Export as JSON, CSV, or Excel** — download the dataset in your preferred format directly from Apify.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, 9GAG Media Downloader 📥 plugs directly into your existing workflow.

Export formats are available directly from the Apify dataset tab, including JSON, CSV, and Excel, so you can move **9GAG media downloader** results into your analysis tools quickly. If you want to go further, you can connect Apify to your stack via Apify’s integrations and automation platforms like Zapier or Make (via their available Apify support).

You can also access run results via the Apify API and build automated pipelines (for example, fetching the dataset results into your internal storage or enrichment workflow). For event-driven workflows, you can use webhooks to trigger downstream actions when a run completes.

***

### Pricing & Free Trial

9GAG Media Downloader 📥 runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier includes **$5 platform credits on sign-up**, which is typically enough for several test runs. After that, usage is **pay-as-you-go** based on Apify platform compute units (CUs), without requiring a monthly subscription. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting concerns | Uses built-in proxy support for more reliable scraping |
| Mixed-quality inputs | Returns an error record per failed post (with `error: true` and `error_message`) |
| Runtime visibility | Provides `time_end` (milliseconds) per processed URL |
| Output completeness | Still pushes a dataset record even when a post can’t be processed successfully |
| Large batches | Designed for processing a list of post URLs in one run |

Limitations: this actor processes only the `links` you provide and returns whatever media details are available from the page content it can access. If a post’s expected configuration isn’t present, the actor reports it via `error_message`.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for 9GAG Media Downloader 📥?

Yes. Apify offers a **free tier** with **$5 platform credits on sign-up**, which is meant for getting started with test runs.

#### Do I need to log in to 9GAG to use this actor?

No. This actor is designed to scrape publicly available data from the 9GAG post URLs you supply.

#### How accurate is the data returned by 9GAG Media Downloader 📥?

Accuracy depends on what’s available on each target post page. The actor returns fields like `title`, `thumbnail`, and `medias` with `type`, `quality`, and `extension` based on what it finds for that post.

#### How many results can I get per run?

There’s no hard limit described in the actor’s input schema beyond how many URLs you put into `links`. Each URL becomes one output record.

#### How often is the data updated or how fresh is it?

The data is captured at run time, so freshness matches when you trigger the actor. If you need the latest media metadata, rerun with the same `links`.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor is built to work with **publicly available data**, but legal compliance depends on how you use and store the results. You’re responsible for compliance with GDPR, CCPA, and the platform’s Terms of Service.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard, and you can move the CSV/Excel into Google Sheets or other tools.

#### Can I run this on a schedule automatically?

Yes. You can schedule Apify actors to run automatically using Apify’s scheduling options, depending on your Apify plan and setup.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically via the Apify API—useful if you’re building an automated **9GAG video downloader** pipeline.

#### What happens if the actor hits an error?

If a specific post fails, the actor still pushes a record with `result.error: true` and includes `error_message` with details. Successful posts continue independently, so you still get value from the rest of your `links`.

***

### Need Help or Have a Request?

Got a question about **9GAG Media Downloader 📥** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome feedback and respond to requests for improvements like webhook notifications on completion or batch-driven enhancements. The actor is actively maintained based on user needs.

***

### Disclaimer & Responsible Use

*9GAG Media Downloader 📥 is the fastest, most reliable way to collect 9GAG media metadata — start your free run today.*

This actor collects **publicly available data** from the URLs you provide and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using the results. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `links` (type: `array`):

List of 9GAG post URLs.

## Actor input object example

```json
{
  "links": [
    {
      "url": "https://9gag.com/gag/aND4YA4"
    }
  ]
}
```

# 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 = {
    "links": [
        {
            "url": "https://9gag.com/gag/aND4YA4"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/9gag-media-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 = { "links": [{ "url": "https://9gag.com/gag/aND4YA4" }] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/9gag-media-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 '{
  "links": [
    {
      "url": "https://9gag.com/gag/aND4YA4"
    }
  ]
}' |
apify call scraperoka/9gag-media-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "9gag Media Downloader",
        "description": "📺 9gag Media Downloader helps you save memes & videos from 9gag fast and hassle-free. ⚡ Download high-quality content in seconds with a simple, user-friendly interface. ✅ Perfect for sharing, backups, and offline viewing.",
        "version": "0.1",
        "x-build-id": "ZbRpdCYMeZYBfmhOr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~9gag-media-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-9gag-media-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/scraperoka~9gag-media-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-9gag-media-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/scraperoka~9gag-media-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-9gag-media-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",
                "required": [
                    "links"
                ],
                "properties": {
                    "links": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "List of 9GAG post URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
