# Reel.farm TikTok Slideshow Scraper (`mrdoe/reelfarm`) Actor

Scrape reel.farm's TikTok Slideshow creator profiles, products promoted, niches, audience regions, and likes/views/bookmarks per slideshow. No login required. Optional session token unlocks AI-generated "recreate this slideshow" prompts.

- **URL**: https://apify.com/mrdoe/reelfarm.md
- **Developed by:** [MrDoe](https://apify.com/mrdoe) (community)
- **Categories:** Social media, Automation, Videos
- **Stats:** 4 total users, 1 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$0.50 / 1,000 results

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/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

## Reel.farm Database Scraper

reel.farm maintains a database of TikTok creators running AI-generated slideshow content - who they are, what they're promoting, and how each of their slideshows is performing. This actor turns that database into rows you can filter, export, and build on. **Public by default, no account needed.** A session token is optional and only unlocks one extra field.

### Two ways to run it

| | Default (no token) | With `sessionToken` |
|---|---|---|
| Creator profiles, niches, products, audience data | ✅ | ✅ |
| Slideshow likes / views / bookmarks | ✅ | ✅ |
| Slideshow images | ✅ | ✅ |
| AI-generated "recreate this slideshow" prompt | ❌ (blank) | ✅ |
| Your own logged-in `/dashboard/slideshow` view | ❌ | ✅ with `scrapeOwnDashboard` |

Most runs don't need a token at all - the database itself is fully public.

### What's in each row

| Category | Fields |
|---|---|
| Creator | `unique_id`, `nickname`, `signature`, `follower_count`, `following_count`, `avatar_url`, `link_in_bio` |
| Positioning | `product`, `product_medium`, `niche`, `region`, `audience_regions` |
| This slideshow | `slideshow_index`, `slideshow_name`, `likes`, `views`, `bookmarks` |
| Media | `image_url`, `images` (all images, comma-separated), `imageStorageUrl` (if downloaded) |
| AI | `prompt` (only when a session token is set) |

One row = one slideshow. A creator with 5 recent slideshows produces up to 5 rows (capped by `maxSlideshowsPerProfile`).

**These are image carousels, not video** - there's no audio, sound, or music field anywhere in this dataset. If you need TikTok audio/sound data, this isn't the right source for it.

### Who this is for

- **Faceless/UGC creators** scanning for niches and formats that are actually converting right now, across hundreds of profiles instead of scrolling a dashboard by hand.
- **AI content agencies** sourcing real, high-performing slideshow examples (and their prompts) to brief a generation pipeline.
- **Market researchers** mapping which product categories and regions creators in this space are targeting.
- **Growth teams** building a benchmark set of slideshow performance numbers to measure their own output against.

### Input options

| Field | What it does |
|---|---|
| `startUrls` | Which listing to scrape. `https://reel.farm/dashboard/database` for everything, or a filtered URL like `.../niche/self-improvement` or `.../medium/mobile-app` to scope it. Leave blank for the full database. |
| `maxItems` | Row cap per listing URL. `0` = unlimited. Default `200`. |
| `maxSlideshowsPerProfile` | Row cap per creator, so output spreads across many profiles instead of one eating the whole budget. Default `2`. |
| `sessionToken` | Optional login credential - see below. Unlocks the `prompt` field. |
| `downloadImages` | Save each slideshow's first image into the key-value store instead of only linking to it. Default off. |
| `scrapeOwnDashboard` | Requires `sessionToken`. Also pulls your private `/dashboard/slideshow` view as its own rows - the actor's original mode. Default off. |
| `proxyConfiguration` | Leave as-is unless requests start failing. |

#### Getting a session token

1. Log into [reel.farm](https://reel.farm).
2. DevTools -> Application (Chrome) / Storage (Firefox) -> Cookies.
3. Copy the `__Secure-next-auth.session-token` value.
4. Paste into `sessionToken`. It's a secret-type field - masked in the Console, never written to logs.

Use a secondary account if you have one; it's a live credential. `sessionToken` by itself enriches the public rows with `prompt`. Add `scrapeOwnDashboard` to also pull your own dashboard as separate rows.

### Example inputs

Whole database:

```json
{ "maxItems": 200 }
```

One niche, prompts included:

```json
{
    "startUrls": [{ "url": "https://reel.farm/dashboard/database/niche/self-improvement" }],
    "maxItems": 50,
    "sessionToken": "your-session-token"
}
```

### Sample row

```json
{
    "unique_id": "noteswithzay",
    "nickname": "zayyy",
    "follower_count": "13",
    "product": "AI note-taking app",
    "product_medium": "Mobile App",
    "niche": "studytok",
    "region": "PK",
    "profile_url": "https://reel.farm/noteswithzay",
    "slideshow_index": 1,
    "slideshow_name": "Slideshow 1",
    "likes": "18",
    "views": "345",
    "bookmarks": "6",
    "prompt": "",
    "image_url": "https://dh8vpkzn300g4.cloudfront.net/noteswithzay/slideshow_f754e7fc.jpeg",
    "images": "https://.../slideshow_f754e7fc.jpeg,https://.../slideshow_63081dcc.jpeg",
    "imageStorageUrl": null
}
```

Export it as CSV, Excel, or JSON from the Console, or pull it through the API.

### Good to know

- `maxItems` is scoped **per listing URL**, not the whole run - two `startUrls` at `maxItems: 50` each can return up to 100 rows total.
- Filtered listing URLs (niche/product/region) are matched the same way reel.farm's own dashboard filters them - the underlying response is always the full dataset regardless of URL.
- A creator with zero recent slideshows still returns one row (profile fields filled in, slideshow fields blank) rather than being silently dropped.
- `prompt` costs a real network round-trip per row, so token-enabled runs are noticeably slower than public-only ones - plan `maxItems` accordingly.

### FAQ

**Do I need a reel.farm account to use this?**
No. Everything except the `prompt` field is public - profiles, niches, products, regions, slideshow stats, and images.

**Is there any audio or sound data in here?**
No. These are static image slideshows, not videos - there's no audio/music field in reel.farm's data for this feature.

**My session token is wrong or expired - does the run fail?**
No. `prompt` just comes back empty for every row, exactly like running with no token at all.

**How do I scope a run to one niche or product category?**
Point `startUrls` at a filtered listing, e.g. `https://reel.farm/dashboard/database/niche/<slug>` or `.../medium/<slug>`.

**Can I get the actual image files, not just URLs?**
Yes - `downloadImages: true` saves each slideshow's first image to the key-value store and adds an `imageStorageUrl` link.

**Is there a hard limit on how many rows I can pull?**
Only what you set in `maxItems` (`0` = unlimited) per listing URL - the actor paginates through the whole listing on its own.

**Some rows have a blank `prompt` even with a token set - why?**
reel.farm's prompt-generation endpoint occasionally rate-limits or times out per slideshow; that row's `prompt` is left blank instead of failing the run.

**What's the difference between `sessionToken` alone and adding `scrapeOwnDashboard`?**
`sessionToken` alone just fills in `prompt` on the public rows. Adding `scrapeOwnDashboard` additionally fetches your own private `/dashboard/slideshow` view as its own separate rows. With an invalid/expired token, that part returns zero extra rows rather than failing the run.

# Actor input Schema

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

reel.farm TikTok Slideshow Database listing page URL(s) to scrape, e.g. https://reel.farm/dashboard/database/niche/self-improvement for one niche, or https://reel.farm/dashboard/database/medium/mobile-app for a product category. Leave the default to scrape the whole database.

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

Maximum number of dataset rows (one per slideshow) to scrape per listing URL. Set to 0 for unlimited.

## `maxSlideshowsPerProfile` (type: `integer`):

Maximum number of slideshow rows to include per creator profile (0 = unlimited). Keeps output spread across many profiles instead of Max Items being exhausted by the first one.

## `sessionToken` (type: `string`):

Optional. Not required to scrape - profile, niche, product, and slideshow stats are all public. Provide your reel.farm session token to additionally fetch the AI-generated "recreate this slideshow" prompt for every row. Log into reel.farm, open DevTools -> Application -> Cookies, and copy the value of the \_\_Secure-next-auth.session-token cookie. This is a live login credential - never share it or commit it to a public repo.

## `downloadImages` (type: `boolean`):

If enabled, each slideshow's first image is downloaded and stored in the key-value store, with a link added to that row's imageStorageUrl field. Off by default since image\_url already links directly to the source image.

## `scrapeOwnDashboard` (type: `boolean`):

Requires Session Token above. This is the original scraping mode: it additionally fetches reel.farm's private /dashboard/slideshow view using your logged-in session, the same profile/slideshow data your own dashboard shows you. Most users don't need this - the public database above already covers the same kind of data without a login. Off by default; ignored if no session token is set.

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

Proxy settings for fetching pages. Leave as-is unless you're seeing blocked or failed requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://reel.farm/dashboard/database"
    }
  ],
  "maxItems": 200,
  "maxSlideshowsPerProfile": 2,
  "downloadImages": true,
  "scrapeOwnDashboard": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `slideshows` (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 = {
    "startUrls": [
        {
            "url": "https://reel.farm/dashboard/database"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrdoe/reelfarm").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://reel.farm/dashboard/database" }] }

# Run the Actor and wait for it to finish
run = client.actor("mrdoe/reelfarm").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 '{
  "startUrls": [
    {
      "url": "https://reel.farm/dashboard/database"
    }
  ]
}' |
apify call mrdoe/reelfarm --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/reelfarm"
        }
    }
}

```

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/xfrcgJ2vbahR6s2og/builds/vDDDgdmCIrHL6djqC/openapi.json