# Tumblr Media Downloader (`maximedupre/tumblr-media-downloader`) Actor

Download media from public Tumblr post, blog, and archive URLs. Export direct media links, available variants, post metadata, tags, engagement counts, source URLs, and scrape timestamps for APIs, schedules, and integrations.

- **URL**: https://apify.com/maximedupre/tumblr-media-downloader.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.65 / 1,000 media items

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

### 📥 Tumblr media downloader for public posts and blogs

Tumblr Media Downloader collects public media from [Tumblr](https://www.tumblr.com/) post, blog, and archive URLs and exports direct media links with useful post context. Use it when you need Tumblr images, videos, GIFs, or audio files in a structured dataset for research, content operations, archiving workflows, scheduled exports, or API-based integrations.

Start with a single Tumblr post URL when you know exactly which post you need. Add a blog or archive URL when you want the Actor to discover recent public posts and save the media it finds. Each accepted media item is saved as its own dataset row, so downstream tools can process files one by one without unpacking large nested post objects.

### ✅ What this Actor does

Tumblr Media Downloader finds media attached to public Tumblr posts and returns one row per media item. It supports public post URLs, public blog homepages, and public archive URLs. For blog and archive runs, it discovers public posts from the target page and collects media from those posts until it reaches your maximum media row limit.

The Actor returns source-friendly metadata next to each media URL, including the Tumblr blog name, post URL, post ID, summary text, caption text, tags, publish time when available, note count when available, and scrape timestamp. When Tumblr exposes multiple media variants, the Actor can include those variants so you can choose the size or format that fits your workflow.

### 📊 Data you can export

The dataset includes direct media links and post context that is useful in spreadsheets, databases, automation tools, and API clients:

- Input URL and target type
- Tumblr blog name and blog title
- Post ID, post URL, summary, caption text, tags, publish time, and note count
- Media type, media index, media count in the post, file extension, width, and height when available
- Direct source media URL
- Optional media variants with available sizes and URLs
- Optional Apify key-value store file details when media saving is enabled
- Scrape timestamp

### 🚀 How to run it

1. Add one or more public Tumblr post, blog, or archive URLs.
2. Set the maximum number of media rows you want to save.
3. Choose whether to include media variants.
4. Optionally enable media file saving to Apify storage.
5. Run the Actor and export the dataset as JSON, CSV, Excel, XML, or through the Apify API.

For a quick first run, keep the default limit or lower it to 25 media rows and use a public blog or archive URL. For a targeted run, paste a direct Tumblr post URL.

### 🧾 Input

The main input is `startUrls`, an array of public Tumblr URLs. Supported targets are:

- Public Tumblr post URLs
- Public Tumblr blog URLs
- Public Tumblr archive URLs

`maxItems` controls the maximum number of media rows saved across all targets. `includeMediaVariants` keeps available alternate media URLs with each row. `saveMediaToKeyValueStore` downloads each media file through the Actor and returns an Apify storage URL in addition to the source URL.

### 📄 Output example

```json
{
  "inputUrl": "https://staff.tumblr.com/archive",
  "inputIndex": 0,
  "targetType": "archive",
  "discoveredFromUrl": "https://staff.tumblr.com/archive",
  "blogName": "staff",
  "blogTitle": "Tumblr Staff",
  "postId": "818408523445731328",
  "postUrl": "https://staff.tumblr.com/post/818408523445731328",
  "postSummary": "Where's that comment?",
  "captionText": "Where's that comment?\nHello Tumblr!",
  "tags": ["tumblr update"],
  "publishedAt": "2026-06-03 13:59:49 GMT",
  "noteCount": 3436,
  "mediaIndex": 1,
  "mediaCountInPost": 4,
  "mediaType": "image",
  "extension": "jpg",
  "width": 1280,
  "height": 720,
  "mediaUrl": "https://64.media.tumblr.com/example.jpg",
  "directMediaUrl": "https://64.media.tumblr.com/example.jpg",
  "mediaVariants": [
    {
      "url": "https://64.media.tumblr.com/example_1280.jpg",
      "width": 1280,
      "height": 720
    }
  ],
  "source": "tumblr",
  "service": "tumblr.com",
  "scrapedAt": "2026-06-13T19:05:37.103Z"
}
````

When media saving is enabled, rows also include a `savedFile` object with the Apify storage key, download URL, content type, and file size in bytes.

### 💸 Pricing

This Actor uses pay-per-event pricing. You are charged only for saved Tumblr media items. The current event price is $0.00265 per media item, which is $2.65 per 1,000 saved media items.

Runs that stop before finding media do not charge media item events.

### ⚖️ Limits and caveats

This Actor is built for public Tumblr content. It does not log in to Tumblr, bypass private blogs, or access content that requires an authenticated account. Tumblr can remove posts, change media availability, or omit some metadata, so optional fields may be missing on some rows.

Blog and archive URLs are discovery targets, not full historical backups. Use `maxItems` to control run size, and run the Actor on a schedule when you want recurring exports from the same public blogs.

### ❓ FAQ

#### 🖼️ Can it download Tumblr images, videos, GIFs, and audio?

Yes. The Actor saves media rows for supported public Tumblr media it finds on the requested posts or discovered public posts. The `mediaType` field identifies the item type when it can be determined.

#### 🔗 Should I use post URLs or blog URLs?

Use post URLs for exact posts. Use blog or archive URLs when you want the Actor to discover recent public posts and collect media until it reaches your `maxItems` limit.

#### 💾 Does it save files or only return links?

By default, the Actor returns direct source media links. If you enable `saveMediaToKeyValueStore`, it also downloads each media file to Apify storage and returns a `savedFile` object.

#### 🧩 Can I use the data with the Apify API?

Yes. The output is saved to the default dataset, so you can export it from the Apify Console or read it from the Apify API in automation, dashboards, and integrations.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~tumblr-media-downloader/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Telegram Media Downloader ↗](https://apify.com/maximedupre/telegram-media-downloader) - Download public Telegram media URLs and post data.
- [Facebook Media Downloader ↗](https://apify.com/maximedupre/facebook-media-downloader) - Download public Facebook video and reel media links.
- [Twitter Media Scraper ↗](https://apify.com/maximedupre/twitter-media-scraper) - Extract public Twitter/X post media from posts, profiles, hashtags, and searches.
- [TikTok Video Downloader ↗](https://apify.com/maximedupre/tiktok-video-downloader) - Download public TikTok video and audio files.
- [Pinterest Video Downloader ↗](https://apify.com/maximedupre/pinterest-video-downloader) - Download public Pinterest pin video media.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Public Tumblr post, blog, or archive URLs to collect media from. Post URLs collect that post; blog and archive URLs collect media from discovered public posts.

## `maxItems` (type: `integer`):

Maximum number of media rows to save across all Tumblr URLs. Use a small value for a quick first run.

## `includeMediaVariants` (type: `boolean`):

Save available size and quality variants with each media row.

## `saveMediaToKeyValueStore` (type: `boolean`):

Download each media file and return an Apify storage URL alongside the source URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tumblr.com/pears-palette/773661808796090368/an-important-psa-to-remember-id-in-alt"
    },
    {
      "url": "https://staff.tumblr.com/"
    }
  ],
  "maxItems": 100,
  "includeMediaVariants": true,
  "saveMediaToKeyValueStore": false
}
```

# Actor output Schema

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

Open the dataset with direct media links, media variants, post metadata, source URLs, and scrape timestamps.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.tumblr.com/pears-palette/773661808796090368/an-important-psa-to-remember-id-in-alt"
        },
        {
            "url": "https://staff.tumblr.com/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/tumblr-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 = { "startUrls": [
        { "url": "https://www.tumblr.com/pears-palette/773661808796090368/an-important-psa-to-remember-id-in-alt" },
        { "url": "https://staff.tumblr.com/" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/tumblr-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 '{
  "startUrls": [
    {
      "url": "https://www.tumblr.com/pears-palette/773661808796090368/an-important-psa-to-remember-id-in-alt"
    },
    {
      "url": "https://staff.tumblr.com/"
    }
  ]
}' |
apify call maximedupre/tumblr-media-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tumblr Media Downloader",
        "description": "Download media from public Tumblr post, blog, and archive URLs. Export direct media links, available variants, post metadata, tags, engagement counts, source URLs, and scrape timestamps for APIs, schedules, and integrations.",
        "version": "0.1",
        "x-build-id": "e1i5mvzfL8aGeakXB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~tumblr-media-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-tumblr-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/maximedupre~tumblr-media-downloader/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-tumblr-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/maximedupre~tumblr-media-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-tumblr-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Tumblr URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Public Tumblr post, blog, or archive URLs to collect media from. Post URLs collect that post; blog and archive URLs collect media from discovered public posts.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum media rows",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of media rows to save across all Tumblr URLs. Use a small value for a quick first run.",
                        "default": 100
                    },
                    "includeMediaVariants": {
                        "title": "Include media variants",
                        "type": "boolean",
                        "description": "Save available size and quality variants with each media row.",
                        "default": true
                    },
                    "saveMediaToKeyValueStore": {
                        "title": "Save media files to Apify storage",
                        "type": "boolean",
                        "description": "Download each media file and return an Apify storage URL alongside the source URL.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```