# Instagram Following API (https://www.socialcrawl.dev/platforms/instagram/following)

> Returns a paginated list of the accounts an Instagram user follows. Each account 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 that follows nobody 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 following 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/following` 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/following" \
  --data-urlencode "handle=mrbeast" \
  -H "x-api-key: sc_YOUR_API_KEY"
```

## FAQ

### How do I get the accounts an Instagram user follows via API?

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

### Can I query the following list by user ID?

Yes. Pass user_id instead of handle. user_id is faster because SocialCrawl does not need to resolve the username to an ID before pulling the following list.

### How do I paginate the full following list?

The response returns a cursor. Send it back as the cursor parameter on your next call to get the next page, and repeat until the cursor is empty.

### How much does the Instagram Following API cost?

Each request costs 5 credits on the advanced tier for one page of accounts. New accounts start with 100 free credits and no credit card is required to try it.

### What is the following list useful for?

The following graph reveals interests and affinities: see which brands or creators a prospect follows for lead scoring, competitor research, or influencer-fit checks.

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 to fetch the accounts an Instagram profile follows with an API
- API to see which brands an Instagram user follows for lead scoring