Follower count API for Instagram, TikTok, YouTube and more

Last updated: October 21, 2026

TL;DR: A follower count API is a web service that takes a public handle or profile link and returns the account's audience size as a number you can store. With Scrape Everything you send one POST per profile and read one JSON field. Each lookup costs 1 credit on eight platforms, and repeat lookups inside your cache_days window are free.

Fetching the number is easy. The annoying part: every platform names it differently, gates it behind a different official API, and rounds it differently. Below is one table for all of that, an honest look at the official routes, and a daily snapshot script. The scrapers hub lists every endpoint on all nine platforms.

How do I get the follower count of an account via API?#

Send one request per profile. Every Scrape Everything endpoint is a POST to https://api.scrapeeverything.com/v1/<platform>/<action> with a JSON body and an Authorization: Bearer ssk_live_... header. Profile endpoints cost 1 credit each. Failures on our side (blocked, timeout, parse error) are refunded automatically, everywhere below.

The shortest version, for Instagram:

curl -X POST https://api.scrapeeverything.com/v1/instagram/profile \
  -H "Authorization: Bearer $SCRAPEEVERYTHING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "example_user"}'

Trimmed response:

{
  "success": true,
  "data": {
    "id": "1234567890",
    "username": "example_user",
    "full_name": "Example User",
    "is_private": false,
    "is_verified": false,
    "follower_count": 48213,
    "following_count": 512,
    "post_count": 731
  },
  "meta": {
    "request_id": "req_XXXXXXXXXXXXXXXXXXXX",
    "scraper": "instagram.profile",
    "cached": false,
    "cached_at": null,
    "credits_charged": 1,
    "credits_remaining": 99
  }
}

No Instagram login, no Meta app, no proxy. The username field accepts a bare name, an @handle or a full profile URL, so you can paste whatever your spreadsheet has.

Which endpoint and field gives the follower count on each platform?#

Field names come straight from our endpoint catalog.

All eight cost 1 credit per call. There's no single field name you can hardcode, so keep a small map from endpoint to field, like the script further down does.

Spotify is our ninth platform, but follower counts aren't publicly visible there, so spotify.artist has none (Spotify's own Web API does). We don't cover LinkedIn, Threads, Reddit or Snapchat. Better to hear that here than from a KeyError.

Should I use the official API or a scraper API for follower counts?#

Depends on the platform. Some official routes are fine; others only cover your own account.

My honest take on YouTube: if you already have a Google Cloud project, the Data API is hard to beat for subscriber counts. A channels.list call costs 1 quota unit, takes up to 50 channel IDs, and the default quota is 10,000 units a day. Use us when you want one key and one schema across platforms, or only have handles, not channel IDs.

How do I get Instagram and TikTok follower counts?#

Both work the same way: POST /v1/instagram/profile or POST /v1/tiktok/profile with a username, then read data.follower_count.

Instagram's official route is Business Discovery in the Instagram API with Facebook Login. It returns followers_count, but only through a Meta app, with an access token for your own professional account, and only for other business or creator accounts. Our endpoint reads what a logged-out visitor sees, so personal public profiles work too. Error handling and bulk jobs are in our guide to scraping Instagram profiles with an API and the Instagram profile scraper reference.

TikTok gives you more per call. Alongside follower_count you get like_count (total hearts received) and video_count, which is enough for likes per video without a second request. The TikTok profile endpoint page lists every field, and our TikTok scraper API walkthrough covers the video endpoints.

A private Instagram account still returns its public fields, count included, with is_private: true. TikTok profiles carry the same flag. So you can tell "private" from "doesn't exist", which comes back as 404 NOT_FOUND.

How do I get X, YouTube and Twitch follower counts?#

X follower count

POST /v1/x/profile returns follower_count, following_count, tweet_count and listed_count, plus is_private for accounts with protected posts. X's own API puts the same numbers in public_metrics on the v2 user lookup, and that access is paid. For a daily count on a few hundred handles, that's overkill. Details on the X profile scraper page.

Is the YouTube subscriber count API exact?

No. YouTube shows abbreviated subscriber counts on public pages, and the official YouTube Data API channels resource documents that subscriberCount is rounded down to three significant figures. Our youtube.profile endpoint parses the public text, so you get two fields:

• subscriber_count_text: the raw string, like "521M subscribers"
• subscriber_count: that string as an integer, so 521000000

Store both. Chart a large channel's growth and you'll get a staircase: flat for weeks, then a jump. That's rounding, not a bug in your pipeline. video_count is rounded the same way. More at the YouTube scraper hub.

Twitch follower count API

POST /v1/twitch/channel (note: channel, not profile) returns follower_count along with is_live, is_partner and is_affiliate.

The official route hurts most here. Twitch's Helix API serves follower data from Get Channel Followers, which needs a registered app and a user access token. Unless that token belongs to the broadcaster or one of their moderators, with the moderator:read:followers scope, you get the total and nothing else. Fine for one channel, tedious for 300. See the Twitch scraper hub.

How do I get Telegram, Pinterest and Facebook follower counts?#

Telegram subscriber count API

POST /v1/telegram/profile reads the public t.me card. Which field gets filled depends on what the handle is:

• channels: subscriber_count
• groups: member_count and online_count
• bots: monthly_users

The type field tells you which one you got. It's inferred from the public counters, so check extra_text (the raw counter line) when it matters. See the Telegram scraper hub.

Pinterest follower count

POST /v1/pinterest/profile returns follower_count, following_count, pin_count and board_count for the profile. One call, four numbers. Pinterest scraper hub.

Facebook: Pages only

facebook.profile reads a Page's public preview. For public Pages you get follower_count, like_count and talking_about_count. Personal profiles mostly sit behind Facebook's login wall, so expect null counts. Pages that don't exist or require login return 502 TARGET_BLOCKED instead of a 404, and those aren't charged. Mixed list of brands and people? Filter out follower_count is None before graphing. Facebook scraper hub.

How do I track follower growth daily?#

Put your handles in a list, map each endpoint to its count field, and append one CSV row per handle per day. Run it from cron, a GitHub Action or an n8n workflow.

Python snapshot script

Needs Python 3.9+ and requests 2.x.

import csv
import datetime as dt
import os
from pathlib import Path

import requests

API = "https://api.scrapeeverything.com/v1"
KEY = os.environ["SCRAPEEVERYTHING_API_KEY"]
# 0 on the scheduled run (always live). Set CACHE_DAYS=1 when you rerun
# the same day after a crash, so handles already fetched cost 0 credits.
CACHE_DAYS = int(os.environ.get("CACHE_DAYS", "0"))

# endpoint -> fields to try, in order
COUNT_FIELDS = {
    "instagram/profile": ["follower_count"],
    "tiktok/profile": ["follower_count"],
    "x/profile": ["follower_count"],
    "youtube/profile": ["subscriber_count"],
    "twitch/channel": ["follower_count"],
    "telegram/profile": ["subscriber_count", "member_count", "monthly_users"],
    "pinterest/profile": ["follower_count"],
    "facebook/profile": ["follower_count"],
}

TARGETS = [
    ("instagram/profile", {"username": "example_user"}),
    ("tiktok/profile", {"username": "example_user"}),
    ("youtube/profile", {"username": "@example_channel"}),
    ("twitch/channel", {"username": "example_streamer"}),
    ("telegram/profile", {"username": "https://t.me/example_channel"}),
]

OUT = Path("follower_snapshots.csv")


def fetch(endpoint: str, body: dict) -> dict:
    if CACHE_DAYS:
        body = {**body, "cache_days": CACHE_DAYS}
    r = requests.post(
        f"{API}/{endpoint}",
        headers={"Authorization": f"Bearer {KEY}"},
        json=body,
        timeout=90,  # the docs recommend at least 90 s
    )
    try:
        payload = r.json()
    except ValueError:  # e.g. an HTML 502 from a proxy in between
        raise RuntimeError(f"{endpoint} {body}: HTTP {r.status_code}, non-JSON body")
    if not payload.get("success"):
        raise RuntimeError(f"{endpoint} {body}: {r.status_code} {payload.get('code')}")
    return payload


def main() -> None:
    today = dt.date.today().isoformat()
    new_file = not OUT.exists()
    with OUT.open("a", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        if new_file:
            w.writerow(["date", "endpoint", "handle", "count", "cached"])
        for endpoint, body in TARGETS:
            try:
                p = fetch(endpoint, body)
            except (RuntimeError, requests.RequestException) as err:
                print("skip:", err)
                continue
            data = p["data"]
            count = next(
                (data[k] for k in COUNT_FIELDS[endpoint] if data.get(k) is not None),
                None,
            )
            w.writerow([today, endpoint, body["username"], count, p["meta"].get("cached")])


if __name__ == "__main__":
    main()

The scheduled run sends no cache_days, so every row is a live reading. The cached column flags rows from a same-day rerun.

How do I calculate follower growth from the snapshots?

This standard-library script compares each handle's latest count with its count 7 days earlier:

import csv
import datetime as dt
from collections import defaultdict

rows = defaultdict(dict)  # (endpoint, handle) -> {date: count}
with open("follower_snapshots.csv", encoding="utf-8") as f:
    for r in csv.DictReader(f):
        if r["count"]:
            rows[(r["endpoint"], r["handle"])][r["date"]] = int(r["count"])

for (endpoint, handle), series in rows.items():
    latest = max(series)
    week_ago = (dt.date.fromisoformat(latest) - dt.timedelta(days=7)).isoformat()
    if week_ago in series:
        old, new = series[week_ago], series[latest]
        pct = (new - old) / old * 100 if old else 0.0
        print(f"{endpoint:18} {handle:30} {new - old:+8d} {pct:+6.2f}%")

Output looks like this (placeholder handles and numbers):

instagram/profile  example_user                       +412  +0.86%
twitch/channel     example_streamer                    +95  +1.40%
youtube/profile    @example_channel                     +0  +0.00%

That +0 on YouTube is the staircase from earlier. Look at a 30-day window for big channels.

Node lookup with a concurrency cap

Node 18+ has fetch built in. This version runs a small pool of workers instead of firing everything at once:

const API = "https://api.scrapeeverything.com/v1";
const KEY = process.env.SCRAPEEVERYTHING_API_KEY;
const CONCURRENCY = 5; // free accounts: 5 concurrent; paid: 20

const targets = [
  ["x/profile", { username: "example_user" }, "follower_count"],
  ["pinterest/profile", { username: "example_user" }, "follower_count"],
  ["facebook/profile", { username: "example_page" }, "follower_count"],
];

async function lookup([endpoint, body, field]) {
  const res = await fetch(`${API}/${endpoint}`, {
    method: "POST",
    headers: { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify(body),
    signal: AbortSignal.timeout(90_000),
  });
  const json = await res.json().catch(() => ({ success: false, code: `HTTP_${res.status}` }));
  if (!json.success) return { endpoint, handle: body.username, error: json.code };
  return { endpoint, handle: body.username, count: json.data[field], cached: json.meta.cached };
}

const queue = [...targets];
const results = [];
async function worker() {
  while (queue.length) results.push(await lookup(queue.shift()));
}
await Promise.all(Array.from({ length: CONCURRENCY }, worker));
console.table(results);

Save it as followers.mjs so top-level await works.

How often can I check a profile, and what does it cost?#

There's no batch endpoint: one handle is one request. Rate limits are per account. Free accounts get 60 requests per minute and 5 concurrent requests. Accounts whose purchases total $39 or more (a Builder pack or larger) get 300 per minute and 20 concurrent. Back off on 429 RATE_LIMITED or 429 CONCURRENCY_LIMIT; rejected requests aren't charged. A call can take up to a minute while we retry through other proxies, which is why both scripts use a 90-second timeout. Full details on the rate limits page.

cache_days is the main cost lever. Every successful live result is kept for 14 days. When you pass cache_days (1 to 14), we return a stored result that's young enough for 0 credits, flagged with meta.cached: true and an X-Cache: HIT header. The caching docs suggest 7 to 14 days for enriching CRM records. Cache hits still count toward your per-minute limit.

Credits come in one-time packs that never expire: Builder $39 / 25,000 credits, Growth $119 / 100,000, Scale $449 / 500,000. At 1 credit per lookup, daily tracking costs this at each pack's effective rate (you buy whole packs, so this is usage cost, not an invoice):

Apify, for comparison, charges a monthly platform plan (the free plan includes $5 of usage) plus per-Actor prices that vary, per our Apify comparison checked October 22, 2026. Prices change, so check theirs. For agency client rosters, the agencies use case and the pricing calculator help you size a pack.

Can I get real-time follower counts?#

Not as a stream. We read the public page when you ask, so a request without cache_days returns the count at that moment. There's no push or webhook. "Live" counters on other sites poll in a loop; you can too, within your rate limit, though hourly is plenty for most dashboards. Social Blade charts history for you; this setup puts the raw numbers in your own database.

What are the limits of a follower count API?#

• Public data only: no logins, no private posts, no follower lists.
• Approximate figures where the platform rounds. YouTube is the clear case.
• Facebook counts exist for public Pages, not personal profiles.
• A handle that doesn't exist returns 404 NOT_FOUND. It's billed (the lookup completed), so drop dead handles from your list. The full billing table is in the errors docs.
• Unofficial. Scrape Everything isn't affiliated with these platforms. For write access or private analytics on your own accounts, use the official API.

On the legal side: read the platform terms and get advice for your jurisdiction. If you track individuals rather than brands, a follower count tied to a named person can be personal data under rules like the GDPR, so store only what you need and for as long as you need it. We cover the general questions in is scraping public social media data legal.

How do I start?#

Want to check a handle by hand first? Three free tools run the same endpoints without an account: the Instagram profile viewer, the TikTok profile viewer and the YouTube channel viewer.

Then Get 100 free credits. Sign in with Google or GitHub, no payment details needed. That's 100 lookups, enough to run the 5-handle Python script daily for about 20 days. Set SCRAPEEVERYTHING_API_KEY, replace the placeholder handles, and run it.

AI agents can call the same endpoints through our MCP server (Model Context Protocol). For terminal testing there's the CLI, and the full spec is published as OpenAPI.

FAQ#

Is there one API that returns follower counts for every social network?

No single official API does. Scrape Everything covers eight: Instagram, TikTok, X, YouTube, Twitch, Telegram, Pinterest and Facebook Pages. Each has its own endpoint at 1 credit, and the count field name differs per platform. LinkedIn, Threads and Reddit aren't covered.

Is there a free follower count API?

Partly. The YouTube Data API has a free daily quota, and the Telegram Bot API is free if your bot can reach the chat. Scrape Everything gives 100 free credits on signup, which is 100 profile lookups across any of the eight platforms.

How do I get an Instagram follower count without the Graph API?

Call POST /v1/instagram/profile with {"username": "..."} and read data.follower_count. It works for any public profile and needs no Meta app, access token or Instagram login.

Why does the YouTube subscriber count look rounded?

YouTube only publishes abbreviated subscriber counts, and its own Data API rounds subscriberCount down to three significant figures. We return the parsed integer in subscriber_count and the original text in subscriber_count_text.

Can I get the list of someone's followers?

No. Follower lists aren't visible to logged-out visitors, so the profile endpoints return the count only. Private accounts return their public fields and is_private: true, never posts or followers.

Does checking the same profile twice cost two credits?

Not if you pass cache_days. A stored result inside your window is returned for 0 credits. Without cache_days, every request fetches live data and is charged.