DEV Community: Intropix-team

How do you check that influencers actually posted the Instagram stories you paid for? (Python)

Intropix-team — Wed, 21 Oct 2026 14:13:39 +0000

The contract said: two stories in launch week, tag the brand, use the link sticker, show the paid partnership label. Checking it meant asking creators for screenshots, which arrived late, cropped, or not at all. And by the time anyone noticed a missing link, the story had expired.

How we solved it

We built the Instagram Stories Scraper on Apify (disclosure: it's ours). It reads a creator's live stories with no Instagram login, and each story comes back with mentions, link_urls, coauthors and is_paid_partnership. Stories last 24 hours, so a run every 12 hours sees each one at least once. The input:

{
  "usernames": ["creator_one", "creator_two", "creator_three"],
  "maxResults": 200
}

maxResults is one total for the run, so set it well above what the creators post in a day; you pay per delivered story, not per slot. Then each story is checked against the brief:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
BRAND, DOMAIN = "yourbrand", "yourbrand.com"

run = client.actor("intropix/instagram-stories-scraper").call(run_input={
    "usernames": ["creator_one", "creator_two", "creator_three"],
    "maxResults": 200})

for s in list(client.dataset(run["defaultDatasetId"]).iterate_items()):
    tagged = BRAND in s["mentions"] or BRAND in s["coauthors"]
    linked = any(DOMAIN in u for u in s["link_urls"])
    labelled = s["is_paid_partnership"] is True
    print(s["username"], s["story_pk"], s["taken_at"],
          "OK" if tagged and linked and labelled else
          f"tagged={tagged} linked={linked} labelled={labelled}")

We append each run's items to a JSONL file, deduplicated on story_pk, and download media_url in the same job, because that link expires with the story.

What came out

A real story item, trimmed (National Geographic, 16-07-2026):

{
  "username": "natgeo",
  "story_pk": "3942549043641043661",
  "taken_at": "2026-07-16T13:28:11Z",
  "expiring_at": "2026-07-17T13:28:11Z",
  "media_type": "image",
  "is_paid_partnership": false,
  "link_urls": [],
  "mentions": ["disneyparks", "disneyland"],
  "coauthors": []
}

Run against the brief, this one would print tagged=False linked=False labelled=False. The per-creator count of OK lines against the contracted number is the report we sent the client.

Cost

Ten creators, two runs a day, 30 stories a day seen twice: 2 x ($0.005 + 10 x $0.002) + 60 x $0.0025 = $0.20 a day.

The caveat

Only live stories are visible. A story posted and deleted between two runs is never seen, and story views and reach are not public, so you still need the creator's own insights for those.

For the feed side of the same check, the paid partnership label on posts and reels, see tracking brand deals with the PRO Instagram Posts & Reels Scraper, or use the standard Instagram Posts & Reels Scraper at $1.90 per 1,000 posts when captions, likes, comments, views, dates and that label are enough.

The full field list, scheduling and CSV export are in How to scrape Instagram stories without login.

How do you audit a competitor's Instagram engagement beyond likes? (shares, reposts and engagement rate in Python)

Intropix-team — Wed, 21 Oct 2026 14:13:15 +0000

Our competitor audits used to stop at likes, because likes are the number on every post. But likes scale with follower count and say nothing about whether anyone passed a post on. We wanted to know, for two competing brands: which format works, which posts get shared, and what they pin or hide.

How we solved it

We built the PRO Instagram Posts & Reels Scraper on Apify (disclosure: it's ours). Next to likes and views it returns engagement_rate, share_count, repost_count, is_pinned, caption_edited and is_off_grid, with no Instagram login. The input per brand, with reels that are off the grid but still public on the reels tab:

{
  "usernames": ["nike"],
  "maxPosts": 50,
  "includeOffGridReels": true
}

maxPosts is one budget per run, spent account by account in input order, so one brand per run:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
posts = []
for brand in ["nike", "adidas"]:
    run = client.actor("intropix/instagram-posts-reels-scraper-pro").call(run_input={
        "usernames": [brand], "maxPosts": 50, "includeOffGridReels": True})
    posts += list(client.dataset(run["defaultDatasetId"]).iterate_items())

df = pd.DataFrame(posts)
print(df.groupby(["username", "post_type"])[
    ["engagement_rate", "view_count", "share_count", "repost_count"]].median())
print(df.groupby("username")[["is_pinned", "is_off_grid", "caption_edited"]].sum())

Medians, not means: one viral reel drags a mean across the chart.

What came out

The metric half of a real Red Bull reel (17-10-2026):

{
  "follower_count": 34172188,
  "post_type": "reel",
  "like_count": 46317,
  "comment_count": 344,
  "view_count": 1588744,
  "share_count": 3450,
  "repost_count": 937,
  "engagement_rate": 0.001365,
  "is_pinned": false,
  "is_off_grid": false
}

0.001365 is 0.14%; accounts with tens of millions of followers often sit below 1%, so compare brands of similar size. The first table answers the format question, the second shows how much each brand pins, keeps off the grid, or rewrites after posting.

Cost

Each brand at 50 posts is $0.005 + $0.002 + 50 x $0.0039 = $0.202, so $0.404 for the pair. Off-grid reels bill as ordinary posts inside the same maxPosts.

The caveat

Every count is a snapshot. A post from this morning has not finished collecting likes, so leave the newest day or two out. When an owner hides counts, counts_hidden is true and the numbers are null. Photos and carousels have no view count at all.

To try it without code, the Audit a competitor's Instagram engagement task runs the PRO Instagram Posts & Reels Scraper on one account. If likes, comments, views and dates are enough, the standard Instagram Posts & Reels Scraper does it at $1.90 per 1,000 posts.

The rest is in the PRO actor overview.

How do you map where a brand's Instagram posts were taken? (venue and coordinates to GeoJSON)

Intropix-team — Wed, 21 Oct 2026 14:12:52 +0000

An event brand wanted to see its own footprint for September: which venues it posted from, and whether those posts did better than the rest. Instagram shows the location tag one post at a time, under the handle. We wanted all of them as points on a map.

How we solved it

We built the PRO Instagram Posts & Reels Scraper on Apify (disclosure: it's ours). Every post carries location_name, location_id, location_city, location_lat and location_lng, null when there is no tag, and it needs no Instagram login. One brand, one month:

{
  "usernames": ["redbull"],
  "maxPosts": 200,
  "sinceDate": "2026-09-01",
  "untilDate": "2026-09-30"
}

The date window decides what comes back; maxPosts is only a ceiling. Then the located posts become GeoJSON, which opens in QGIS, kepler.gl or geojson.io. Note the longitude, latitude order:

import json
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("intropix/instagram-posts-reels-scraper-pro").call(run_input={
    "usernames": ["redbull"], "maxPosts": 200,
    "sinceDate": "2026-09-01", "untilDate": "2026-09-30"})
posts = list(client.dataset(run["defaultDatasetId"]).iterate_items())

features = [{
    "type": "Feature",
    "geometry": {"type": "Point",
                 "coordinates": [p["location_lng"], p["location_lat"]]},
    "properties": {"venue": p["location_name"], "post": p["permalink"],
                   "likes": p["like_count"], "views": p["view_count"]},
} for p in posts if p["location_lat"] is not None]

with open("locations.geojson", "w") as f:
    json.dump({"type": "FeatureCollection", "features": features}, f)
print(len(features), "of", len(posts), "posts carry a location")

What came out

A real Red Bull reel from 17-10-2026, with the location fields:

{
  "permalink": "https://www.instagram.com/p/DekxytFz6gm/",
  "post_type": "reel",
  "view_count": 1588744,
  "location_name": "Cypress Mountain",
  "location_id": "415790",
  "location_city": null,
  "location_lat": 49.39541,
  "location_lng": -123.20219
}

Note the null city next to real coordinates. That is normal, so we plot from the coordinates and treat the city as a label. For one marker per venue, group on location_id, not the name, since venue names are not unique.

Cost

A month with 100 posts is $0.005 + $0.002 + 100 x $0.0039 = $0.397. Posts without a location are billed too; there is no "located only" filter.

The caveat

Only tagged posts have a location, and it is the venue the publisher picked, not where the camera was. A city-wide tag is one point for the whole city. Keep this at brand and venue level: our Terms prohibit using location data to infer where a person is.

To try it without code, the Map where a brand's Instagram posts were taken task runs the PRO Instagram Posts & Reels Scraper on one account. If captions, likes, comments, views and dates are all you need, without the location fields, the standard Instagram Posts & Reels Scraper returns those at $1.90 per 1,000 posts.

Field list, pricing and n8n or MCP setup are in the PRO actor overview.

How do you get Instagram business account details and contacts for a lead list? (Python, and the GDPR part)

Intropix-team — Wed, 21 Oct 2026 14:12:29 +0000

We had a list of a few hundred Instagram handles in one niche and needed, for each: is it a business, what category does it show, what is its website, and is there a public email or phone. The manual version is opening every profile and copying from the contact button into a sheet.

How we solved it

We built the PRO Instagram Posts & Reels Scraper on Apify (disclosure: it's ours). Every post it returns carries the account's profile fields, so one post per account is enough for one lead row, with no Instagram login. The input, one post per account:

{
  "usernames": ["redbull", "dennikn", "heineken"],
  "maxPostsPerAccount": 1
}

maxPostsPerAccount gives every handle its own allowance, so the whole list is one run. Plain maxPosts: 1 would deliver one post in total: maxPosts is one budget per run, spent account by account in input order.

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
COLS = ["username", "owner_account_type", "owner_category", "follower_count",
        "owner_website", "owner_public_email", "owner_public_phone"]
run = client.actor("intropix/instagram-posts-reels-scraper-pro").call(
    run_input={"usernames": ["redbull", "dennikn", "heineken"], "maxPostsPerAccount": 1})
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

leads = pd.DataFrame(rows, columns=COLS)
leads = leads[leads["owner_account_type"].isin(["business", "creator"])]
leads.to_csv("instagram_leads.csv", index=False)

What came out

One row per account. The Red Bull row, from a real item on 17-10-2026:

{
  "username": "redbull",
  "owner_account_type": "business",
  "owner_category": null,
  "follower_count": 34172188,
  "owner_website": "https://onein.bio/redbull",
  "owner_public_email": "info@redbull.com",
  "owner_public_phone": null
}

owner_bio_links, owner_post_count, owner_city and owner_address are there too if you want them.

Cost

Each handle is $0.002 + $0.0039 = $0.0059, plus $0.005 once for the run, so 200 handles in one run are $0.005 + 200 x $0.0059 = $1.185. Handles that do not resolve cost nothing. A run holds up to 1,000 posts on a paid plan (10 on the free plan), so split a longer list into several runs.

The caveat

Contact fields are only what the profile shows publicly. An account that hides its email gets null even if Instagram stores one, so expect plenty of nulls. A business with no posts gives no row, because the row rides on a post.

Responsible use

A public business email can still belong to a named person. You are the data controller for what you collect, so you need your own lawful basis, worked out for your use case. Our Terms limit the actor to business, creator and brand accounts, prohibit using delivered contacts to reach private individuals or for unsolicited marketing where the recipient's country requires consent, and ask you to keep results only as long as the purpose needs (30 days as a guideline). Say where you found the address, and honour opt-outs. This is not legal advice.

To try it without code, the Instagram business account details and contacts task runs the PRO Instagram Posts & Reels Scraper on one account (run one account per run for a list). If captions, likes, comments, views and dates are all you need, without the account details, the standard Instagram Posts & Reels Scraper returns those at $1.90 per 1,000 posts.

Field list, pricing and n8n or MCP setup are in the PRO actor overview.

Which songs do brands put behind their Instagram reels? How we pulled reel music with Python

Intropix-team — Wed, 21 Oct 2026 14:12:04 +0000

A client asked which tracks the big sportswear brands were using in their reels, and whether licensed songs did better than original sound. Answering that by hand means opening each reel and reading the audio label at the bottom. Fine for ten reels, useless for three brands and a quarter of posts.

How we solved it

The audio is part of the post data. We built the PRO Instagram Posts & Reels Scraper on Apify (disclosure: it's ours), which returns audio_title, audio_artist, audio_id and is_original_audio on every post, with no Instagram login. The input per brand:

{
  "usernames": ["nike"],
  "maxPosts": 60,
  "mediaType": "video"
}

maxPosts is one budget per run, spent account by account in input order, so one brand per run. The grouping is by audio_id, because titles collide and the id does not:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
reels = []
for brand in ["nike", "adidas", "puma"]:
    run = client.actor("intropix/instagram-posts-reels-scraper-pro").call(
        run_input={"usernames": [brand], "maxPosts": 60, "mediaType": "video"})
    reels += list(client.dataset(run["defaultDatasetId"]).iterate_items())

df = pd.DataFrame(reels)
df = df[df["is_original_audio"].notna()]  # drop posts with no audio
tracks = (df[df["is_original_audio"].eq(False)]
          .groupby("audio_id")
          .agg(title=("audio_title", "first"), artist=("audio_artist", "first"),
               brands=("username", "nunique"), views=("view_count", "sum"))
          .sort_values(["brands", "views"], ascending=False))
print(df.groupby(["username", "is_original_audio"])["view_count"].median())
print(tracks.head(20))

What came out

Every reel carries the same four audio fields. A real Red Bull reel from 17-10-2026:

{
  "username": "redbull",
  "view_count": 1588744,
  "share_count": 3450,
  "audio_title": "Original audio",
  "audio_artist": "redbull",
  "audio_id": "26590578263972833",
  "is_original_audio": true
}

The first print is the licensed-versus-original split per brand, as median views. The second is the playlist the client asked for: licensed tracks ranked by how many of the brands used them, then by total views.

Cost

At most $0.005 + $0.002 + 60 x $0.0039 = $0.241 per brand. Photos skipped by mediaType are never billed, so it is usually less.

The caveat

mediaType: "video" still reads maxPosts posts and drops the photos, so a brand whose newest 60 posts are half photos gives you about 30 reels. It also skips photo posts with a music sticker, which carry the same audio fields. And an original sound is a black box: if it is a re-upload of a song, the data does not say so.

To try it without code, the Find the music brands use in Instagram reels task runs the PRO Instagram Posts & Reels Scraper on one account's reels. If captions, likes, comments, views and dates are all you need, without the music fields, the standard Instagram Posts & Reels Scraper returns those at $1.90 per 1,000 posts.

Field list, pricing and n8n or MCP setup are in the PRO actor overview.

How do you track which brands an Instagram creator works with? (sponsored posts and brand deals in Python)

Intropix-team — Wed, 21 Oct 2026 14:11:34 +0000

We needed to know which brands a list of creators had worked with in the last 90 days, and how big those partners were. Scrolling each profile and squinting at the "Paid partnership with" line under the handle does not scale past a handful of creators, and the official API shows nothing for accounts you do not manage.

How we solved it

Instagram already stores the answer in structured form: the paid-partnership label names the brand, collab posts list their co-authors. We built the PRO Instagram Posts & Reels Scraper on Apify (disclosure: it's ours), which returns those as fields, with no Instagram login. The input per creator:

{
  "usernames": ["natgeo"],
  "maxPosts": 300,
  "sinceDate": "2026-07-23",
  "enrichPartners": true
}

maxPosts is one budget for the whole run, spent account by account in input order, so we run one creator per run and let sinceDate decide what comes back:

from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
posts = []
for creator in ["natgeo", "creator_two", "creator_three"]:
    run = client.actor("intropix/instagram-posts-reels-scraper-pro").call(run_input={
        "usernames": [creator], "maxPosts": 300,
        "sinceDate": "2026-07-23", "enrichPartners": True})
    posts += list(client.dataset(run["defaultDatasetId"]).iterate_items())

df = pd.DataFrame(posts)
deals = (df[df["is_paid_partnership"].eq(True)]
         .explode("sponsor_usernames")
         .groupby(["username", "sponsor_usernames"])["post_pk"].nunique())
print(deals.sort_values(ascending=False))

What came out

On each paid post, sponsor_usernames names the brand and partners profiles every co-author and sponsor. From the brand-deals example in the actor's README:

"sponsor_usernames": ["rolex"],
"partners": [
  {"username": "chaivasarhelyi", "follower_count": 63358,
   "category": "Film Director", "account_type": "creator"},
  {"username": "imax", "follower_count": 1676536,
   "category": null, "account_type": "business"}
]

The grouped table gives one row per creator and sponsor with the number of labelled posts. Next to it we kept view_count, share_count and engagement_rate per post, so the client could see which deals did anything.

Cost

A creator with 100 posts in the window costs $0.005 + $0.002 + 100 x $0.0039 = $0.397, plus $0.005 per distinct partner enriched in that run.

The caveat

Only labelled deals are visible. is_paid_partnership is Instagram's own label, so a creator who takes money and skips the label looks organic. mentions and an #ad in hashtags are a useful second signal, but a heuristic, not proof. Enrichment also needs a paid Apify plan, and tagged accounts are never enriched.

To try it without code, the Track Instagram brand deals and sponsored posts task runs the PRO Instagram Posts & Reels Scraper on one account with partner enrichment on. If captions, likes, comments, views and dates are all you need, the standard Instagram Posts & Reels Scraper returns those, plus the paid partnership flag, at $1.90 per 1,000 posts.

A ready-made command-line version, with CSV and markdown reports that rank sponsor brands, is in instagram-brand-deals-tracker.

The full field list, pricing and the n8n and MCP setup are in the PRO actor overview.

Instagram scraper API without login: posts and reels with music, shares, location and business contacts (Python)

Intropix-team — Wed, 21 Oct 2026 13:58:15 +0000

The Instagram Basic Display API was shut down on 04-12-2024. What is left on the official side is the Graph API, which is built around accounts you manage: your own professional account, a Meta app, app review, and even then a narrow view of anyone else's content. If the job is "pull public posts and reels from a list of brand accounts into a pipeline, with everything Instagram shows on them", the official route does not get you there.

The jobs that kept coming to me were all versions of that: which brands a creator works with, which tracks brands put behind their reels, where an event brand posts from, which accounts in a list are businesses with a public contact. Each one needs more than likes and a caption. This post is the scraper I built for them.

Why not instaloader and a burner account?

You can, until the account dies. The open-source libraries are good, but a burner running against them collects checkpoint challenges within days, and anything beyond a shallow scrape wants a logged-in session. Then you are maintaining accounts instead of doing analysis.

So the session problem sits with me. The PRO Instagram Posts & Reels Scraper runs on Apify: usernames or post links in, one JSON item per post out. No Instagram login, no cookies, no OAuth, no Instagram account of your own. Full disclosure: it's mine, so factor that in.

What it returns

Every item has the same 54 keys, null (or []) when a value is absent, never a made-up zero. Basics first:

Media: every image and video URL with width, height and duration. A carousel is one item with its slides nested in media.
Post: post_pk, shortcode, permalink, post_type (photo, video, reel, carousel), taken_at, caption, hashtags, mentions.
Metrics: like_count, comment_count, real reel and video plays in view_count, and engagement_rate ((likes + comments) / followers, as a fraction).

Then the details:

Music: audio_title, audio_artist, audio_id, and is_original_audio to separate licensed tracks from the account's own sound.
Shares: share_count and repost_count, plus fb_play_count and fb_like_count when the post was cross-posted to Facebook.
Location: location_name, location_id, location_city, location_lat, location_lng, from the venue the publisher tagged.
Tagged accounts and partners: tagged_usernames, coauthors, and sponsor_usernames (the brand on the paid partnership label) next to is_paid_partnership.
Flags: is_pinned, caption_edited, has_audio, counts_hidden, is_off_grid.
Account profile: owner_account_type, owner_category, owner_website, owner_bio_links, owner_post_count, follower counts, and owner_public_email, owner_public_phone, owner_city, owner_address where the profile shows them publicly. Hidden contact details stay null.
Partner enrichment (optional): with enrichPartners on, partners holds a short profile of every co-author and sponsor brand (followers, verified badge, category, account type).

It reads public business, creator and brand accounts, including age-gated (18+) accounts in alcohol, vape, tobacco and nightlife that anonymous visitors cannot see. Private accounts are out of scope by design.

Python quickstart

pip install apify-client

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("intropix/instagram-posts-reels-scraper-pro").call(
    run_input={"usernames": ["redbull"], "maxPosts": 10}
)

for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["taken_at"], post["post_type"], post["like_count"],
          post["share_count"], post["audio_title"], post["location_name"])

call() blocks until the run finishes.

The input, and the one detail that catches people out

usernames: accounts to read, newest posts first.
postUrls: links to specific posts or reels. Each valid link is delivered as one post, whatever maxPosts and the filters say.
maxPosts: default 10. A carousel counts as one post.
sinceDate, untilDate: only posts on or after / on or before a date (YYYY-MM-DD, UTC).
mediaType: any, image or video. Filtered posts are never delivered or billed.
includeViews (on by default), includeOffGridReels (reels missing from the grid but public on the reels tab), enrichPartners.

maxPosts is ONE budget for the whole run, spent account by account in the order you list them. It is not a per-account allowance. Give it three usernames and maxPosts: 100, and the first account can use all 100 while the other two return nothing. For multi-account jobs, run one account per run (an Apify task or a short loop), or set a high maxPosts and let sinceDate and untilDate decide what comes back. A paid run delivers at most 1,000 posts, so larger jobs split across runs anyway.

What the output looks like

A real item, trimmed (Red Bull, 17-10-2026; URLs shortened, some fields cut):

{
  "username": "redbull",
  "follower_count": 34172188,
  "post_pk": "4009548556935342118",
  "permalink": "https://www.instagram.com/p/DekxytFz6gm/",
  "post_type": "reel",
  "taken_at": "2026-10-17T00:08:53Z",
  "like_count": 46317,
  "comment_count": 344,
  "view_count": 1588744,
  "share_count": 3450,
  "repost_count": 937,
  "engagement_rate": 0.001365,
  "audio_title": "Original audio",
  "audio_artist": "redbull",
  "audio_id": "26590578263972833",
  "is_original_audio": true,
  "coauthors": ["asavermette", "redbullbike"],
  "tagged_usernames": ["redbullbike", "asavermette"],
  "sponsor_usernames": [],
  "location_name": "Cypress Mountain",
  "location_lat": 49.39541,
  "location_lng": -123.20219,
  "owner_account_type": "business",
  "owner_website": "https://onein.bio/redbull",
  "owner_public_email": "info@redbull.com"
}

post_pk is the dedup key. engagement_rate 0.001365 is 0.14%: accounts with tens of millions of followers often sit below 1%.

Node quickstart

const res = await fetch(
  "https://api.apify.com/v2/acts/intropix~instagram-posts-reels-scraper-pro" +
    "/run-sync-get-dataset-items",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      // Token in a header, never in the query string.
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
    },
    body: JSON.stringify({ usernames: ["redbull"], maxPosts: 10 }),
  }
);
const posts = await res.json();
for (const p of posts) console.log(p.post_type, p.share_count, p.audio_title);

Node 18+ has fetch built in. Save as scrape.mjs for top-level await.

What does it cost?

Pay per event, no subscription: $0.005 per run start, $0.002 per scanned profile, $0.0039 per delivered post ($3.90 per 1,000). Every field above is in that price. Partner enrichment is the one option: $0.005 per enriched profile, charged once per profile per run. Failed lookups are never charged.

Worked example, ten brand accounts, newest 100 posts each, in one run with maxPostsPerAccount: 100: $0.005 + 10 x $0.002 + 1,000 x $0.0039 = $3.925. If the run enriches 50 partner profiles, add 50 x $0.005 = $0.25.

Free Apify accounts can test with up to 10 results per run and 40 per day, shared across my Instagram actors. Enrichment needs a paid plan.

Knowing why a run returned nothing

Every run writes an OUTPUT record to its key-value store: outcome (ok or denied), delivered, failed_targets and failed_target_reasons. Branch on that, not on the item count.

out = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("OUTPUT")
print(out["value"]["outcome"], out["value"]["failed_target_reasons"])

n8n, Make and AI agents

In n8n, the verified Apify node's "Run actor and get dataset" operation takes the id intropix~instagram-posts-reels-scraper-pro and the same JSON input. Make and Zapier have Apify integrations that work the same way. For scheduled jobs, let Apify own the schedule and have the workflow react to a webhook.

For an AI agent, point any MCP client at Apify's hosted MCP server, limited to this one actor:

https://mcp.apify.com?tools=intropix/instagram-posts-reels-scraper-pro

Authenticate with your Apify account and the agent sees one tool with this input schema. Put a maxPosts ceiling in the prompt: a model asked to "get everything" will ask for a lot, and you pay per delivered post.

For coding agents there are ready-made skills: npx skills add Intropix-team/instagram-scraper-skills installs seven, from saving stories and reels to a competitor audit, brand deals and business contacts. Each one picks the right scraper, runs it in your Apify account and writes the files (repo).

Honest limits

Private accounts, direct messages, comment text and commenter identities are out. So are highlights and the tagged-photos tab.
Instagram trial reels are shown only to their author and are not returned.
Counts are what Instagram showed at scrape time. When the owner hides counts, counts_hidden is true and the count fields are null.
Location is the venue the publisher tagged, not where the camera was, and many posts have none.
Contact fields are only what the profile shows publicly. Many accounts show none.
Media URLs point at Instagram's CDN and expire; download promptly if you need the files.

This is an independent, unofficial tool. It is not affiliated with, endorsed by, or connected to Instagram or Meta Platforms, Inc.

When the base scraper is enough

I also run the standard Instagram Posts & Reels Scraper at $1.90 per 1,000 posts. It returns 24 fields: media, caption, likes, comments, views, dates, follower counts, and the paid-partnership and co-author signals. Those 24 are identical to the first 24 here, so code moves between the two unchanged. If that is the whole job, use it. As soon as shares, music, location, sponsors or account details are the point, this one is cheaper than collecting them anywhere else.

Wrap-up

Walkthroughs of my other two actors: How to scrape Instagram stories without login and How to scrape Instagram posts and engagement data without login. Runnable stories, posts and PRO examples (brand deals and business leads to CSV) are in github.com/Intropix-team/instagram-scraper-examples.

Short posts on single jobs with this actor: tracking brand deals, the music brands use in reels, business contacts for lead lists, mapping post locations and a competitor engagement audit. If you have a job that does not fit, leave a comment.

How to scrape Instagram posts and engagement data without login (Python)

Intropix-team — Fri, 24 Jul 2026 13:56:09 +0000

If you have ever tried to pull post data out of Instagram in code, you already know the official route is a dead end unless you own the account. The Graph API hands you your own business profile and basically nothing beyond it. So anyone doing competitor analysis, influencer verification, or plain content research ends up scraping instead, and then runs straight into the next wall: anonymous scraping of Instagram stopped working years ago.

A client wanted posts and reels from a list of brand accounts, with engagement numbers attached, running on a daily schedule, and able to backfill a historical date range on demand. What I landed on runs without an Instagram login, cookies, or a headless browser, and the core of it is maybe 15 lines of Python.

Why not instaloader and a burner account?

You can, until the account dies. The open-source libraries (instaloader, instagrapi) are genuinely good, but a burner running against them starts collecting checkpoint challenges and shadow-bans within days, and at that point you are running an account-warming operation, not an analytics one. Feeds are a bit friendlier to scrape than stories, but the moment you want reliable engagement counts and deep pagination, Instagram wants to see a logged-in session again.

So I let someone else carry the session problem. I use a hosted scraper on Apify (the Instagram Posts & Reels Scraper actor): usernames in, JSON out. Full disclosure, it's mine, so factor that in. Any hosted scraper with an API gets you the same shape of result; the exact keys below are what this one returns.

What you need

A free Apify account (free tier is enough to test: the actor caps free runs at 10 posts per run and 40 per day, shared across our Instagram actors)
Your Apify API token, from Console > Settings > API & Integrations
Python 3.9+

Step 1: install the client

pip install apify-client

Step 2: run the scraper

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("intropix/instagram-posts-reels-scraper").call(
    run_input={
        "usernames": ["natgeo"],
        "maxPosts": 2,
    }
)

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(f"{run['status']}: {len(items)} posts")
for post in items:
    print(post["post_type"], post["like_count"], post["permalink"])

call() blocks until the run finishes. My last test run took 10 seconds wall clock including container startup.

What the output looks like

One dataset item per post, always the same 24 fields, with every media slide nested inside it. This is a real reel from the run above (URLs truncated, caption shortened):

{
  "username": "natgeo",
  "user_pk": "787132",
  "full_name": "National Geographic",
  "is_verified": true,
  "is_private": false,
  "follower_count": 280000000,
  "following_count": 148,
  "profile_pic_url": "https://instagram.fxxx.fna.fbcdn.net/v/t51.2885-19/...",
  "biography": "Experience the world through the eyes of National Geographic photographers.",
  "post_pk": "3512345678901234567",
  "shortcode": "DbrNlfeg60B",
  "permalink": "https://www.instagram.com/p/DbrNlfeg60B/",
  "post_type": "reel",
  "taken_at": "2026-08-05T22:29:25Z",
  "caption": "Black rhinos once again roam Matusadona National Park, decades after poachers turned the Zimbabwean refuge into what one conservationist called...",
  "like_count": 16545,
  "comment_count": 77,
  "view_count": 1253265,
  "is_paid_partnership": false,
  "is_off_grid": false,
  "coauthors": [],
  "hashtags": [],
  "mentions": ["marcuswestbergphotography", "warren_smart"],
  "media": [
    {
      "slide_index": 0,
      "media_type": "video",
      "media_url": "https://scontent-lax3-1.cdninstagram.com/o1/v/t2/f2/m86/...",
      "cover_url": "https://scontent-lax3-2.cdninstagram.com/v/t51.82787-15/...",
      "width": 720,
      "height": 1280,
      "video_duration": 13.696000099182129
    }
  ]
}

The fields that make this useful for analysis:

like_count and comment_count on everything; view_count on reels and videos. Instagram publishes no view count for photos or carousels, so those are null rather than a misleading zero. This is the data the official API will not give you for accounts you don't own.
follower_count and following_count: the account's public totals at scrape time, stamped on every item, so a dataset row carries its own denominator for engagement-rate maths.
coauthors and is_paid_partnership: collab posts and Instagram's own sponsorship label, the two signals you want for influencer verification.
media is one entry per slide. A 10-slide carousel is ONE item with 10 nested slides, not 10 items. Your item counts match reality and so does your bill.
post_pk is a stable numeric ID, use it for dedup. permalink gives you the clickable evidence URL.

The schema is a strict allowlist: every item has exactly these 24 keys, every slide the same 7. Upstream changes drop out instead of leaking into your pipeline.

The date filters are the actually good part

sinceDate and untilDate bound the fetch server-side:

run = client.actor("intropix/instagram-posts-reels-scraper").call(
    run_input={
        "usernames": ["natgeo", "bbcearth"],
        "maxPosts": 200,
        "sinceDate": "2026-07-22",
    }
)

That pattern turns a scheduled daily run into an incremental pipeline: yesterday's date in sinceDate, and each run collects exactly the new posts instead of re-downloading (and re-paying for) the whole feed. For one-off historical work, set both bounds and backfill a campaign window post by post.

Two input details worth knowing. maxPosts gives you the N newest posts, which is less obvious than it sounds: Instagram's feed is not date-ordered, pinned posts sit at the top carrying their original dates, and even the tail arrives out of order, so taking the first N the feed hands over quietly returns the wrong posts. The actor reads past the limit, sorts, then truncates. And maxPosts is a total across all usernames, filled account by account in input order, not a per-account allowance. For a fixed number per account, set maxPostsPerAccount instead (it replaces maxPosts for the usernames), or use date bounds.

The reels that aren't on the profile grid

Some reels never show up on the profile grid the feed endpoint reads: creators take reels off their grid while leaving them public on the reels tab. Those are invisible to anything that only walks the grid.

includeOffGridReels (off by default) returns them alongside everything else, and every item carries is_off_grid so you can tell which is which. The flag is on every post, not just when you opt in, so your columns never move.

One thing to know if this is why you're here: Instagram trial reels are a different case, and they are not returned. Instagram shows a trial reel only to its author, so it is in no listing a scraper can read, and repeated runs do not change that. An earlier version of this post said otherwise; that was wrong, and the actor's page has the measurements.

Can it read age-restricted (18+) accounts?

Yes, same as its stories sibling. Alcohol, vape, tobacco and nightlife brands often sit behind Instagram's age gate and return nothing to anonymous scrapers. This actor reads their feeds at the standard price and I verified delivery against an age-gated global beer brand's account (carousels and all). Scope boundary: public and age-gated brand content. Private accounts are out.

What does it cost?

Pay-per-event, no subscription: $0.005 per run start, $0.002 per profile scanned, and from $1.90 per 1,000 posts delivered. A carousel counts as one post no matter how many slides. View counts cost nothing extra, and off-grid reels bill as ordinary delivered posts, so turning that flag on spends your maxPosts budget rather than adding a surcharge. Failed lookups (typo'd or deleted usernames) are never charged. A daily incremental pull on two competitor accounts costs about two cents a day; a 1,000-post backfill across 10 accounts lands around $1.93 all-in.

Getting it into a spreadsheet

Flatten to CSV and open it in Sheets or Excel; the engagement columns are what you usually want:

import csv

FIELDS = ["username", "post_pk", "post_type", "taken_at", "permalink",
          "like_count", "comment_count", "view_count",
          "follower_count", "is_off_grid",
          "is_paid_partnership", "hashtags", "mentions"]

with open("posts.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
    writer.writeheader()
    for post in items:
        row = {**post,
               "hashtags": " ".join(post["hashtags"]),
               "mentions": " ".join(post["mentions"])}
        writer.writerow(row)

Sort by like_count and you have a poor man's top-content report; group by ISO week of taken_at and you have a posting-cadence benchmark.

No-dependency Node version

The plain REST API does the whole thing in one call:

const res = await fetch(
  "https://api.apify.com/v2/acts/intropix~instagram-posts-reels-scraper" +
    "/run-sync-get-dataset-items",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      // Token in a header, never in the query string: URLs land in
      // shell history, proxy logs and server access logs.
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
    },
    body: JSON.stringify({ usernames: ["natgeo"], maxPosts: 2 }),
  }
);
const posts = await res.json();
console.log(posts.length, "posts");

Node 18+ has fetch built in, so that is the entire program.

Running it on a schedule

Apify has a scheduler built in: actor page > Schedule, pick an interval. Pair it with sinceDate for the incremental pattern above, and add a webhook (Integrations tab) if you want each finished run POSTed to your endpoint.

Using an AI coding agent?

The same scrapers come as agent skills: ask your agent to "back up nike's posts from September" or "download the last 10 reels from nike" and it runs the scraper in your Apify account, downloads the media and writes the CSV. Install with npx skills add Intropix-team/instagram-scraper-skills (repo).

Wrap-up

Complete runnable versions of the examples are in the examples repo: github.com/Intropix-team/instagram-scraper-examples. The actor, with the full 24-field reference and pricing, is at apify.com/intropix/instagram-posts-reels-scraper. If you need the ephemeral side of Instagram instead (stories, which disappear after 24 hours), that is a separate actor with its own write-up: How to scrape Instagram stories without login. The free tier is enough to test whether it fits before any money is involved.

If you need more than this actor's 24 fields (shares, reposts, music, location, tagged accounts, sponsor brands, the account's category, website and publicly shown contacts), the PRO Instagram Posts & Reels Scraper returns 54 per post at $3.90 per 1,000, with the same input and the same first 24 fields. Its overview, with n8n and MCP setup: Instagram scraper API without login: posts and reels with music, shares, location and business contacts. Worked examples with the PRO actor: tracking brand deals, the music brands use in reels, business contacts for lead lists, mapping post locations and a competitor engagement audit.

Got a posts or engagement use case that doesn't quite fit the above? Drop it in the comments. The date-range filtering in particular came out of exactly these kinds of questions.

How to scrape Instagram stories without login (Python, JSON in 30 seconds)

Intropix-team — Fri, 24 Jul 2026 13:50:40 +0000

Instagram stories disappear after 24 hours, which makes them the most annoying content type to work with programmatically. Posts sit there forever and give you time to figure things out. Stories punish you for slow pipelines, meaning if your scraper has a bad day, the data is simply gone.

For a client project I needed active stories from a list of brand accounts, as structured data, on a schedule. This post is the setup I ended up with. It uses no Instagram login, no cookies, no browser automation, and the whole thing is about 15 lines of Python.

Why not just log in with a burner account?

Because Instagram is very good at killing burner accounts. The usual open-source route (instaloader, instagrapi and friends) works right up until it doesn't. First a checkpoint challenge, then forced 2FA, then the session quietly gets shadow-banned, and suddenly you are babysitting a stable of warm accounts and residential proxies instead of doing your actual job. Stories make this worse than posts do: the web UI has no anonymous path to them at all, so every story fetch normally rides on a logged-in session.

The alternative is to let someone else own that problem. I use a hosted scraper on Apify (the Instagram Stories Scraper actor). You send usernames, you get JSON back, and session management stops being your concern. Full disclosure: this is my own actor, so treat me as biased. The technique below is the same with any hosted scraper that exposes an API; the specific field names you'll see are from mine.

What you need

A free Apify account (the free tier is enough to test: the actor caps free runs at 10 stories per run and 40 per day, shared across our Instagram actors)
Your Apify API token, from Console > Settings > API & Integrations
Python 3.9+

Step 1: install the client

pip install apify-client

Step 2: run the scraper

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("intropix/instagram-stories-scraper").call(
    run_input={
        "usernames": ["natgeo"],
        "maxResults": 2,
    }
)

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(f"{run['status']}: {len(items)} stories")
for story in items:
    print(story["username"], story["media_type"], story["media_url"][:60])

call() starts the actor and blocks until it finishes. On my last test run this took 27 seconds wall clock including container startup; the scrape itself is 2-3 seconds per account.

What the output looks like

One dataset item per story, always the same 22 fields. This is a real item from the run above (media URL truncated):

{
  "username": "natgeo",
  "user_pk": "787132",
  "full_name": "National Geographic",
  "is_verified": true,
  "is_private": false,
  "story_pk": "3942549043641043661",
  "taken_at": "2026-07-16T13:28:11Z",
  "expiring_at": "2026-07-17T13:28:11Z",
  "media_type": "image",
  "media_url": "https://instagram.frix7-1.fna.fbcdn.net/v/t51.82787-15/747613074_...",
  "video_duration": null,
  "is_paid_partnership": false,
  "attribution_url": null,
  "width": 750,
  "height": 1334,
  "caption": null,
  "link_urls": [],
  "hashtags": [],
  "mentions": ["disneyparks", "disneyland"],
  "music_title": null,
  "music_artist": null,
  "coauthors": []
}

A few fields worth calling out:

expiring_at tells you exactly when the story dies, so you know your download deadline.
media_url is a direct CDN link to the full-resolution image or video. These links expire after a while, so if you want the file, download it in the same job.
is_paid_partnership, mentions and link_urls are the interesting ones for influencer-verification and competitor-monitoring use cases: they tell you who a story tags and where it links.
story_pk is a stable numeric ID, use it for dedup.

The schema is fixed. If Instagram adds junk fields upstream, they get dropped rather than leaking into your dataset, so downstream code does not break when Instagram changes something.

Can it read age-restricted (18+) accounts?

Yes, and this was the reason I built it. Alcohol, vape and nightlife brands often mark their accounts age-restricted, and those accounts return nothing to anonymous story viewers. If you do competitor monitoring in those verticals, or you verify influencer placements for a drinks brand, that gap is exactly where your data needs to be. This scraper reads them like any other public account: I verified delivery against age-gated brand accounts (Budweiser was my test case, 17 story items from an account that an anonymous viewer cannot see at all).

To be clear about scope, this is for public and age-gated brand content. Private accounts stay private and the actor does not touch them.

What does it cost?

Pay-per-event, no subscription. Three events: $0.005 per run start, $0.002 per profile scanned, $0.0025 per story delivered. That lands at "from $2.50 per 1,000 stories", or about $2.70 per 1,000 all-in on typical runs. A daily check on two competitor accounts costs about $0.014 per run. Failed lookups (typo'd or deleted usernames) are never charged.

Running it on a schedule

You could cron the Python script, but Apify has a scheduler built in, so I let the platform do it: actor page > Schedule, pick an interval, done. Add a webhook (Integrations tab) if you want each finished run POSTed to your endpoint.

For no-code pipelines there is a verified Apify node for n8n: its "Run actor and get dataset" operation takes the actor id intropix~instagram-stories-scraper and the same JSON input as above, and hands the stories to the next node. Make and Zapier have Apify integrations that work the same way.

No-dependency Node version

If you would rather not install a client library, the plain REST API does the same job. This endpoint starts a run, waits, and returns the dataset items in one call:

const res = await fetch(
  "https://api.apify.com/v2/acts/intropix~instagram-stories-scraper" +
    "/run-sync-get-dataset-items",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      // Send the token as a header, not in the query string. URLs land in
      // shell history, proxy logs and server access logs.
      Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
    },
    body: JSON.stringify({ usernames: ["natgeo"], maxResults: 2 }),
  }
);
const stories = await res.json();
console.log(stories.length, "stories");

Node 18+ has fetch built in, so that is the entire program.

Getting it into a spreadsheet

The lazy path that works everywhere: flatten to CSV, open in Google Sheets or Excel.

import csv

FIELDS = ["username", "story_pk", "taken_at", "expiring_at", "media_type",
          "caption", "link_urls", "mentions", "is_paid_partnership", "media_url"]

with open("stories.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
    writer.writeheader()
    for story in items:
        row = {**story,
               "link_urls": " ".join(story["link_urls"]),
               "mentions": " ".join(story["mentions"])}
        writer.writerow(row)

For a fully automated Sheets pipeline (append rows on every scheduled run), use the n8n template instead of reinventing it.

Using an AI coding agent?

The same scraper comes as an agent skill: ask your agent to "save today's stories from natgeo" and it runs the scraper in your Apify account and downloads every story into a dated folder, skipping ones it already saved, so a daily run builds an archive. Install with npx skills add Intropix-team/instagram-scraper-skills (repo).

Wrap-up

Complete runnable versions of all three examples (Python, Node, CSV export) are in the examples repo: github.com/Intropix-team/instagram-scraper-examples. For a ready-made archiver that saves every story to dated folders with JSONL and CSV metadata, see instagram-story-archiver. The actor itself, including full field reference and pricing, is at apify.com/intropix/instagram-stories-scraper. The free tier is enough to test whether it fits your use case before any money is involved.

If you need the permanent side of Instagram instead (posts and reels, with like, comment and play counts, follower counts, date-range filtering, and reels that never appear on the profile grid), that is a separate actor, the Instagram Posts & Reels Scraper, and I wrote up that one the same way: How to scrape Instagram posts and engagement data without login.

For the full post data (music, shares, reposts, location, tagged accounts, sponsor brands and the account's public business details) there is also a PRO Instagram Posts & Reels Scraper. I wrote it up the same way, including how to call it from n8n and from an AI agent over MCP: Instagram scraper API without login: posts and reels with music, shares, location and business contacts. For a worked stories job, see How do you check that influencers actually posted the Instagram stories you paid for?

If you have a stories use case that is close but not quite covered here, leave a comment. I read them, and edge cases are how the actor got most of its fields.