# Tumblr Scraper (`goat255/tumblr-scraper`) Actor

Scrape Tumblr blog posts without a login. Pull a blog's posts with title, body text, tags, images and links, filter by tag, and walk deeper history when you supply a read key. Built for content research, trend tracking and archiving. One clean row per post, ready for analysis or export.

- **URL**: https://apify.com/goat255/tumblr-scraper.md
- **Developed by:** [Goutam Soni](https://apify.com/goat255) (community)
- **Categories:** Social media, Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Scraper

Scrape public Tumblr blog posts without a login or API key. Give the Tumblr Scraper one or more blogs and it returns clean, structured rows for each post: title, body text, tags, images, outbound links, post type, and publish date.

### What it does

- **Scrapes posts from any public Tumblr blog.** Pass a blog name, a host, or a full blog URL.
- **Extracts the full post shape:** title, a plain-text summary of the body, tags, image URLs, outbound links, post type, and publish date.
- **No login and no API key required** for the latest posts of each blog.
- **Tag filtering.** Keep only posts that carry a specific tag (case-insensitive).
- **Multi-blog batches.** Pass many blogs at once and process them in parallel.
- **Deeper history (optional).** Supply an optional read key and raise the per-blog cap to walk further back through a blog's archive, with note counts included.
- **Clean, stable output.** Every row uses the same field shape, so the dataset drops straight into a spreadsheet, database, or downstream automation.

### Use cases

- **Content and trend research.** Track what topics, tags, and formats a niche or fandom is posting about right now.
- **Brand and keyword monitoring.** Watch how a brand, product, or hashtag is being discussed across blogs you care about.
- **Lead and creator discovery.** Find active creators in a space by pulling their recent posts, tags, and linked sites.
- **Dataset building.** Collect posts, images, and tags at scale for analysis, archiving, or model training inputs.
- **Competitor and market analysis.** Pull the recent output of blogs in your own market to benchmark posting cadence, formats, and themes.

### Input

| Field | Type | Description |
|---|---|---|
| `blogs` | array | Tumblr blogs to scrape. Each entry can be a blog name (`example_blog`), a host (`example_blog.tumblr.com`), or a full URL (`https://example_blog.tumblr.com`). |
| `tag` | string | Keep only posts carrying this tag. Case-insensitive. Leave blank to keep every post. |
| `maxPostsPerBlog` | integer | Maximum posts returned per blog. Default 20. The latest batch is served with no key; to go beyond it, also supply a read key. |
| `apiKey` | string | Optional read key. Only needed when you want more than the latest batch of posts per blog. Without it, the latest posts are returned with no credentials at all. |
| `concurrency` | integer | How many blogs to process in parallel. Default 5. |
| `proxyConfig` | object | Optional proxy configuration. Not required for the public endpoints, but available if you wish to route through one. |

#### Example input

```json
{
  "blogs": ["example_blog", "https://another-example.tumblr.com"],
  "tag": "art",
  "maxPostsPerBlog": 50
}
````

### Output

Each post is one dataset row with a stable, importance-ordered shape:

```json
{
  "type": "post",
  "postId": "812545258409934848",
  "blog": "example_blog.tumblr.com",
  "url": "https://example_blog.tumblr.com/post/812545258409934848",
  "noteCount": 128,
  "postType": "photo",
  "title": "An example post",
  "summary": "A short plain-text rendering of the post body.",
  "tags": ["art", "example"],
  "images": ["https://example.com/image.jpg"],
  "links": ["https://example.com"],
  "date": "2026-03-30T20:45:43.000Z"
}
```

#### Key fields

- **`postId`, `url`, `blog`** identify the post and where it lives.
- **`postType`** classifies the post (`text`, `photo`, or `video`) so you can split content by format.
- **`noteCount`** is the post's engagement (likes plus reblogs). It is populated when you supply a read key.
- **`title`, `summary`, `tags`** carry the readable content. `summary` is a plain-text rendering of the body, not the raw HTML.
- **`images`, `links`** are de-duplicated arrays of media URLs and outbound links found in the post.
- **`date`** is the ISO 8601 publish time.

### FAQ

**Is it free? How is it priced?**
The actor is pay per result, so you are billed for the posts it returns. There is no separate per-run start fee. Pull a few posts to try it, then scale up.

**Do I need a Tumblr login or password?**
No. The latest posts of any public blog are returned with no login, no password, and no API key. A read key is optional and only needed to go beyond the latest batch into a blog's deeper archive.

**How many posts can I get per blog?**
The latest batch (about 20 posts) is available with no key. To reach further back through a blog's archive, raise `maxPostsPerBlog` and supply a read key.

**How fast is it?**
Blogs are processed in parallel (configurable with `concurrency`), so a batch of many blogs finishes far quicker than running them one at a time.

**Can I filter by tag?**
Yes. Set `tag` to keep only posts carrying that tag. Matching is case-insensitive.

**Why is `noteCount` empty on some runs?**
Note counts are returned on the deeper-history path, which needs a read key. The keyless latest-posts path does not expose them, so `noteCount` stays empty there.

**What about copyrighted content?**
Post bodies are returned as a plain-text summary. Full long-form copyrighted bodies (such as complete song lyrics) are not stored.

### Privacy

To improve our actors we collect anonymized usage telemetry (run stats and input patterns). No personal account data is collected.

# Actor input Schema

## `blogs` (type: `array`):

Tumblr blogs to pull posts from. Accepts a blog name, a full host, or a blog URL. Example: example\_blog, example\_blog.tumblr.com, https://example\_blog.tumblr.com.

## `tag` (type: `string`):

When set, only posts carrying this tag are kept. Case-insensitive. Leave blank to keep every post.

## `maxPostsPerBlog` (type: `integer`):

Cap on posts returned per blog. The latest batch is served without any key. To reach beyond the latest batch, also supply a read key below so the full archive can be walked.

## `apiKey` (type: `string`):

Optional read key. Only needed when you want more than the latest batch of posts per blog. Without it, the latest batch is returned with no credentials at all.

## `concurrency` (type: `integer`):

How many blogs to process in parallel.

## `proxyConfig` (type: `object`):

Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.

## Actor input object example

```json
{
  "blogs": [
    "staff"
  ],
  "tag": "",
  "maxPostsPerBlog": 20,
  "concurrency": 5,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `posts` (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 = {
    "blogs": [
        "staff"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("goat255/tumblr-scraper").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 = { "blogs": ["staff"] }

# Run the Actor and wait for it to finish
run = client.actor("goat255/tumblr-scraper").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 '{
  "blogs": [
    "staff"
  ]
}' |
apify call goat255/tumblr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tumblr Scraper",
        "description": "Scrape Tumblr blog posts without a login. Pull a blog's posts with title, body text, tags, images and links, filter by tag, and walk deeper history when you supply a read key. Built for content research, trend tracking and archiving. One clean row per post, ready for analysis or export.",
        "version": "0.1",
        "x-build-id": "i3A0lIB6PYbv84YsB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/goat255~tumblr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-goat255-tumblr-scraper",
                "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/goat255~tumblr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-goat255-tumblr-scraper",
                "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/goat255~tumblr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-goat255-tumblr-scraper",
                "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": {
                    "blogs": {
                        "title": "Blogs",
                        "type": "array",
                        "description": "Tumblr blogs to pull posts from. Accepts a blog name, a full host, or a blog URL. Example: example_blog, example_blog.tumblr.com, https://example_blog.tumblr.com.",
                        "default": [
                            "staff"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tag": {
                        "title": "Tag filter",
                        "type": "string",
                        "description": "When set, only posts carrying this tag are kept. Case-insensitive. Leave blank to keep every post.",
                        "default": ""
                    },
                    "maxPostsPerBlog": {
                        "title": "Max posts per blog",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cap on posts returned per blog. The latest batch is served without any key. To reach beyond the latest batch, also supply a read key below so the full archive can be walked.",
                        "default": 20
                    },
                    "apiKey": {
                        "title": "Read key (optional, for deeper history)",
                        "type": "string",
                        "description": "Optional read key. Only needed when you want more than the latest batch of posts per blog. Without it, the latest batch is returned with no credentials at all."
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many blogs to process in parallel.",
                        "default": 5
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. The public read endpoints do not require a proxy, but you may route through one if you wish.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
