# Instagram Followers API (https://www.socialcrawl.dev/platforms/instagram/followers)

> Returns a paginated list of the accounts that follow an Instagram user. Each follower includes username, display name, avatar URL, verification status, and profile URL. Pass either `handle` or `user_id`, and page through with `cursor`. A public account with no followers returns 200 with an empty list and `data.total` 0, not an error, and is not charged. A plain walk can end before the profile's count: on most accounts it ends within a few rows of that count, and on large verified accounts Instagram caps every route at about 50 rows with no cursor, so a plain walk ends there. `data.total` carries the profile's own count on every page, so compare the rows you collected against it. Send `coverage=full` with `handle` to walk a merged list instead: each page is drawn from several reads of the list and carries no account twice inside a page, until the rows reach the count or no read has more. Across consecutive pages a handful of accounts can repeat on the pages one source covered on its own; the merged walk, which never returns an account it has already given you, runs wherever that source cannot cover the list. A full-coverage page costs 10 credits instead of 5 and takes longer, and its cursor only continues a `coverage=full` walk. Send `query` to search inside the list instead of paging it: one window of the accounts in the list whose username or display name contains the query, so the exact username of an account tells you whether it is on the list. An empty list means no account in the list matches. A `query` call has no cursor and no `data.total`, and it cannot be combined with `cursor` or `coverage=full`. On large verified accounts Instagram limits the list and does not search it, so the search runs on the roughly 50 accounts Instagram shows, only the ones that match are returned, and `data._warnings` says so: an account the answer does not return may still be on the list.

TL;DR: `GET /v1/instagram/followers` costs 5 credits a page. Up to three reads are merged into one page, typically about 50 accounts, and a page can carry fewer. With `coverage=full`, up to 10 credits a page, settled down to 5 when the plain walk covered the whole page. A page that fails is refunded. With `query`, 5 credits for its one window, and nothing when no account matches. With `max_pages`, `max_items` or `max_credits`, each page walked is billed at this price (a cached page is free), and `max_credits` caps the total. and returns SocialCrawl's unified JSON schema. Single x-api-key auth, 100 free credits on signup.

## Parameters

| Parameter | Required | Description |
| --- | --- | --- |
| `handle` | no | Instagram username without the @ symbol. |
| `user_id` | no | Instagram numeric user ID. Use this for faster responses. |
| `cursor` | no | Pagination cursor. Use the `next_cursor` from the previous response to fetch the next page. |
| `coverage` | no | Send `full` to walk a merged list: accounts are added from several reads of the list and no account appears twice inside a page, until the rows reach the profile's count in `data.total`. On the pages one source covered on its own a handful of accounts can repeat across consecutive pages; wherever that source cannot cover the list the merged walk runs instead, and it never returns an account it has already given you. Requires `handle`. 10 credits a page instead of 5, settled down to 5 on any page a single read covered in full. Up to three reads are merged into one page, typically about 50 accounts, so a full list costs at most roughly the account count divided by 50, times 10 credits: on 13/09/2026 a following list of 2,652 took 54 pages and a follower list of 2,360 took 59, because the later pages of a follower walk add fewer new accounts. A page usually takes about 8 seconds and can take up to about 45, and a `503` is retried with the same cursor. A cursor from this mode only continues this mode. (full) |
| `query` | no | A username or name to look for in the list. Returns the accounts whose username or display name contains it (ignoring case and accents) in one window with no cursor, at the price of a page, and nothing is charged when no account matches. Cannot be combined with `cursor` or `coverage`. |
| `max_pages` | no | 1 to 50 (default 1, or 50 when `max_items` or `max_credits` is sent). Walk up to this many pages in one call and return the rows from all of them. Each page walked is billed exactly as one call to this endpoint (a cached page is free) and counts against your rate limit; its charge and any refund are recorded under the page's own request id, listed in `data.walk.request_ids`. The walk stops early at the last page, or when the request's time budget runs low; `data.walk.stopped` says why (`end`, `max_pages`, `max_items`, `max_credits`, `time_budget`, `page_error`) and `pagination.next_cursor` continues from where it stopped. |
| `max_items` | no | 1 to 5000. Get more in one call: keep walking pages until the response holds at least this many rows, then stop with `data.walk.stopped: "max_items"`. The last page is returned whole (it was billed), so `data.items` can hold up to one page more than this, and `pagination.next_cursor` resumes right after it without skipping a row. Walks up to 50 pages unless `max_pages` says fewer; each page is billed as one call (a cached page is free). Add `max_credits` to cap the spend. A long walk can stop on the time budget first (`"time_budget"`): send the returned cursor with the same params to continue. |
| `max_credits` | no | 1 to 100000. The most this call may spend, across every page it walks. A page starts only while the credits already spent plus that page's price (or, when higher, the most any page of this walk has cost) still fit, so the call never goes past it; the walk then stops with `data.walk.stopped: "max_credits"` and the cursor to resume. Sent alone, it walks as far as the budget goes (up to 50 pages). A value below the price of one page is a free 400 whose `error.details.page_credits` names that price. Credits a row join (`include=`) adds are known only once a page has run, so page 1 is checked against its own price. |

## Code example

```bash
curl -G "https://www.socialcrawl.dev/v1/instagram/followers" \
  --data-urlencode "handle=mrbeast" \
  -H "x-api-key: sc_YOUR_API_KEY"
```

## FAQ

### How do I get a list of a user's Instagram followers with an API?

Send a GET request to /v1/instagram/followers with a handle or user_id. SocialCrawl returns a JSON array of follower accounts, each with username, display name, avatar URL, verified status, and profile URL.

### Can I look up followers by user ID instead of username?

Yes. Pass user_id instead of handle. Using user_id is faster because SocialCrawl skips the username-to-ID lookup step before fetching the follower list.

### How do I paginate through all of an account's followers?

Each response includes a cursor. Pass that value back as the cursor parameter on the next request to fetch the following page. Keep going until the cursor comes back empty.

### How much does the Instagram Followers API cost per request?

Each call costs 5 credits on the advanced tier and returns one page of followers. New accounts get 100 free credits with no credit card, so you can test before paying.

### What can I build with Instagram follower data?

Follower lists power audience analysis, influencer vetting, and lead generation: map who follows a competitor, score an influencer's real audience, or build prospect lists from a niche account.

See the full Instagram API: https://www.socialcrawl.dev/platforms/instagram

## Pricing

- Standard endpoints: 1 credit per call
- Advanced endpoints: 5 credits per call
- Premium endpoints: 10 credits per call
- 100 free credits on signup, no credit card required. Cached responses cost 0 credits. Credit packs never expire.
- Full pricing: https://www.socialcrawl.dev/pricing

## Explore with AI

Questions this API answers, phrased for an AI assistant:

- How do I get the list of accounts that follow an Instagram user via API?
- Best API to export a competitor's Instagram followers for audience analysis