DEV Community: Lucio

Instagram Reels & Audio API Tutorial: Scrape Reels, Tracks & Comments

Lucio — Tue, 09 Jun 2026 04:26:48 +0000

Originally published on our blog.

Instagram Reels & Audio API Tutorial: Scrape Reels, Tracks & Comments

Reels are where Instagram's reach lives now, and that makes them the most interesting surface to analyze: which short videos a creator is publishing, which audio tracks are trending, and how people are reacting in the comments. The problem is that getting at this data is awkward. The official Meta Graph API doesn't expose arbitrary public Reels, and scraping the app yourself means dealing with logins, dynamic rendering, and constant breakage.

In this tutorial we'll use the Instagram Cheapest API on RapidAPI to do three things:

Pull a creator's Reels with user_reels
Find every Reel that uses a particular audio track with reels_audio
Fetch the comments on a specific piece of media with media_comments

We'll do the main flow in Python with requests, then add a short Node.js snippet so you can drop this into a JavaScript backend too. Everything returns raw, real-time JSON.

Prerequisites

Python 3.8+ (pip install requests), and optionally Node.js 18+ for the JS snippet
A RapidAPI account and a subscription to the Instagram Cheapest API. The Basic plan is free (30 calls/month) — enough to work through this guide.

Every request uses two headers:

x-rapidapi-key: your RapidAPI key
x-rapidapi-host: instagram-cheapest.p.rapidapi.com

The base URL is https://instagram-cheapest.p.rapidapi.com and all endpoints are GET under /api/v1/instagram.

Step 0: A reusable client

import requests
import json

API_KEY = "YOUR_RAPIDAPI_KEY"
HOST = "instagram-cheapest.p.rapidapi.com"
BASE_URL = f"https://{HOST}/api/v1/instagram"

HEADERS = {
    "x-rapidapi-key": API_KEY,
    "x-rapidapi-host": HOST,
}


def get(path, params=None):
    resp = requests.get(f"{BASE_URL}/{path}", headers=HEADERS,
                        params=params, timeout=30)
    resp.raise_for_status()
    return resp.json()

Keep the timeout generous. This API serves live, uncached data, so calls take a real round trip to Instagram — don't set an aggressive 2-second timeout and wonder why requests fail.

A note on user IDs

Like the posts endpoint, the Reels endpoint identifies a creator by numeric user_id, not username. If you only have a handle, resolve it first. The userinfo endpoint (/api/v1/instagram/user/{username}) returns the profile, and the numeric ID is in that payload. There's also username_by_uid for going from an ID back to a handle. Print the profile JSON and pull the ID field you see there:

def get_user_id(username):
    profile = get(f"user/{username}")
    # Inspect the printed profile to confirm the exact key.
    return profile.get("id") or profile.get("pk")

From here on we work with that numeric ID.

Step 1: Fetch a creator's Reels with `user_reels`

user_reels takes user_id as a query parameter:

def get_reels(user_id):
    return get("user_reels", params={"user_id": user_id})


user_id = get_user_id("nike")
reels = get_reels(user_id)

# Always inspect the shape before iterating.
print(json.dumps(reels, indent=2)[:2000])

The response is raw JSON, so look at what comes back before assuming a structure. Reels responses are usually a collection of media objects — possibly at the top level, possibly nested under a key like items or data. Each Reel object typically carries a shortcode, a caption, a video URL or thumbnail, play/like/comment counts, and often a reference to the audio track it uses.

Iterate defensively and pull only fields you've confirmed exist:

def iter_reels(reels_response):
    items = reels_response if isinstance(reels_response, list) else (
        reels_response.get("items") or reels_response.get("data") or []
    )
    for reel in items:
        yield {
            "code": reel.get("code") or reel.get("shortcode"),
            "caption": reel.get("caption"),
            "plays": reel.get("play_count") or reel.get("view_count"),
            "likes": reel.get("like_count"),
            "comments": reel.get("comment_count"),
        }


for reel in iter_reels(reels):
    print(reel)

The point of using .get() everywhere and falling back across container keys is resilience: Instagram's payloads evolve, and you want your loop to keep running rather than crash on a renamed field.

Step 2: Find Reels by audio track with `reels_audio`

This is the fun one. Trending audio drives Reels distribution, so being able to list every Reel using a given track is genuinely useful for trend analysis. The reels_audio endpoint takes an audio_id query parameter:

def get_reels_by_audio(audio_id):
    return get("reels_audio", params={"audio_id": audio_id})

Where do you get an audio_id? In practice you discover it from a Reel you already fetched in Step 1 — many Reel objects include the audio/music metadata, and the track's numeric ID is in there. Inspect a Reel object to locate it, then feed it back in:

# Suppose you spotted an audio id while inspecting a reel object.
audio_id = "1234567890"  # replace with one you found in the Reels payload
audio_reels = get_reels_by_audio(audio_id)
print(json.dumps(audio_reels, indent=2)[:2000])

The response is, again, a collection of Reels — this time the ones sharing that track. Reuse the same iter_reels helper to walk it. This lets you answer questions like "how many creators are riding this sound?" or "what's the engagement spread on Reels using this track?"

Step 3: Pull engagement with `media_comments`

To go beyond counts and read actual audience reaction, use media_comments. Note this endpoint identifies media by its shortcode (code), not a numeric ID:

def get_comments(code):
    return get("media_comments", params={"code": code})


# Use a code you pulled from a reel or post earlier.
code = "CxAmPLe123"  # replace with a real shortcode from your data
comments = get_comments(code)
print(json.dumps(comments, indent=2)[:2000])

Comment payloads are typically a list of comment objects, each generally including the comment text, a like count, and some author info. As always, confirm the keys against your printed output:

def iter_comments(comments_response):
    items = comments_response if isinstance(comments_response, list) else (
        comments_response.get("comments")
        or comments_response.get("items")
        or comments_response.get("data") or []
    )
    for c in items:
        yield {
            "text": c.get("text"),
            "likes": c.get("comment_like_count") or c.get("like_count"),
        }


for c in iter_comments(comments):
    print(c)

Chaining these three endpoints — Reels → audio → comments — gives you a full engagement picture for a creator or a trend without ever touching a headless browser.

Error handling

Wrap calls so a bad shortcode, expired key, or rate limit doesn't take down your job:

def safe_get(path, params=None):
    try:
        resp = requests.get(f"{BASE_URL}/{path}", headers=HEADERS,
                            params=params, timeout=30)
        resp.raise_for_status()
        return resp.json()
    except requests.exceptions.HTTPError as e:
        code = e.response.status_code
        if code == 404:
            print(f"Not found: {path}")
        elif code in (401, 403):
            print("Auth error — check your x-rapidapi-key.")
        elif code == 429:
            print("Rate limited — back off or upgrade your tier.")
        else:
            print(f"HTTP {code}: {e}")
    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")
    return None

Mind the rate limits when looping over many Reels or comment threads — the free Basic tier allows 1 request/second, so pace your calls accordingly.

The same flow in Node.js

If your stack is JavaScript, here's the user_reels call using the built-in fetch (Node 18+). The headers and query-param pattern are identical:

const HOST = "instagram-cheapest.p.rapidapi.com";
const API_KEY = "YOUR_RAPIDAPI_KEY";

async function getReels(userId) {
  const url = new URL(`https://${HOST}/api/v1/instagram/user_reels`);
  url.searchParams.set("user_id", userId);

  const resp = await fetch(url, {
    headers: {
      "x-rapidapi-key": API_KEY,
      "x-rapidapi-host": HOST,
    },
  });

  if (!resp.ok) {
    throw new Error(`Request failed: ${resp.status}`);
  }
  return resp.json();
}

getReels("13460080")
  .then((data) => console.log(JSON.stringify(data, null, 2)))
  .catch(console.error);

Same two headers, same query parameter, same raw JSON back. Swap the path for reels_audio?audio_id=... or media_comments?code=... to hit the other endpoints.

Bandwidth tip

Reels and comment payloads can get chunky. Every endpoint supports an optional fields parameter so you can request only the JSON fields you need and shrink the response. Each tier includes 10 GB/month (then $0.001/MB), so trimming payloads with fields is the easiest way to stay inside the allowance when you're pulling Reels in bulk.

A quick word on cost

Pricing here is per request and deliberately low: from $0.10 per 1,000 requests on the top Mega tier, $0.11 on Ultra, and $0.13 on Pro, with a free Basic tier (30 calls/month) for testing. Because a single trend analysis can chain many calls — Reels, then audio, then comments — that low per-request cost adds up in your favor. Pair it with the fields parameter to keep bandwidth in check and Reels analytics stays cheap even at volume.

Conclusion

You've now got a complete Reels workflow: list a creator's Reels with user_reels, pivot on a trending track with reels_audio, and read the room with media_comments — in both Python and Node.js. The recurring discipline is the same as with any raw-JSON API: print the response, confirm the field names, and iterate generically so your code survives Instagram's inevitable payload tweaks.

Start building with the free tier today:

Get the Instagram Cheapest API on RapidAPI →

Compliance note: this API returns public Instagram data only. You are responsible for complying with Instagram's terms and applicable privacy law (GDPR/CCPA). It is not affiliated with or endorsed by Meta/Instagram.

The Cheapest Instagram API in 2026: A Real Cost Breakdown

Lucio — Tue, 09 Jun 2026 04:26:16 +0000

Originally published on our blog.

The Cheapest Instagram API in 2026: A Real Cost Breakdown

If you're building anything that touches public Instagram data at scale — influencer discovery, competitor tracking, social analytics, lead enrichment — the line item that quietly kills your margins is the data API. Per-record pricing on the big providers looks small until you multiply it by a few hundred thousand profiles a month.

This post is a straight cost analysis, not a sales pitch. We'll break down the per-request pricing of the Instagram Cheapest API on RapidAPI across its four tiers, work through a realistic 100,000-requests/month example, show how the fields parameter keeps bandwidth costs near zero, and compare honestly against Bright Data, Apify, EnsembleData, and the Meta Graph API.

How the pricing is structured

Instagram Cheapest uses RapidAPI's standard tier model: a flat monthly fee that includes a quota, plus a per-request overage rate beyond it. Every tier includes 10 GB of bandwidth per month, after which it's billed at $0.001/MB. All endpoints are GET requests returning raw JSON.

Here are the four tiers:

Tier	Monthly	Per request (overage)	Cost per 1,000 requests	Rate limit	Bandwidth incl.
Basic	$0	— (hard cap 30 req/mo)	—	1 req/sec	10 GB (+$0.001/MB)
Pro	$59	$0.00013/req	$0.13	20 req/min	10 GB (+$0.001/MB)
Ultra	$119	$0.00011/req	$0.11	40 req/min	10 GB (+$0.001/MB)
Mega ⭐	$249	$0.0001/req	$0.10	120 req/min	10 GB (+$0.001/MB)

Two things stand out. First, the free Basic tier gives you 30 calls a month — not an expiring trial, but a standing allowance to test integration before you pay a cent. Second, the per-request cost drops as you scale up: from $0.13 per 1,000 on Pro down to $0.10 per 1,000 on Mega. That's the opposite of the trap where heavier usage gets punished with higher unit prices.

Reading the rate limits

The rate limit is about throughput, not total cost. Basic is 1 request/second; Pro allows 20 requests/minute, Ultra 40/minute, and Mega 120/minute. For a bulk enrichment job, the Mega tier's 120 req/min is what lets you actually move volume.

Worked example: 100,000 requests per month

Let's price a concrete workload: a social analytics tool making 100,000 requests/month. We'll compute request cost on each paid tier (bandwidth is handled separately below, since it depends heavily on the fields parameter).

The math is the monthly base fee plus the per-request rate times your request count. Here's the simplest apples-to-apples view using each tier's published per-1,000 rate:

Pro at $0.13 / 1,000 → 100,000 requests ≈ $13 in request cost (on top of the $59 base)
Ultra at $0.11 / 1,000 → 100,000 requests ≈ $11 in request cost (on top of the $119 base)
Mega at $0.10 / 1,000 → 100,000 requests ≈ $10 in request cost (on top of the $249 base)

For a pure 100k workload, the Pro tier's lower base fee makes it the cheapest entry point. The higher tiers earn their base fee through faster rate limits and a lower marginal rate — which is what you want once volume climbs into the millions and the $0.10 vs $0.13 per-1,000 gap dominates. The decision rule: pick the tier by your throughput and total volume, then let the declining per-request rate reward you as you grow.

The hidden cost: bandwidth (and how `fields` kills it)

Per-request pricing is only half the story. Every tier includes 10 GB/month of bandwidth, and beyond that you pay $0.001/MB. Instagram profile and media payloads are verbose raw JSON — full of URLs, nested objects, and metadata you frequently don't need. Pull complete payloads on 100,000+ calls and you can chew through 10 GB faster than you'd expect, turning overage bandwidth into a quiet second bill.

This is exactly what the fields parameter is for. It's an optional query parameter on every endpoint that lets you request only the JSON fields you actually need. Building a follower-count tracker? Ask for the username and follower count, nothing else. The response shrinks dramatically, and so does your bandwidth.

A rough sense of the impact: if trimming responses with fields cuts your average payload from tens of kilobytes down to a few hundred bytes, a workload that might have flirted with the 10 GB ceiling stays comfortably inside the included allowance — meaning $0 in bandwidth overage. The provider even publishes a tutorial on this ("How to use the fields parameter to reduce bandwidth usage"). It costs you nothing but a query parameter.

The takeaway: your real monthly cost is request cost + bandwidth overage, and fields drives the second term to zero.

Honest comparison with the alternatives

No tool is right for every job. Here's how Instagram Cheapest stacks up against common alternatives, using verifiable cost figures rather than superlatives.

vs. Bright Data

Bright Data's Instagram Scraper API runs around $1.50 per 1,000 records, and its pre-collected datasets are roughly $2.50 per 1,000. It's an enterprise-grade platform with broad compliance tooling and massive proxy infrastructure. But on pure cost-per-record, Instagram Cheapest at $0.10–$0.13 per 1,000 is roughly 10–15× cheaper. If cost-per-record is your binding constraint, that gap is decisive.

vs. Apify

Apify uses pay-per-result actor pricing — you're billed by the results each scraper actor returns, plus platform compute. It's flexible and has a large actor marketplace, great when you need custom scraping logic. The trade-off is that result-based pricing plus compute is harder to predict than a flat per-request rate, and for straightforward profile/media/Reels pulls the simple per-request model here is both cheaper and easier to forecast.

vs. EnsembleData

EnsembleData targets the enterprise tier — for example, a Platinum plan around $1,400/month for roughly 50,000 units/day. If you need that scale and the surrounding support, it's a serious option. But for an indie developer or startup that just needs affordable real-time public data, paying four figures a month is hard to justify when the same core data is available per-request for cents per thousand.

vs. the Meta Graph API

The official Meta Graph API is the "correct" path, but it comes with real constraints: it primarily serves accounts you own or business/creator accounts you manage, with app review, permissions, and access-token overhead. It's not designed for ad-hoc lookups of arbitrary public profiles. Instagram Cheapest fills that gap — quick, real-time access to public profiles, posts, Reels, and comments by username or ID — while you stay responsible for using only public data in line with Instagram's terms.

Versus other RapidAPI scrapers

Plenty of other Instagram APIs on RapidAPI start at $10–$30/month, which can look cheaper at the entry point. The catch is the marginal rate: a low monthly fee with a high per-request cost escalates quickly once you're past the included quota. Instagram Cheapest is designed around that marginal rate — as low as $0.10 per 1,000 requests — which is what matters as usage grows.

So which should you choose?

A quick decision guide:

Testing or prototyping? Start on the free Basic tier (30 calls/month). Zero commitment.
A real product up to a few hundred thousand calls/month? Pro ($59) is the cheapest practical entry, and you can move up without re-integrating.
Bulk pipelines or millions of requests? Ultra ($119) or Mega ($249) — the lower per-request rate and higher rate limits pay for themselves at volume.
Always: use the fields parameter from day one to keep bandwidth inside the 10 GB allowance.

The throughline is predictability. You pay a known per-request rate, you control payload size (and therefore bandwidth) with fields, and you get real-time, uncached, raw JSON with no middleman cache. For cost-sensitive teams building on public Instagram data in 2026, that combination is hard to beat.

Conclusion

When you run the numbers, the case is straightforward: at $0.10–$0.13 per 1,000 requests, Instagram Cheapest is roughly an order of magnitude cheaper per record than enterprise scrapers like Bright Data, more predictable than result-based pricing, and far more accessible than four-figure plans or the gated Meta Graph API. Add the fields parameter to neutralize bandwidth costs, and your all-in spend stays remarkably low.

See the live tiers and start on the free plan:

View pricing and get started on RapidAPI →

Compliance note: this API returns public Instagram data only. You are responsible for complying with Instagram's terms and applicable privacy law (GDPR/CCPA). It is not affiliated with or endorsed by Meta/Instagram. Competitor pricing figures are approximate and current as of mid-2026; verify against each provider's live pricing before deciding.

Get Instagram Profile Data with an API in Python (Followers, Bio, Posts)

Lucio — Tue, 09 Jun 2026 04:18:26 +0000

Originally published on our blog.

Get Instagram Profile Data with an API in Python (Followers, Bio, Posts)

If you've ever tried to pull a public Instagram profile programmatically, you know the pain. The official Meta Graph API only works for accounts you own (or business accounts you manage through the platform), and rolling your own scraper means fighting login walls, rotating proxies, and parsing brittle HTML that breaks every few weeks.

This tutorial takes a different route. We'll use the Instagram Cheapest API on RapidAPI to fetch a public profile — follower count, bio, and metadata — and then pull that same user's recent posts. Everything is plain Python with requests, real-time JSON, and no scraping infrastructure to maintain.

By the end you'll have a small, reusable client that:

Looks up a profile by username
Extracts the numeric user_id from the profile
Uses that ID to fetch the user's media
Handles errors and trims bandwidth with the fields parameter

Prerequisites

You'll need:

Python 3.8+ and the requests library (pip install requests)
A free RapidAPI account
A subscription to the Instagram Cheapest API — the Basic plan is free and gives you 30 calls a month, which is plenty to follow along

Once subscribed, grab your x-rapidapi-key from the RapidAPI dashboard. Every request needs two headers:

x-rapidapi-key: your personal key
x-rapidapi-host: instagram-cheapest.p.rapidapi.com

Step 1: Set up the client

Let's start with the connection boilerplate. The base URL is https://instagram-cheapest.p.rapidapi.com and all endpoints are GET requests under the /api/v1/instagram path.

import requests

API_KEY = "YOUR_RAPIDAPI_KEY"  # keep this in an env var in production
HOST = "instagram-cheapest.p.rapidapi.com"
BASE_URL = f"https://{HOST}/api/v1/instagram"

HEADERS = {
    "x-rapidapi-key": API_KEY,
    "x-rapidapi-host": HOST,
}


def get(path, params=None):
    """Thin GET wrapper with basic error handling."""
    url = f"{BASE_URL}/{path}"
    resp = requests.get(url, headers=HEADERS, params=params, timeout=30)
    resp.raise_for_status()  # raises on 4xx/5xx
    return resp.json()

A note on the timeout: this API returns real-time, uncached data straight from Instagram, so responses are not instant. Give each call a generous timeout (30 seconds here) rather than letting it hang or fail prematurely.

Step 2: Fetch the profile with `userinfo`

The userinfo endpoint takes the username as a path parameter — it's the one endpoint that doesn't use a query string. The path is /api/v1/instagram/user/{username}.

def get_profile(username):
    return get(f"user/{username}")


profile = get_profile("nike")
print(profile)

Print the raw response first. The API returns raw JSON — exactly what Instagram returns — so the cleanest way to learn the shape is to inspect it directly rather than trust a field name you read in a blog post (including this one). Pretty-print it so you can scan the keys:

import json
print(json.dumps(profile, indent=2)[:2000])

Look through the output for the values you care about. A public profile payload like this typically includes the account's numeric user ID, the follower and following counts, the full name, the biography text, and whether the account is verified or private. The exact key names and nesting are whatever Instagram itself uses, so confirm them against your printed output before hardcoding them.

Once you've identified the keys, pull them out defensively with .get() so a missing field returns None instead of throwing a KeyError:

def extract_summary(profile):
    # Adjust these keys to match what you actually see in the printed JSON.
    return {
        "user_id": profile.get("id") or profile.get("pk"),
        "username": profile.get("username"),
        "full_name": profile.get("full_name"),
        "followers": profile.get("follower_count"),
        "bio": profile.get("biography"),
    }

This is the honest way to work with any third-party JSON API: read the real response, then map fields. Don't assume.

Step 3: Get the numeric user_id

Here's the key thing that trips people up: the posts and Reels endpoints don't accept a username — they need the numeric user_id. So your workflow is almost always two-step: resolve username → ID, then use the ID everywhere else.

You usually already have the ID from the userinfo response in Step 2. But if you only have a numeric UID and need to go the other way — ID back to username — the API gives you username_by_uid:

def get_username(uid):
    return get("username_by_uid", params={"uid": uid})


# Example: resolve a username from a numeric UID
print(get_username("13460080"))

There's also user_by_user_id if you want the full profile starting from an ID instead of a username:

def get_profile_by_id(user_id):
    return get("user_by_user_id", params={"user_id": user_id})

For our flow, we'll just reuse the ID we already extracted from the profile.

Step 4: Fetch the user's posts with `user_media`

Now we use the numeric ID with user_media, which takes user_id as a query parameter:

def get_user_media(user_id):
    return get("user_media", params={"user_id": user_id})


summary = extract_summary(profile)
user_id = summary["user_id"]

media = get_user_media(user_id)
print(json.dumps(media, indent=2)[:2000])

Again, inspect the structure before iterating. Media responses are typically a list of post objects (sometimes nested under a key like items or data). Each post object generally carries things like a shortcode, caption, media type (image/video/carousel), and per-post engagement counts. Iterate generically and guard each field:

def iter_posts(media_response):
    # The list might be at the top level or under a key — check your output.
    items = media_response if isinstance(media_response, list) else (
        media_response.get("items") or media_response.get("data") or []
    )
    for post in items:
        yield {
            "code": post.get("code") or post.get("shortcode"),
            "caption": post.get("caption"),
            "likes": post.get("like_count"),
            "comments": post.get("comment_count"),
        }


for post in iter_posts(media):
    print(post)

Notice the pattern: we never assume the response shape is fixed. We check whether it's a list or a dict, fall back across likely container keys, and use .get() for every field.

Step 5: Handle errors properly

A production client needs to handle the failures you'll actually hit: a missing username (404), an expired or wrong key (401/403), or rate limiting (429). Wrap the call and branch on the status code:

def safe_get(path, params=None):
    try:
        resp = requests.get(f"{BASE_URL}/{path}", headers=HEADERS,
                            params=params, timeout=30)
        resp.raise_for_status()
        return resp.json()
    except requests.exceptions.HTTPError as e:
        status = e.response.status_code
        if status == 404:
            print(f"Not found: {path}")
        elif status in (401, 403):
            print("Auth problem — check your x-rapidapi-key.")
        elif status == 429:
            print("Rate limited — slow down or upgrade your tier.")
        else:
            print(f"HTTP {status}: {e}")
    except requests.exceptions.RequestException as e:
        print(f"Network/timeout error: {e}")
    return None

The 429 case matters because each plan has a rate limit — the free Basic tier is capped at 1 request/second, so add a small delay if you're looping over many usernames.

Bandwidth tip: use the `fields` parameter

Every endpoint supports an optional fields parameter that lets you request only the JSON fields you actually need. If you're building a "followers count" widget, you don't need the full bio, profile-pic URLs, and every nested object on every call — that's wasted bandwidth.

Each tier includes 10 GB/month, after which you pay $0.001/MB. Trimming responses with fields keeps you comfortably inside that allowance:

# Conceptually: ask for a narrower payload to cut response size.
profile = get("user/nike", params={"fields": "username,follower_count"})

The provider has a dedicated tutorial on this ("How to use the fields parameter to reduce bandwidth usage"). When you're enriching thousands of profiles, narrowing the payload is the single easiest cost lever you have.

A quick word on cost

This API is built around being cheap at scale. Pricing is per request, and the per-1,000 rate drops as you move up tiers: from $0.10 per 1,000 requests on the top (Mega) tier, $0.11 on Ultra, and $0.13 on Pro. The Basic plan is free with 30 calls/month so you can prototype this whole tutorial without paying anything. Combined with the fields trick to stay under the 10 GB bandwidth allowance, profile enrichment pipelines stay genuinely inexpensive.

Conclusion

You now have a clean, two-step pattern for pulling public Instagram profile data in Python: resolve the username to a profile with userinfo, grab the numeric user_id, then fan out to user_media (and other ID-based endpoints) from there. Because the API returns raw, real-time JSON, the golden rule is to print the response and map fields from what you actually see — never from assumptions.

Ready to build? Grab your key and start with the free tier:

Get started with the Instagram Cheapest API on RapidAPI →

Compliance note: this API returns public Instagram data only. You're responsible for complying with Instagram's terms and applicable privacy law (GDPR/CCPA). It is not affiliated with or endorsed by Meta/Instagram.

DEV Community: Lucio

Instagram Reels & Audio API Tutorial: Scrape Reels, Tracks & Comments

Instagram Reels & Audio API Tutorial: Scrape Reels, Tracks & Comments

Prerequisites

Step 0: A reusable client

A note on user IDs

Step 1: Fetch a creator's Reels with user_reels

Step 2: Find Reels by audio track with reels_audio

Step 3: Pull engagement with media_comments

Error handling

The same flow in Node.js

Bandwidth tip

A quick word on cost

Conclusion

The Cheapest Instagram API in 2026: A Real Cost Breakdown

The Cheapest Instagram API in 2026: A Real Cost Breakdown

How the pricing is structured

Reading the rate limits

Worked example: 100,000 requests per month

The hidden cost: bandwidth (and how fields kills it)

Honest comparison with the alternatives

vs. Bright Data

vs. Apify

vs. EnsembleData

vs. the Meta Graph API

Versus other RapidAPI scrapers

So which should you choose?

Conclusion

Get Instagram Profile Data with an API in Python (Followers, Bio, Posts)

Get Instagram Profile Data with an API in Python (Followers, Bio, Posts)

Prerequisites

Step 1: Set up the client

Step 2: Fetch the profile with userinfo

Step 3: Get the numeric user_id

Step 4: Fetch the user's posts with user_media

Step 5: Handle errors properly

Bandwidth tip: use the fields parameter

A quick word on cost

Conclusion

Step 1: Fetch a creator's Reels with `user_reels`

Step 2: Find Reels by audio track with `reels_audio`

Step 3: Pull engagement with `media_comments`

The hidden cost: bandwidth (and how `fields` kills it)

Step 2: Fetch the profile with `userinfo`

Step 4: Fetch the user's posts with `user_media`

Bandwidth tip: use the `fields` parameter