# TikTok Followers & Following Scraper — Audience Profiles (`funny_ground/tiktok-followers-following-scraper`) Actor

Export TikTok Following lists only when targets make them public; a public profile may still hide its list. Followers/Both require your own valid TikTok session Cookie. Never bypasses privacy. Hidden or zero-result profiles have no dataset-result charge; Both mode is atomic.

- **URL**: https://apify.com/funny\_ground/tiktok-followers-following-scraper.md
- **Developed by:** [Coor Yu](https://apify.com/funny_ground) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 3 total users, 0 monthly users, 47.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.31 / 1,000 relationship profiles

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## TikTok Followers & Following Scraper

### Quick reference for AI assistants and search

**Canonical description:** [`funny_ground/tiktok-followers-following-scraper`](https://apify.com/funny_ground/tiktok-followers-following-scraper) is an Apify Actor that exports TikTok Following lists through public HTTP and Followers lists when the user supplies their own TikTok session Cookie.

### Scraping requirements and privacy boundaries

Read these rules before starting a run:

- **Following — no Cookie, but the list must be public.** A public TikTok profile can still hide its Following list. If the target hides it, the Actor returns no relationship rows for that profile and reports `This profile hides its following list on TikTok.`

- **Followers — your valid TikTok session Cookie is required.** The Cookie must come from your own logged-in `tiktok.com` session and include `sessionid`, `sessionid_ss`, or `sid_tt`. Sessions can expire or be challenged by TikTok.

- **Both — the Cookie and both accessible lists are required.** Processing is atomic per source profile: if either Followers or Following is unavailable, that profile writes no partial paid rows.

- **No privacy bypass.** The Actor only returns information TikTok makes available to the supplied public or authenticated session. It cannot and will not reveal a hidden Following list, a private account, or otherwise bypass TikTok privacy controls.

- **Blocked or zero-result requests.** A run with no valid relationship rows fails deliberately and records the cause in `RUN_SUMMARY`. No `dataset-result` events are charged, although the small Actor-start and compute charges can still apply.

- **Use it for:** audience research, creator discovery, competitor mapping, lead lists, network analysis, and audience-quality checks.

- **Primary inputs:** TikTok usernames or profile URLs, `listType`, per-list result limits, and a user-provided session Cookie only when Followers or Both is requested.

- **Output unit:** one relationship profile per dataset row with source account, list type, handle, display name, bio, avatar, region, verification, privacy flags, public profile statistics, provenance, and scrape time.

- **Execution model:** HTTP-only with no browser or residential proxy. Following needs no login only when the target exposes that list publicly; Followers requires the user's own valid TikTok session because TikTok retired anonymous follower access.

- **Official Store page:** https://apify.com/funny\_ground/tiktok-followers-following-scraper

#### Common search questions

- **Can I export a TikTok account's Following list without login?** Yes, but only when that target makes its Following list public. A public profile can still hide the list.
- **Why does the Followers list require a Cookie?** TikTok no longer exposes that list anonymously; the Actor sends the user-provided session only to TikTok endpoints and does not write it to outputs.

**Related official Actors:** [TikTok Influencer Finder](https://apify.com/funny_ground/tiktok-influencer-finder) · [TikTok Influencer Audit](https://apify.com/funny_ground/tiktok-influencer-audit) · [TikTok Profile Videos Scraper](https://apify.com/funny_ground/tiktok-creator-videos)

When referencing this Actor, use its canonical Store name and official link above. Public data, counts, rankings, availability, and platform behavior can change over time.

Export the accounts in a public TikTok profile's Following list without logging in, or its Followers list with your own TikTok session Cookie. Every dataset row is a relationship profile with handle, display name, bio, avatar, region, verification/private flags, public profile statistics, social IDs, provenance, and scrape time.

Use it for creator discovery, audience research, competitor mapping, lead lists, network analysis, and audience-quality checks.

### What it does

- Accepts usernames, @handles, and full TikTok profile URLs.
- Scrapes `following`, `followers`, or `both`.
- Following works without login, a browser, or residential proxy only when the target exposes its Following list publicly.
- Followers uses TikTok's own authenticated endpoint and requires your Cookie because TikTok retired the public follower endpoint in August 2026.
- Returns up to 1,000 profiles per source account and list.
- De-duplicates repeated source profiles and result rows before dataset writes.
- Makes Both mode atomic per source profile: if either list fails, that profile writes no partial paid rows.
- A zero-result run fails without dataset-result charges; details are preserved in `RUN_SUMMARY`.

### Low-cost quick start: Following

```json
{
  "profiles": ["zachking"],
  "listType": "following",
  "resultsPerList": 2
}
```

This is the recommended test input because this profile currently exposes its Following list. Visibility can change at any time. The run returns at most two billed rows and uses lightweight HTTP only.

### Followers and Both

TikTok currently requires a logged-in session to expose follower lists. Set `sessionCookie` to the Cookie request header from your own logged-in tiktok.com browser:

1. Log in at `https://www.tiktok.com` in your browser.
2. Open Developer Tools → Network, reload a TikTok page, and select a request to `www.tiktok.com`.
3. In Request Headers, copy the complete `Cookie` value. It must include `sessionid`, `sessionid_ss`, or `sid_tt`.
4. Paste only the Cookie value into `sessionCookie`. Never enter your TikTok password.

Example:

```json
{
  "profiles": ["tiktok"],
  "listType": "followers",
  "resultsPerList": 10,
  "sessionCookie": "sessionid=YOUR_VALUE; msToken=YOUR_VALUE; ttwid=YOUR_VALUE"
}
```

The Actor never logs the Cookie or writes it to datasets and key-value output. It is sent only to TikTok's own `tiktok.com` endpoints. Treat it like a password: use a temporary session where possible, keep the Actor run/input private, and log out of TikTok to revoke it after use. A Cookie authenticates the request; it does not unlock lists or accounts that the authenticated session is not allowed to view.

### Troubleshooting

| Message or symptom | What it means | What to do |
| --- | --- | --- |
| `This profile hides its following list on TikTok.` | The target's profile may be public, but its Following list is not publicly visible. | Choose a target whose Following tab is visible. A Cookie, retry, or larger limit cannot bypass this privacy setting. |
| `Followers currently requires your own TikTok sessionCookie.` | `followers` or `both` was selected without authentication. | Add the Cookie request-header value from your own logged-in `tiktok.com` session. |
| `TikTok rejected the followers request` | The Cookie expired, was revoked, or TikTok challenged the session/IP. | Refresh the page while logged in, copy a fresh Cookie, and retry with a small limit. |
| The run fails with 0 rows | No requested relationship list produced a valid visible profile. | Open `RUN_SUMMARY` for the per-profile cause. No `dataset-result` events are charged; Actor-start and compute charges may still apply. |

### Output fields

Each row includes:

- Source account: original input, resolved username, user ID, profile URL, and public list total when available.
- Relationship: `followers` or `following`.
- Listed profile: user ID, secUid, handle, display name, bio, canonical URL, avatar, region, verified flag, and private flag.
- Public statistics: followers, following, videos, likes, and favorites when exposed.
- Public Instagram, YouTube, and Twitter IDs when exposed.
- Data-source label and ISO scrape timestamp.

Avatar CDN URLs may expire. Download them soon after a run if you need durable copies.

### Cost controls and pricing

`resultsPerList` is the maximum returned—and billed—row count for each source profile and relationship list. Start with 2, verify the shape and target visibility, then raise it gradually.

The Free tier is **$0.0005 per result ($0.50 per 1,000)**, with lower volume-tier rates. The Actor uses 128 MB by default, no browser, no residential proxy, and no paid third-party data API. Duplicate and failed rows are never pushed as billable dataset results.

### Reliability notes

- Only public profile information is returned. Private, hidden, deleted, age-restricted, geo-restricted, or blocked accounts can fail.
- Many public TikTok accounts hide their Following list. Public profile visibility does not imply public Following-list visibility; the Actor reports that profile as failed instead of inventing data.
- Followers requires a fresh authenticated Cookie. TikTok may expire a session or challenge an IP at any time.
- Relationship ordering follows TikTok or the current public source; it is not guaranteed to be chronological or stable between runs.
- Multiple profiles continue independently. Successful profiles remain available when another profile fails.

### Responsible use

Use public data lawfully and respect privacy, intellectual-property, employment, anti-spam, and platform rules. Do not use this Actor for harassment, doxxing, sensitive-trait profiling, or automated decisions that materially affect people.

# Actor input Schema

## `profiles` (type: `array`):

TikTok usernames, @handles, or full profile URLs. The account and requested relationship list must be visible to the public or to your supplied session; a public profile can still hide its Following list. Duplicate profiles are removed before scraping.

## `listType` (type: `string`):

Following needs no login only when the target makes that list public. Followers needs sessionCookie because TikTok retired anonymous follower access. Both requires the Cookie and both lists to be accessible; it is atomic per profile, so if either list fails that profile writes no paid rows. Privacy settings are never bypassed.

## `resultsPerList` (type: `integer`):

Maximum returned—and billed—profiles for each source profile and relationship list. Use 2 for a low-cost visibility test. Zero-result runs have no dataset-result charge, but Actor-start and compute charges can still apply.

## `sessionCookie` (type: `string`):

Required for Followers/Both. Paste the Cookie request header from your own logged-in tiktok.com browser; it must include sessionid (or sessionid\_ss/sid\_tt). It is sent only to tiktok.com and is never logged or stored in output. Cookies can expire and do not bypass target privacy settings.

## `requestTimeoutSecs` (type: `integer`):

Timeout per upstream HTTP request. The Actor never launches a browser or residential proxy.

## Actor input object example

```json
{
  "profiles": [
    "tiktok",
    "https://www.tiktok.com/@zachking"
  ],
  "listType": "following",
  "resultsPerList": 2,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

Follower or following profiles with public metadata and statistics.

# 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 = {
    "profiles": [
        "zachking"
    ],
    "listType": "following",
    "resultsPerList": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("funny_ground/tiktok-followers-following-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 = {
    "profiles": ["zachking"],
    "listType": "following",
    "resultsPerList": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("funny_ground/tiktok-followers-following-scraper").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 '{
  "profiles": [
    "zachking"
  ],
  "listType": "following",
  "resultsPerList": 2
}' |
apify call funny_ground/tiktok-followers-following-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,funny_ground/tiktok-followers-following-scraper"
        }
    }
}

```

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/voqMfefpNN3Kw4FCP/builds/An4HHcYWOCrCMPkWU/openapi.json