# Tumblr Username Availability Scraper (`automation-lab/tumblr-username-availability-checker`) Actor

Check batches of Tumblr usernames and export available, occupied, or reserved status with blog URLs, HTTP evidence, and timestamps.

- **URL**: https://apify.com/automation-lab/tumblr-username-availability-checker.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.24 / 1,000 username checkeds

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/actors/running/actors-in-store.md#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.

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

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

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

# README

## Tumblr Username Availability Checker

Check **Tumblr username availability** in batches and export a structured answer for every candidate name.

This Actor classifies each normalized Tumblr username as `available`, `occupied`, or `reserved`. It includes the canonical blog URL when a public blog exists, the HTTP statuses supporting the decision, a concise evidence explanation, and the exact check timestamp.

Use it before a brand launch, while selecting campaign handles, or as a scheduled naming-inventory check. You do not need a Tumblr account, API key, cookies, or your own proxy.

### What does this Tumblr username checker do?

The Actor accepts up to 100 names or Tumblr blog URLs in one run. It:

1. trims and normalizes each name to lowercase;
2. accepts `@name`, `name.tumblr.com`, and public Tumblr blog URLs;
3. removes duplicate normalized names;
4. checks Tumblr's lightweight blog-info surface;
5. distinguishes a missing blog from a reserved Tumblr route;
6. returns one typed dataset row per unique checked name;
7. retries only transient upstream failures with strict limits.

Unlike a generic social-account finder, this Actor is intentionally focused on Tumblr. The output exposes response evidence instead of returning only an unexplained yes/no flag.

### Who is it for?

- **Brand managers** validating candidate names before a launch.
- **Social media teams** comparing a shortlist across scheduled runs.
- **Campaign operators** checking temporary event or promotion handles.
- **Agencies** exporting naming research into client spreadsheets.
- **Developers** adding Tumblr availability evidence to an internal workflow.
- **Researchers** maintaining timestamped public namespace observations.

The Actor is a lookup tool, not an account-registration bot. It never logs in, reserves a name, or creates a Tumblr blog.

### What data does it return?

| Field | Meaning |
| --- | --- |
| `input` | The original name or URL supplied by the user. |
| `username` | Normalized lowercase Tumblr username. |
| `available` | `true` only when both public checks indicate availability. |
| `status` | `available`, `occupied`, or `reserved`. |
| `blogUrl` | Canonical `https://name.tumblr.com/` URL for an occupied blog; otherwise `null`. |
| `lookupUrl` | Tumblr blog-info endpoint used for the primary check. |
| `apiHttpStatus` | HTTP status from the blog-info lookup. |
| `pageHttpStatus` | HTTP status from the public namespace route when needed. |
| `evidence` | Human-readable explanation supporting the classification. |
| `checkedAt` | ISO 8601 UTC check timestamp. |

All records are written to the run's default Apify dataset. You can download them as JSON, CSV, Excel, XML, RSS, or JSONL through Apify's standard dataset exports.

### How are available, occupied, and reserved different?

#### Available

No public blog exists, and Tumblr's public namespace route also returns not found. The Actor sets `available: true` and `blogUrl: null`.

#### Occupied

Tumblr resolves an existing public blog. The Actor sets `available: false` and returns its canonical Tumblr subdomain in `blogUrl`.

#### Reserved

No public blog is resolved, but the name belongs to a Tumblr application route such as `login`. The Actor sets `available: false` and leaves `blogUrl` null.

Tumblr can withhold names for private policy, trademark, moderation, or account-history reasons that are not exposed publicly. Therefore `available` means the public lookup surfaces were clear at check time; it is not a guarantee that Tumblr will allow account registration.

### How to use the Actor

1. Open the Actor in Apify Console.
2. Add one or more values under **Tumblr usernames**.
3. Optionally lower **Maximum results**.
4. Click **Start**.
5. Open the **Results** tab.
6. Export the table or connect the dataset to your next automation step.

A useful first input is:

```json
{
  "usernames": [
    "staff",
    "tumblr",
    "brand-campaign-2026",
    "login"
  ],
  "maxResults": 4
}
```

This mix exercises occupied blogs, a candidate name, and a reserved route.

### Input parameters

#### `usernames`

Required array of 1–100 strings. Each value may be:

- a plain name such as `campaign-studio-2026`;
- an at-name such as `@campaign-studio-2026`;
- a Tumblr subdomain such as `staff.tumblr.com`;
- a full URL such as `https://staff.tumblr.com/`;
- a main-site blog URL such as `https://www.tumblr.com/staff`.

Normalized names may contain lowercase letters, digits, and hyphens. They must contain 1–32 characters and cannot begin or end with a hyphen. Invalid input fails clearly before any checks are charged.

#### `maxResults`

Optional integer from 1 to 100. It limits the number of unique normalized names checked and returned. The default is 100.

Duplicate spellings such as `Staff`, `@staff`, and `https://staff.tumblr.com/` count as one normalized username.

### Output example

A current occupied-blog record has this shape:

```json
{
  "input": "https://staff.tumblr.com/",
  "username": "staff",
  "available": false,
  "status": "occupied",
  "blogUrl": "https://staff.tumblr.com/",
  "lookupUrl": "https://api.tumblr.com/v2/blog/staff.tumblr.com/info",
  "apiHttpStatus": 401,
  "pageHttpStatus": null,
  "evidence": "Tumblr blog-info endpoint resolved the blog and returned HTTP 401 for the anonymous metadata request.",
  "checkedAt": "2026-01-15T12:00:00.000Z"
}
```

The timestamp above is illustrative. Every actual record receives its run-time UTC timestamp.

### How much does it cost to check Tumblr usernames?

The Actor uses pay per event pricing:

- **Run started:** $0.005 once per run.
- **Username checked:** tiered per unique result, with $0.00046 on the FREE tier and $0.00040 on BRONZE.

At FREE-tier event prices, approximate totals are:

| Unique usernames | Approximate total |
| ---: | ---: |
| 1 | $0.00546 |
| 10 | $0.00960 |
| 25 | $0.01650 |
| 100 | $0.05100 |

Higher Apify tiers receive lower per-result prices. Duplicate normalized names do not create extra results or item charges. A malformed input fails before the start event; a valid run charges the start event, then charges only rows successfully saved to the dataset.

Apify platform usage is included under pay-per-event pricing where shown in Console. Always check the live pricing panel for the tier applying to your account.

### Recurring brand-name monitoring workflow

For a repeatable shortlist process:

1. Store the current candidate names in an Apify Task.
2. Schedule the Task daily or weekly.
3. Export each dataset to Google Sheets, a database, or object storage.
4. Compare `status` and `checkedAt` with the prior run.
5. Trigger an internal review when a candidate changes from occupied to available or vice versa.

The Actor does not maintain historical state itself. Keeping each run's dataset separate avoids stale rows and lets your integration choose its own retention period.

### Spreadsheet and data-pipeline integrations

You can connect results to:

- Google Sheets for a naming shortlist;
- Make or Zapier for notifications and routing;
- webhooks for post-run processing;
- Python or JavaScript data pipelines;
- the Apify API for CSV or JSON exports;
- scheduled Apify Tasks for recurring checks.

Use `username` as the stable normalized comparison key. Use `checkedAt` to order observations. Keep `status` rather than inferring from `blogUrl`, because reserved names intentionally have no blog URL.

### Run with the Apify API

Set `APIFY_TOKEN` in your shell. Never commit it to source control.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tumblr-username-availability-checker/runs?token=$APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["staff","campaign-studio-2026"],"maxResults":2}'
```

Fetch dataset items using the `defaultDatasetId` returned by the run response.

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tumblr-username-availability-checker').call({
  usernames: ['staff', 'campaign-studio-2026'],
  maxResults: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tumblr-username-availability-checker').call(
    run_input={
        'usernames': ['staff', 'campaign-studio-2026'],
        'maxResults': 2,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/tumblr-username-availability-checker"
```

For **Claude Desktop**, add this to the MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/tumblr-username-availability-checker"
    }
  }
}
```

In **Cursor**, open MCP settings and add the same `apify` server URL. In **VS Code**, add the same HTTP server under your MCP servers configuration, then enable it for the workspace.

Example prompts:

- “Check these Tumblr names and return only those currently marked available.”
- “Verify whether these known Tumblr blog URLs are still occupied.”
- “Run my campaign shortlist and summarize available, occupied, and reserved counts.”

Review agent-generated inputs before running them, especially when a prompt contains large or untrusted lists.

### Reliability, retries, and limits

The Actor uses a lightweight HTTP workflow rather than a browser. That keeps memory, runtime, and transfer low.

Transient timeouts, HTTP 429 responses, and temporary server errors are retried up to two times with exponential backoff. Stable validation errors, HTTP 404 classifications, and unexpected response shapes are not retried blindly.

Limits:

- 100 supplied username strings per run;
- 100 unique output rows per run;
- five concurrent checks;
- at most three attempts for a transient request;
- no account login, cookies, or residential proxy fallback.

If Tumblr changes the response contract, the Actor fails rather than silently converting an unknown response into “available.”

### Troubleshooting

#### Why did my run fail on one unexpected Tumblr response?

The Actor treats unknown statuses as evidence it cannot safely classify. Retry later if Tumblr had an incident. If the same name repeatedly fails while others work, inspect the log and public route manually before relying on a result.

#### Why is a name reserved instead of available?

Tumblr may use that path for its own application. The blog-info lookup finds no blog, but the main public namespace route still exists, so the Actor avoids claiming the name is available.

#### Why did several inputs produce only one row?

Inputs are normalized and deduplicated. `Staff`, `@staff`, and the full staff blog URL all represent the same username.

#### Can the Actor reserve a name for me?

No. It performs anonymous public checks only. Registration requires Tumblr's own signup flow and policies.

### Responsible use and legality

The Actor accesses anonymous public Tumblr response surfaces and records availability evidence. It does not access private posts, accounts, credentials, or authenticated APIs.

You are responsible for:

- complying with Tumblr's terms and applicable law;
- respecting trademarks and naming rights;
- avoiding abusive request patterns;
- not using availability results to impersonate people or organizations;
- independently confirming a name in Tumblr's signup flow before making business commitments.

Availability data can change immediately after a check. Treat every result as a timestamped observation, not ownership or legal clearance.

### FAQ

#### Does this scrape Tumblr posts?

No. It checks username and public-blog existence only.

#### Does it need a Tumblr API key?

No. The classification uses anonymous response statuses and does not request protected metadata.

#### Are custom-domain Tumblr blogs supported?

Supply the underlying Tumblr username or a `*.tumblr.com` / `www.tumblr.com/<name>` URL. Arbitrary custom domains are not accepted because they cannot be normalized reliably to a Tumblr username.

#### Is “available” guaranteed to be registerable?

No. Tumblr may apply undisclosed policy or account-history restrictions during registration.

#### Can I schedule it?

Yes. Save the input as an Apify Task and add a schedule. Each run writes a new timestamped dataset.

#### Are duplicate names charged twice?

No. The Actor normalizes and deduplicates names before checking and charging result events.

### Related automation-lab Actors

- [Tumblr Tagged Posts Scraper](https://apify.com/automation-lab/tumblr-tagged-posts-scraper) extracts public tagged-feed posts and embedded blog metadata.
- [Username Checker](https://apify.com/automation-lab/username-checker) searches for usernames across hundreds of platforms when you need broad cross-network discovery.
- [Cross-platform Username Discovery](https://apify.com/automation-lab/cross-platform-username-discovery) returns richer public profile metadata from GitHub, GitLab, and Mastodon.

Choose this Actor when the buyer job is specifically Tumblr naming availability and auditable status evidence.

### Support

For reproducible issues, include the run URL, sanitized input, affected normalized username, observed status, and expected classification. Do not include API tokens or private account information.

# Actor input Schema

## `usernames` (type: `array`):

Candidate names, @names, or Tumblr blog URLs to check. Names may contain letters, numbers, and hyphens and must be at most 32 characters.

## `maxResults` (type: `integer`):

Maximum number of unique normalized usernames to check and return.

## Actor input object example

```json
{
  "usernames": [
    "staff",
    "tumblr",
    "brand-campaign-2026"
  ],
  "maxResults": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all Tumblr username availability records.

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

Table view of normalized availability results and evidence.

# 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 = {
    "usernames": [
        "staff",
        "tumblr",
        "brand-campaign-2026"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tumblr-username-availability-checker").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 = {
    "usernames": [
        "staff",
        "tumblr",
        "brand-campaign-2026",
    ],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tumblr-username-availability-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "usernames": [
    "staff",
    "tumblr",
    "brand-campaign-2026"
  ],
  "maxResults": 20
}' |
apify call automation-lab/tumblr-username-availability-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/tumblr-username-availability-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/KdL2sOjjW4kTO7KRZ/builds/Sc0bKBafhai5MxrHV/openapi.json