How to scrape Instagram followers and export them to CSV
Updated
To scrape Instagram followers, page through a public account's follower list with an API, then look up each follower's profile to get the bio, links, counts and account type that the list itself leaves out. Bridgly does both with one API key and no Instagram login. Exporting 10,000 followers takes 1,000 requests, which costs $1.67 to $2.00 depending on how many credits you buy.
Get 100 free credits with a business email, no card required. That covers an export of 1,000 followers, or a first test run of the script below.
A follower list on its own is a column of usernames. It becomes useful once you know which followers are businesses, which are creators, where they are based and how to reach them. This guide builds that in one TypeScript script: it exports the followers of a public account, looks up each public follower, sorts them into segments, adds the country for the accounts worth contacting, and writes a CSV you can open in Excel, Google Sheets or your CRM.
People use the result to build lead lists from the audience of a competitor or a niche account, to find creators who already follow a brand, and to check the audience of an influencer before paying for a sponsorship.
Four ways to get an Instagram follower list
| Method | Whose followers | Uses your Instagram login | What you get |
|---|---|---|---|
| Instagram's Download your information | Your own account only | Yes | A file with the usernames of your followers and the accounts you follow |
| Browser extensions, such as Lection | Public accounts, and private ones you follow | Yes, the session in your browser | CSV, Excel or JSON with username, name and private and verified flags |
| No-code cloud tools, such as PhantomBuster and Apify Actors | Public accounts | PhantomBuster: yes, your session cookie. Many Apify Actors: no | CSV or JSON files on a schedule |
| Social data APIs, such as Bridgly and HikerAPI | Public accounts | No | JSON in your own code, with profile lookups on the same key |
Instagram's own export is free and complete, but it only covers your account. Meta's official API does not help with anyone else's followers either: Business Discovery returns the follower count of another professional account, not the followers themselves.
Tools that run on your login put your account in the loop. PhantomBuster's guide to its Follower Collector recommends no more than 20 runs a day and warns that large one-off runs can shorten your session. Lection notes that Instagram can rate-limit long exports. An API that reads public data without your account keeps your own Instagram profile out of the job.
What Instagram shows to any tool
Some limits come from Instagram itself, so they apply to every scraper, Bridgly included. Plan for them before you promise anyone a complete list:
- Public accounts only. A private account shows its followers only to the people it has approved.
- Short lists for verified and some business accounts. For these accounts Instagram returns only a first page of followers, without a next page. HikerAPI's docs put it at about 50 accounts for verified profiles, and the Scraping Solutions Actor reports about 25 for verified and some business profiles.
- Counts run higher than lists. The follower count on a profile can include banned and deleted accounts that no longer appear in the list, as PhantomBuster explains. Expect an export to come up somewhat short of the count.
- The list moves while you read it. People follow and unfollow during a long export, which can shift accounts across pages. Remove duplicates by ID, as the script below does.
- The list is thin. Each follower entry has a username, full name, profile picture and private and verified flags. Bios, links, follower counts and the account type come from a separate profile lookup.
The workflow: export, enrich, segment, write a CSV
- Export the follower list of a public account, 10 accounts per request, following
nextCursoruntil the list ends or you have enough. - Drop duplicates and private accounts. This runs on your machine and costs nothing.
- Look up each public follower for the full name, bio, bio links, follower, following and post counts, and whether the account is verified, a business or a professional account, with its category.
- Sort each profile into a segment: business, creator, personal, or no posts.
- Read About this account for the business and creator accounts only, to add the country they are based in.
- Write one row per follower to a CSV and print a summary of the audience.
Set up
You need Node.js and a Bridgly API key. Create a free account, copy a key from the dashboard, and install the TypeScript SDK:
npm install @bridgly/sdknpm install --save-dev tsxexport BRIDGLY_API_KEY=bgly_...The script
Save this as instagram-followers.mts and run it with an account and the number of followers you want, for example npx tsx instagram-followers.mts natgeo 1000. It writes natgeo-followers.csv with one row per public follower, and natgeo-followers.json with the raw follower list for comparing exports later.
// instagram-followers.mts// Run: npx tsx instagram-followers.mts <account> <how many> [cursor]import { type ApiResult, Bridgly, type InstagramFollowersResponse, type InstagramUserResponse,} from '@bridgly/sdk';import { writeFile } from 'node:fs/promises';type Follower = InstagramFollowersResponse['data']['followers'][number];type Profile = InstagramUserResponse['data'];type Segment = 'business' | 'creator' | 'personal' | 'no posts';type FollowerExport = { followers: Follower[]; /** Where the list continues; null once every follower is collected. */ nextCursor: string | null; credits: number;};type Row = { username: string; profileUrl: string; name: string; segment: Segment; category: string; country: string; followers: number; following: number; posts: number; verified: boolean; website: string; bioEmail: string; bio: string;};const client = new Bridgly({ apiKey: process.env.BRIDGLY_API_KEY ?? '' });const account = process.argv.at(2) ?? 'natgeo';const limit = Number(process.argv.at(3) ?? 1000);const startCursor = process.argv.at(4) ?? null;const EMAIL = /[\w.+-]+@[\w-]+\.[\w.-]+/;/** * Collects up to `limit` followers in batches of 500, so a failed request * loses one batch at most. On a failure it keeps what it has and prints the * cursor to resume from. */async function exportFollowers( username: string, sofar: FollowerExport,): Promise<FollowerExport> { const cursor = sofar.nextCursor ?? undefined; const batch = await client.instagram.getFollowers({ username, cursor, count: Math.min(500, limit - sofar.followers.length), pagination: true, }); if (batch.type === 'error') { if (sofar.followers.length === 0) { throw new Error(`${batch.status} ${batch.message}`); } console.error(`Stopped early: ${batch.message}. Resume with ${cursor}`); return sofar; } const next: FollowerExport = { followers: [...sofar.followers, ...batch.data.followers], nextCursor: batch.data.nextCursor, credits: sofar.credits + batch.creditsCost, }; if (next.nextCursor == null || next.followers.length >= limit) return next; return exportFollowers(username, next);}/** Drops repeats, which appear when the list changes during an export. */function uniqueById(followers: Follower[]): Follower[] { return [...new Map(followers.map((f) => [f.id, f])).values()];}/** Puts a profile in the segment that decides what you do with it. */function segmentOf(profile: Profile): Segment { if (profile.posts_count === 0) return 'no posts'; if (profile.is_business_account) return 'business'; if (profile.is_professional_account) return 'creator'; return 'personal';}/** The first email address written in a bio, or an empty string. */function emailIn(bio: string | null | undefined): string { return bio?.match(EMAIL)?.at(0) ?? '';}/** Credits spent by a set of calls. Failed calls cost nothing. */function creditsOf(results: ApiResult<unknown>[]): number { return results.reduce( (sum, result) => sum + (result.type === 'success' ? result.creditsCost : 0), 0, );}/** Quotes a value so commas, quotes and line breaks stay in one cell. */function csvCell(value: string | number | boolean): string { return `"${String(value).replaceAll('"', '""')}"`;}// 1. Export the follower list, 10 accounts per request.const exported = await exportFollowers(account, { followers: [], nextCursor: startCursor, credits: 0,});const followers = uniqueById(exported.followers);// 2. Look up every public follower. The SDK queues the calls for you.const lookups = await Promise.all( followers .filter((follower) => !follower.is_private) .map((follower) => client.instagram.getUser({ username: follower.username }), ),);const profiles = lookups.flatMap((lookup) => lookup.type === 'success' ? [lookup.data] : [],);// 3. Read "About this account" only for the accounts you may contact.const contactable = profiles.filter((profile) => ['business', 'creator'].includes(segmentOf(profile)),);const abouts = await Promise.all( contactable.map((profile) => client.instagram.getUserAbout({ username: profile.username }), ),);const countries = new Map( abouts.flatMap((about): [string, string][] => about.type === 'success' ? [[about.data.username, about.data.country ?? '']] : [], ),);// 4. Build one row per follower and write the CSV.const rows: Row[] = profiles.map((profile) => ({ username: profile.username, profileUrl: `https://www.instagram.com/${profile.username}/`, name: profile.full_name ?? '', segment: segmentOf(profile), category: profile.category_name ?? '', country: countries.get(profile.username) ?? '', followers: profile.followers, following: profile.following, posts: profile.posts_count, verified: profile.is_verified, website: profile.bio_links.at(0)?.url ?? '', bioEmail: emailIn(profile.biography), bio: profile.biography ?? '',}));const columns: (keyof Row)[] = [ 'username', 'profileUrl', 'name', 'segment', 'category', 'country', 'followers', 'following', 'posts', 'verified', 'website', 'bioEmail', 'bio',];const csv = [ columns.join(','), ...rows.map((row) => columns.map((column) => csvCell(row[column])).join(',')),].join('\n');await writeFile(`${account}-followers.csv`, csv);await writeFile(`${account}-followers.json`, JSON.stringify(followers));// 5. Summarize the audience.const segments: Segment[] = ['business', 'creator', 'personal', 'no posts'];console.table( segments.map((segment) => ({ segment, accounts: rows.filter((row) => row.segment === segment).length, })),);console.log(`Followers exported: ${followers.length}`);console.log(`Private, skipped: ${followers.length - lookups.length}`);console.log(`Rows written: ${rows.length}`);console.log( `Credits used: ${exported.credits + creditsOf(lookups) + creditsOf(abouts)}`,);if (exported.nextCursor != null) { console.log(`More followers remain. Continue with ${exported.nextCursor}`);}How the script works
Export in batches. With pagination: true, the SDK follows the cursor page after page and adds up creditsCost across pages. The script asks for 500 followers at a time, so if a request fails partway through a large export, it keeps everything collected so far and prints the cursor. Pass that cursor as the third argument to continue. Cursors that start with `bridgly_page_` stay valid for a day, so resume the same day.
Enrich in parallel without tripping the limit. The script sends every profile lookup through Promise.all. The SDK sends at most two requests per platform at a time by default, queues the rest, and retries a request rejected with a 429 after the wait the API asks for. Rejected requests cost nothing. If you bought a larger package, raise maxConcurrency in the client options to match your rate limit.
Cached lookups cost nothing. If you call the REST API directly, profile and About requests accept cacheMaxAgeHours. A profile Bridgly fetched within that many hours comes back from the cache at no cost, which helps when you export several accounts whose followers overlap. The API reference lists the cache options.
Segment rules you can change. An account with no posts goes to no posts, whatever its type. Business accounts go to business, other professional accounts to creator, and the rest to personal. Change segmentOf to fit your use, for example to treat personal accounts with more than 10,000 followers as creators.
Contact details come from the bio. The profile response carries the bio and its links but no separate email or phone field today. The script takes the first link as the website and pulls any email address written in the bio, which many business accounts include.
What a run costs on Bridgly
Every Instagram endpoint costs 1 credit per request. The follower list returns up to 10 accounts per request, and a profile or About lookup is one request each. Errors, missing profiles and rate-limited requests cost nothing, and each response reports its exact creditsCost.
Here is a worked example for 1,000 followers, assuming 700 of them are public and 150 of those are business or creator accounts. The export takes 100 credits, the profile lookups 700 and the About lookups 150: 950 credits in total. That is $1.90 on Pay as you go and $1.58 on Scale. Your real numbers depend on how many followers are public.
| Bridgly tier | Price per 1,000 credits | Export 10,000 followers (1,000 credits) | Instagram requests per minute | Fastest time for 1,000 requests |
|---|---|---|---|---|
| Pay as you go, from $5 | $2.00 | $2.00 | 30 | About 34 min |
| Growth, from $50 | $1.82 | $1.82 | 200 | About 5 min |
| Scale, from $300 | $1.67 | $1.67 | 1,000 | About 1 min |
Credits are one-time purchases with no subscription, and purchased credits never expire. Rate limits apply per platform, so an Instagram export does not slow down calls you make to other platforms on the same key. See pricing for every tier.
Bridgly compared with other follower scrapers
This table prices the same job everywhere: export 10,000 followers of a public account, then look up 1,000 of their profiles. Vendor prices come from each vendor’s own pages, checked on November 12, 2026, in USD.
| Option | Export 10,000 followers | Look up 1,000 profiles | Billing | Good to know |
|---|---|---|---|---|
| Bridgly | $1.67 to $2.00 (1,000 requests) | $1.67 to $2.00 | One-time credits from $5 that never expire | No Instagram login. Errors cost nothing. Same key for profiles and About this account. |
| HikerAPI | $0.40 on Standard, $8.00 on Start (about 400 requests) | $1.00 on Standard, $20.00 on Start | Prepaid balance that never expires. Standard needs a $100 balance. | About 25 followers per page. Charges for 400, 403 and 404 responses. |
| Apify: Scraping Solutions followers Actor plus Instagram Profile Scraper | $8.50 on Free, $7.00 on Starter, $6.00 on Business | $2.60 on Free, $2.30 on Starter, $1.60 on Business | Monthly plans from $19, with usage that expires each month | No login. Runs, schedules and exports in the Apify console. |
| PhantomBuster Instagram Follower Collector | Counts against plan hours, not per follower | Through its Instagram Profile Scraper | Plans at $69, $159 and $439 a month | Uses your Instagram session. The free plan exports 10 rows. |
| Instagram's own export | Free, for your own followers only | Not included | Free | Covers your own account only. |
Where the other options are better
- HikerAPI is cheaper for very large exports. Its pages hold about 25 followers against Bridgly's 10, and its Standard rate is $1 per 1,000 requests, so a 10,000-follower export costs about $0.40 there. HikerAPI also returns business contact fields, email and phone, that Bridgly does not return as separate fields today.
- Apify and PhantomBuster run without code. Both schedule runs and hand you a file. PhantomBuster's Watcher mode picks up new followers on each scheduled run, and another Apify Actor's "only new since the last run" option does the same without charging again for followers you already have. With Bridgly you schedule the script yourself and compare exports, as shown below.
- Instagram's export is free. For your own followers it is the complete, official list, with no limits on verified accounts.
Bridgly fits when the follower list feeds code you own: a lead pipeline, an influencer tool, or an AI agent. The export, profile lookups and About this account run on one key, with typed responses and no Instagram account at risk. The same key also covers the other social platforms Bridgly supports, so you can check a lead on another network without a second vendor. For a wider look at Instagram data providers, see the best Instagram APIs compared.
Put the CSV to work
- Lead lists. Filter the
businesssegment bycategoryandcountry, then work through the rows that have awebsiteorbioEmail. The followers of a niche supplier, event or publication are often a ready list of companies in that niche. - Creator outreach. Sort the
creatorsegment byfollowersto find creators who already follow a brand. They know the product, which makes the first message easier. - Audience checks before a sponsorship. Export a sample of an influencer’s followers and look at the share of private accounts and of
no postsaccounts. A high share does not prove the followers are fake, but it is a reason to look closer before you pay. - Competitor audiences. Export the followers of two competitors and find the accounts that follow both. That overlap is an audience that already buys in your category.
Comparing exports takes a few lines. Keep each export as JSON, then compare by follower ID, which stays the same when someone changes their username:
import type { InstagramFollowersResponse } from '@bridgly/sdk';type Follower = InstagramFollowersResponse['data']['followers'][number];/** Followers in `current` who were not in `previous`, e.g. last week's export. */export function newFollowers( previous: Follower[], current: Follower[],): Follower[] { const seen = new Set(previous.map((follower) => follower.id)); return current.filter((follower) => !seen.has(follower.id));}/** Accounts that follow both `a` and `b`, such as two competitors. */export function sharedFollowers(a: Follower[], b: Follower[]): Follower[] { const inB = new Set(b.map((follower) => follower.id)); return a.filter((follower) => inB.has(follower.id));}To check a single account before you run a full export, look it up in the free Instagram profile viewer. AI assistants such as Claude and Cursor can run the same lookups through the Bridgly MCP server, and the CLI writes a page of followers straight to a CSV file.
Start with 100 free credits and run the script on an account you know. Browse every Instagram endpoint, or compare credit packages for larger exports.
Frequently asked questions
Can you export the followers of someone else’s Instagram account?
Yes, if the account is public. A follower scraper or API pages through the list Instagram shows on the profile. Private accounts show their followers only to approved followers, and Instagram’s own data download covers only your own account.
How much does it cost to scrape 10,000 Instagram followers?
On Bridgly, 10,000 followers take 1,000 requests at 1 credit each, which is $2.00 on Pay as you go and $1.67 on Scale. Looking up the full profile of each follower costs 1 more credit per follower.
Why does my export have fewer followers than the profile shows?
Instagram counts some banned and deleted accounts that no longer appear in the list, and for verified and some business accounts it returns only a first page of followers. Accounts that follow or unfollow during the export also change the total.
Do I need an Instagram account to scrape followers?
Not with Bridgly. Requests take a Bridgly API key and the username or profile link, with no Instagram login, cookies or proxies to supply. Browser extensions and tools such as PhantomBuster do run on your Instagram session.
Can I get the email addresses of Instagram followers?
Bridgly returns each follower’s bio and bio links, and the script in this guide pulls any email address written in the bio. Bridgly does not return a separate email or phone field today. HikerAPI returns the public contact fields of business profiles.
Is it safe and legal to scrape Instagram followers?
Bridgly reads public data and never logs in to your Instagram account, so your own profile is not at risk of an action block. Follower lists are personal data, so laws such as the GDPR apply to how you store and use them. Keep only the fields you need and honor opt-out requests. This is not legal advice.
Can I scrape Instagram followers without writing code?
Yes. Connect the Bridgly MCP server to an AI assistant such as Claude or Cursor and ask it to export and sort an account’s followers, or use the Bridgly CLI to save a page of followers as CSV. No-code tools such as Apify and PhantomBuster also export follower lists on a schedule.
Sources
- Bridgly API reference: Instagram followers
- Bridgly docs: rate limits
- HikerAPI: plans and per-request prices
- HikerAPI: follower page size and the limit on verified accounts
- Apify: plans and Store discounts
- Apify: Scraping Solutions Instagram Followers/Following Scraper
- Apify: Instagram Followers & Following Scraper by Instagram Data API
- Apify: Instagram Profile Scraper pricing
- PhantomBuster: plans, limits and pricing
- PhantomBuster: how to use the Instagram Follower Collector
- Lection: Instagram followers exporter
- Meta for Developers: Instagram Business Discovery
- Instagram Help Center: download a copy of your information