Instagram Content Scraper - Posts + Reels [NO LOGIN]

Scrape every public Instagram post AND reel from any profile in one run. Captions, likes, comments, plays, video URLs, carousel images. No login, no cookies. Built for influencer research, content strategy, and brand monitoring.

Why run two scrapers when one does both? This Actor pulls every public Instagram post (photos, videos, carousels) AND every reel from a profile in a single run, then merges them into one unified, analysis-ready dataset. No Instagram login required, no cookies, no proxies to manage.

The official apify/instagram-scraper and most alternatives require separate runs for posts and reels and leave the merge and dedup work to you. This Actor calls both endpoints in parallel, dedupes reels by shortcode, and emits a single flat row per item so you can stream straight into BI tools, dashboards, RAG pipelines, or downstream Actors.

Use this Instagram posts scraper as a drop-in Instagram posts API and Instagram reels API replacement for the official Meta Graph API where rate limits, private-account gates, or business-account requirements block your workflow. The unified schema means one row per item across both feeds, ready for Instagram creator analytics, brand monitoring, and influencer vetting at scale.

---

Why this scraper

• No login, no cookies, no OAuth. Nothing to paste, no session to age, no risk to any Instagram account you own.
• Posts + reels in one run, one row per item. Carousels stay as one row with every slide URL inside; no per-slide row explosion.
• View counts you can trust. IG-native plays and FB cross-post plays are returned as separate fields (stats.ig_plays, stats.fb_plays), not silently merged, so you always know which number you're comparing to.
• Full provenance on every row. _metadata.source_endpoint, _metadata.page, _metadata.fetched_at, and _metadata.input_identifier tell you exactly where each item came from and when.
• Optional AI reel transcripts via the enrich_reel_transcripts flag — transcripts are cached upstream for 7 days, so re-runs are cheap.
• strict_author_match input drops collab and coauthored posts by other creators that Instagram sometimes serves on a profile's feed — a data-cleanliness switch no other scraper we've seen exposes.
• Five dataset views (Overview, Engagement, Media, Errors, Full detail) — no digging through JSON to find what you need.
• Track record: 99.7% success across the last 693 runs, 4.99★ rating on Apify Store.

---

How it compares

At-a-glance vs the most common alternatives for the "posts + reels from a handle" job:

	This actor	apify/instagram-post-scraper + apify/instagram-reel-scraper	apidojo/instagram-scraper	intropix/instagram-posts-reels-scraper	data-slayer/instagram-posts
Posts + reels in ONE run	✅	❌ Two separate actors	✅	✅	❌ Posts only
Carousel = one row (not one row per slide)	✅	✅	✅	✅	✅
IG plays vs FB cross-post plays split out	✅	❌ Single field	❌	❌	❌
Full per-row provenance metadata	✅	❌	❌	❌	❌
Explicit likes_disabled / comments_disabled flags	✅	❌	❌	❌	❌
Multiple dataset views (Overview, Engagement, Media, Errors)	✅ 5 views	❌ 1	❌ 1	❌ 1	❌
Collab / coauthored-post filter	✅ strict_author_match	❌	❌	❌	❌
Optional AI reel transcripts	✅ Flag, cached 7 days	✅ Paid add-on	❌	❌	❌
Pricing	$5.00 / 1k results	$2.30–$2.70 / 1k + paid add-ons	$0.50 / 1k (broad scope)	~$1.93 / 1k + per-run + per-profile	from $1.50 / 1k

Prices, feature flags, and endpoint availability change over time — check each actor's store page for current values.

---

Optional add-ons (all opt-in, all off by default)

Six additional data types can be turned on with a single checkbox each. Every one defaults to OFF, so any run, task, or schedule that never touches these flags produces byte-for-byte identical output to before:

Flag	Adds	Extra row source	Notes
skip_pinned	(filter only)	—	Drops posts pinned to the top of the profile grid so time-window analyses aren't skewed by old outliers.
include_tagged_posts	Posts by other creators that tag this profile	source: "tagged"	Auto-sniffs the numeric user ID from the posts/reels response, so plain handle inputs work.
include_comments	Public comments per delivered post/reel	source: "comment"	Cap with max_comments_per_post (default 10). One upstream call per delivered item.
include_comment_replies	Public replies to each comment	source: "reply"	Requires include_comments. Uses the inline include_replies=true mode; upstream fee is a flat 15 units per comments request when on.
include_story_highlights	The profile's story highlight albums	source: "highlight"	One upstream call per profile.
include_highlight_details	Individual stories inside each highlight album	source: "highlight_item"	Requires include_story_highlights. One upstream call per album.

Every row still carries _metadata with source_endpoint, page, fetched_at, and input_identifier, so downstream pipelines can filter or join across source types cleanly.

Knowing why a run returned nothing

Every run writes an OUTPUT record to the default key-value store, alongside the human-readable run status message. This makes an empty-dataset run programmatically explainable — an account with no posts and a run that hit a plan cap are otherwise indistinguishable:

{
  "outcome": "ok" | "partial" | "denied",
  "message": "...",
  "delivered": 20,
  "delivered_by_source": { "post": 12, "reel": 8, "comment": 40 },
  "failed_targets": ["broken_handle"],
  "failed_target_reasons": {
    "broken_handle": { "reason": "not_found", "message": "not_found: Handle ..." }
  }
}

outcome: "ok" means the run completed and every target that was attempted delivered rows (or genuinely had no matching content). outcome: "partial" means at least one target failed; details are in failed_target_reasons. outcome: "denied" means the run refused to start (no valid input, or upstream unreachable) and no rows were delivered — reason says which of nothing_requested or guard_backend_unavailable.

Existing OUTPUT fields (finished_at, total_items_pushed, cap_reached, item_cap, strict_author_match, per_profile, post_urls) are unchanged for callers already reading them.

Read it via /v2/key-value-stores/{defaultKeyValueStoreId}/records/OUTPUT, or with the client libraries.

What you get that other Instagram scrapers don't

• _metadata on every row. Pipeline debugging stops being guesswork. Every row tells you which endpoint delivered it, which pagination page, when it was fetched, and which input identifier triggered it. No other Instagram scraper on the Store returns this.
• Separate ig_plays and fb_plays. Instagram's in-app view count silently combines both. Competing scrapers surface only the combined number, which is why so many of their users file "views wrong" tickets. We return both, plus views for the primary metric, so you can trace any discrepancy back to which platform contributed what.
• stats.engagement_total. Pre-computed likes + comments + shares + saves + reposts, so your dashboards don't have to.
• stats.likes_disabled and stats.comments_disabled. Nulls in engagement counts have two meanings — "not available" vs "creator disabled it". These flags disambiguate.
• strict_author_match. Instagram sometimes serves collab and coauthored posts by other creators inside a profile's feed. Turn this on (default) and rows where the primary author does not match the queried profile are dropped. Turn it off to keep collabs. Neither Apify nor apidojo nor intropix expose this control.
• carousel_slides[] on every carousel row. Direct CDN URLs to every slide, so you can archive or analyze each image without a second call.
• Full-detail dataset view. Nested fields flattened with dot notation (video.url_no_watermark, stats.views, author.handle, _metadata.source_endpoint) — no need to reshape the JSON before it lands in a spreadsheet.

---

Table of contents

• Why this scraper
• How it compares
• Optional add-ons (all opt-in, all off by default)
• Knowing why a run returned nothing
• What you get that other Instagram scrapers don't
• What this Actor returns
• Required caveats
• Limitations and scope
• Free plan limit
• Pricing
• Hero use case
• Sample output
• Comparison vs alternatives
• Inputs
• Outputs and dataset views
• How it works
• Performance
• Volume guidance
• Use cases
• FAQ
• Demo video
• Live view API
• Legal and compliance
• Changelog
• Support
• Integrations
• Related scrapers

---

What this Actor returns

For every public Instagram profile you supply, you receive a unified, normalized dataset row per piece of content, covering:

Content type	Source endpoint	Fields surfaced
Photo posts	posts feed	shortcode, URL, caption, thumbnail, likes, comments, posted date, author, branded-content flag
Video posts	posts feed	all of the above plus video URL, dimensions, duration, play count
Carousels	posts feed	all of the above plus carousel media count and first-slide thumbnail
Reels	reels feed	shortcode, URL, video URL (no watermark), thumbnail, play count, likes, comments, shares, music metadata, author
Pinned content	posts feed	included (pinned reels surface here, not in the reels feed)

Inputs accepted: profile URLs, handles (with or without @), or numeric Instagram user IDs - mix any of them in one bulk field.

---

Required caveats (read these first)

• Play counts are Instagram-only. When a reel is cross-posted to Facebook, the in-app view count shows combined IG + FB. This API returns only the IG portion. Disclose this to your end users so they do not dispute your numbers against in-app stats.
• Reel captions are not returned by the reels endpoint. If your pipeline needs reel captions, source them from the posts feed (reels cross-posted to feed carry their caption there).
• Private accounts return an error row, not data. The Actor accesses publicly visible content only.
• Story and Highlight content is not included. This Actor targets the permanent feed (posts + reels) only.

---

Limitations and scope

Everything this Actor deliberately does not do, so you can rule it out quickly if your use case needs one of these:

• No private accounts. Only publicly visible content is scraped. Private profiles return an error row and the Actor moves on.
• No ephemeral 24-hour stories. The include_story_highlights add-on (see Optional add-ons) reaches permanent story highlights only.
• No live streams. Instagram Live is out of scope entirely.
• No hashtag or location discovery. This Actor scrapes by profile. For hashtag- or location-based discovery, use a dedicated Actor for that endpoint.
• No Instagram Insights metrics. Impressions, reach, follower demographics, and audience breakdowns require the account owner's OAuth consent through Meta's Graph API and are not accessible to any third-party scraper.
• No trial reels. Instagram serves trial-mode reels only to the creator's own account; no scraper (this one or any other) can see them from a third-party session.
• No shares/saves/reposts counts on posts. These metrics are private to the creator (visible only in Instagram Insights). The Actor returns null for these fields on posts; on reels a subset is available through what the upstream exposes.
• Play counts are Instagram-only. When a reel is cross-posted to Facebook, the in-app view count shows combined IG + FB. This Actor splits them into stats.ig_plays and stats.fb_plays so you know which is which.
• Media URLs expire. Instagram's CDN URLs are signed and time-limited. Download media promptly if you need to keep it.

---

Free plan limit

Free Apify users get up to 50 results per run. Paying users are not affected and receive results normally.

This limit was set by the Actor developer, not by Apify. To remove it and receive unlimited results, upgrade to any paid Apify plan: https://apify.com/pricing

When a free plan run hits the cap, the Actor finishes successfully (status SUCCEEDED) and the run's status message explains what happened. No error is raised, so the first 50 results are fully usable as normal.

---

Pricing

$5.00 per 1,000 results. Platform usage is included. Free tier available on the Apify free plan (first 50 results per run, capped as described above).

Every row counts as one result - posts, reels, and error rows alike. A run that returns 350 items costs $1.75. There are no per-request, per-page, or platform-compute surcharges - the $5.00 per 1,000 is the whole line item.

---

Hero use case

An influencer marketing agency tracking 200 creators across Instagram:

1. Paste 200 profile URLs into the profiles bulk field.
2. Get every post + reel for each creator in one unified dataset.
3. Run engagement analysis (views, likes, comments, branded-content flags) without merging two separate sources.

The merge is the conversion event - one row per item, normalized fields across both shapes, ready for analysis the moment the run finishes.

---

Sample output (unified schema)

{
  "source": "reel",
  "id": "3251234567890123456",
  "url": "https://www.instagram.com/reel/Cabc123xyz/",
  "shortcode": "Cabc123xyz",
  "type": "reel",
  "caption": "Behind the scenes...",
  "created_at": "2026-05-12T10:23:45.000Z",
  "stats": {
    "views": 482310,
    "ig_plays": 482310,
    "fb_plays": 138420,
    "video_views": null,
    "likes": 31204,
    "comments": 412,
    "shares": 1820,
    "saves": 3022,
    "reposts": 47,
    "engagement_total": 36505,
    "likes_disabled": false,
    "comments_disabled": false
  },
  "video": {
    "url_no_watermark": "https://scontent.cdninstagram.com/.../video.mp4",
    "url_alt": null,
    "duration_ms": 28500,
    "width": 1080,
    "height": 1920
  },
  "thumbnail_url": "https://scontent.cdninstagram.com/.../thumb.jpg",
  "is_paid_partnership": false,
  "music": { "title": "Original audio", "author": "natgeo", "id": "..." },
  "author": { "handle": "natgeo", "name": "National Geographic", "verified": true },
  "_metadata": {
    "source_endpoint": "/v1/instagram/user/reels",
    "page": 2,
    "fetched_at": "2026-06-05T14:32:01.000Z",
    "input_identifier": "natgeo"
  }
}

A post row has the same shape with source: "post" and type: "photo" | "video" | "carousel". The unified schema means a downstream consumer never has to branch on the source endpoint.

Field reference

Field	Type	Notes
source	"post" | "reel"	Which feed the item came from.
id	string	Stable Instagram media ID.
url	string	Direct link to the content.
shortcode	string	Used for dedup between posts and reels feeds.
type	enum	photo, video, carousel, reel, text, unknown.
caption	string | null	Always present for posts. Null for reels (Instagram's reels endpoint does not return captions).
created_at	ISO 8601	Original post time.
stats.views	number | null	Best available view count for video / reels. null for photos (Instagram does not count views on photos).
stats.ig_plays	number | null	Instagram-only plays, when Instagram splits the count from Facebook plays in the response (most reels).
stats.fb_plays	number | null	Facebook cross-post plays. Almost always null - Instagram's public feeds rarely return this.
stats.video_views	number | null	Legacy video_view_count for very old video posts. Almost always null on modern content.
stats.likes	number | null	All content types. null when likes_disabled = true.
stats.comments	number | null	All content types. null when comments_disabled = true.
stats.shares	number | null	PRIVATE METRIC. Always null. See "What about shares, saves, reposts?" below.
stats.saves	number | null	PRIVATE METRIC. Always null. See below.
stats.reposts	number | null	PRIVATE METRIC. Always null. See below.
stats.engagement_total	number | null	Computed: likes + comments + shares + saves + reposts. In practice equals likes + comments because the other three are private.
stats.likes_disabled	boolean	Creator hid like counts on the post.
stats.comments_disabled	boolean	Creator turned comments off.

What about shares, saves, reposts?

These are private creator-only metrics. Instagram only shows them to the post's author inside their own Insights dashboard. No public Instagram scraper can return them, including this one - it is an Instagram product decision, not a scraper limitation.

The fields are kept in the schema for forward compatibility: if Instagram ever exposes them via a public response (which has happened briefly in the past), the normalizer is already wired to pick them up without a code change. Until then they will be null.

If you need shares / saves / reposts, the only legitimate paths are:

• The creator's own Insights, accessed through the Instagram Graph API with the creator's OAuth consent (business / creator accounts only).
• The Meta Business Suite for accounts you own.

What publicly visible engagement actually exists

Metric	Photos	Carousels	Video posts	Reels
Likes	Yes	Yes	Yes	Yes
Comments	Yes	Yes	Yes	Yes
Views	No (Instagram does not count)	No	Yes	Yes
IG-only plays vs FB plays	n/a	n/a	Sometimes split	Sometimes split
Shares / saves / reposts	Private	Private	Private	Private
video.url_no_watermark	string | null	Direct MP4.
video.duration_ms	number | null	Duration in milliseconds.
video.width, video.height	number | null	Pixel dimensions.
thumbnail_url	string	First-frame thumbnail or photo.
is_paid_partnership	boolean	Branded-content disclosure flag.
music.title, music.author, music.id	string | null	Reel audio metadata.
author.handle, author.name, author.verified	string / boolean	Creator identity.
carousel_slides	array | absent	Only on carousels. One entry per slide with index, type (photo/video), image_url, video_url (for video slides), width, height, duration_ms (for video slides). Absent on non-carousel rows.
_metadata.source_endpoint	string	The underlying endpoint that produced this row.
_metadata.page	number	Pagination page index.
_metadata.fetched_at	ISO 8601	When this row was fetched.
_metadata.input_identifier	string	The input you supplied.

---

Comparison vs alternatives

Feature	This Actor	apify/instagram-scraper (official)	apidojo Instagram	Most commodity scrapers
Posts + reels in one run	Yes	No - separate runs	No	No
Unified normalized schema across both feeds	Yes	No - raw shape per endpoint	Partial	No
Reel dedup by shortcode	Yes	Manual	Manual	Manual
Login required	No	Optional but recommended for coverage	No	Varies
Pinned reel coverage via posts feed	Yes	Yes	Partial	Often missed
Bulk input (URLs + handles + IDs mixed)	Yes	Yes	Partial	No
Per-page progress logs	Yes	No	No	Rare
Live view HTTP API	Yes	No	No	No
Pay model	Pay-per-event	Per result	Per result	Per result

---

Inputs

Input	Type	Required	Default	Description
profiles	array of strings	yes	-	One entry per target. Mix any of: profile handle (natgeo, @natgeo), profile URL (https://www.instagram.com/natgeo/), numeric Instagram user ID (529823214 - reels only), or a specific post / reel URL (https://www.instagram.com/p/<shortcode>/ or /reel/<shortcode>/). The Actor routes each entry automatically: profile-style inputs scrape the whole feed; post/reel URLs fetch just that one item. Query params (?stkn=..., ?img_index=...) are stripped. Duplicates are removed.
results_type	enum	no	both	posts, reels, or both. Applies to profile scraping only; specific post/reel URLs always return that one item.
max_items_per_profile	integer	no	0 (unlimited)	Cap per profile. 0 = fetch every available post and reel with no cap. Set a positive number between 1 and 15000 for a bounded sample.
strict_author_match	boolean	no	true	Return only content owned by the queried profile. Drops collab / coauthored / tagged posts where the author is a different creator. Set to false to include everything Instagram returns for the profile. See "Coauthored posts and strict author match" below.
enrich_reel_transcripts	boolean	no	false	Opt-in reel transcript enrichment. When enabled, adds a transcript field (string or null) to each reel under 2 minutes. Each transcript call takes 10 - 30 seconds, so wall time increases significantly. Reels 2 minutes or longer are skipped. Only reel-type rows are transcribed; photos, carousels, videos, and text posts are never sent to the transcript endpoint. When disabled (default) output rows are unchanged.
trim	boolean	no	false	Drop heavy CDN / transcode fields from each row.

Coauthored posts and strict author match

Instagram's posts and reels feeds sometimes return content where the queried profile is tagged, coauthored, or collaborating but is not the primary author. Real example from an actual run: querying _charihawkins returned some rows with author.handle = "onherturf" or "katemackz" - both real posts from Instagram's response for that profile, both with a different primary author.

Default behavior (recommended): strict_author_match is enabled by default. Rows where author.handle does not match the queried handle (case-insensitive) are dropped. Your dataset will only contain content owned by the profiles you queried. Count of drops per profile is exposed in the per-profile summary rows so you can see how much collab content Instagram surfaced.

Opting out: Set strict_author_match: false if you want the raw feed, including collab / coauthored / tagged content. In that mode:

• author.handle is the primary author of that specific post (which will often differ from the profile you queried).
• _metadata.input_identifier is the profile you queried - always the source of the row.

Filter by _metadata.input_identifier when you need to know which of your queried profiles a row belongs to.

Per-profile run summary rows

At the end of every run the Actor appends one row per queried profile to the dataset (in addition to the content rows). Each summary row has source: "summary" and _metadata.source_endpoint: "run-summary", and reports:

• total_items, posts, reels
• owned_items (author matched the queried profile)
• coauthored_items (author was a different account)
• dropped_by_strict_author_match (only nonzero when strict_author_match=true)
• errors (per-profile error count)
• zero_items (true when the profile returned nothing)

Filter the dataset by source == "summary" to see, at a glance, which of your queried profiles produced data and which produced zero.

Example profiles input

[
  "natgeo",
  "@nasa",
  "https://www.instagram.com/nike/",
  "529823214"
]

Numeric IDs are accepted but feed the reels endpoint only - the posts endpoint requires a handle. If you provide only a numeric ID, posts for that profile are skipped with a warning.

Programmatic run (Apify API)

curl -X POST "https://api.apify.com/v2/acts/unseenuser~instagram-posts-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "profiles": ["natgeo", "nasa"],
    "results_type": "both",
    "max_items_per_profile": 100
  }'

---

Outputs and dataset views

Results stream to the Apify dataset as flat rows. The Apify console renders three pre-built views:

• Overview - source, type, shortcode, URL, author, caption, headline engagement (views, likes, comments, shares, saves, total), posted date.
• Engagement - public engagement signals per item: views (video / reels), IG-only plays, likes, comments, computed total, plus likes-hidden / comments-off flags. Shares, saves, and reposts are private metrics Instagram does not expose publicly and are not shown here.
• Media URLs - shortcode, type, thumbnail, video URL, dimensions, duration. Use for download pipelines.
• Errors - any rows that failed mid-run. Check first when a profile returns no data.

Export formats

• JSON, JSON Lines, CSV, XLSX, XML, RSS, HTML
• Apify API (paginated)
• Webhooks on run finish

Key-value store outputs

Key	Content
OUTPUT	Run-level summary (counts, cap status, finish time).
SUMMARY-<handle>	Per-profile counts of posts, reels, and errors.
STATE-*	Reserved for internal run state. Safe to ignore.

---

How it works

profiles input
     v
parser  ----> { handle, userId, label } per profile
     v
for each profile (sequential)
     +--> posts endpoint  -+
     |                      +--> dedup by shortcode --> normalize --> push to dataset
     +--> reels endpoint  -+

• Posts and reels for a single profile fetch in parallel.
• Profiles are processed sequentially so failures on one do not poison others.
• Reels that appear in both feeds (cross-posts, pinned reels) are deduplicated by shortcode.
• Failed pages emit error rows; the run keeps going.
• Pagination is capped at 50 pages per endpoint and stops automatically if cursors stop advancing or pages return only duplicates.

---

Performance

Typical run times on the paid plan:

Workload	Approx wall time
1 profile, 100 items, posts + reels	10 - 25 s
1 profile, 1000 items, posts + reels	1 - 3 min
10 profiles, 100 items each	2 - 5 min
200 profiles, 100 items each	30 - 90 min

---

Volume guidance

Pulling 1000 items from a single creator typically requires several paginated upstream requests under the hood. The max_items_per_profile input lets you cap each profile's volume so a single noisy creator never blows up a bulk run.

---

Use cases

• Influencer content audits - vet a creator's full portfolio before a partnership.
• Brand monitoring - track a brand or competitor's posting cadence across both formats.
• Content strategy research - measure how reels stack up against photo / carousel posts on engagement per impression.
• Competitor analysis - benchmark engagement against peers in your category.
• Cross-posting analysis - identify which reels also appear as feed posts (the dedup metadata tells you).
• Brand-safety audits - review what a creator actually publishes before sponsorship.
• UGC research - analyze how communities create content around products.
• Academic research - study posting cadence, engagement velocity, content trends.
• RAG / search indexing - feed creator content into vector stores for downstream Q&A.
• Instagram creator analytics - export every piece of content for a creator's Instagram profile into a normalized dataset your BI tool can chart.
• Instagram influencer analytics - compare engagement across creators in a category by pulling posts + reels for every one of them in a single bulk run.
• Instagram monitoring tool - schedule the Actor daily or weekly to track new posts and reels for a brand or a competitor; the unified schema slots straight into a dashboard.

---

FAQ

How is this different from the official Apify Instagram scraper? The official actor solves a broader surface (profiles, hashtags, locations, comments) but requires you to run separate jobs for posts and reels and stitch the results yourself. This Actor is purpose-built for the posts + reels merge: one run, unified schema, dedup handled.

What happens with private accounts? Only publicly visible content is returned. Private profiles return a clear error row and the Actor moves on to the next profile.

What is the max posts per profile? No hard limit when max_items_per_profile is left at 0 (default) - the Actor paginates until Instagram runs out of items. Set a positive number between 1 and 15000 for a bounded sample. For pulls larger than 15000 items per single profile, leave the cap at 0 and let the Actor fetch everything available.

How are carousels handled? Each carousel is one row with type: "carousel". The first media's thumbnail represents the carousel. Every slide's URL is also exposed in the carousel_slides array on the row - one entry per slide with index, type (photo or video), image_url, video_url (for video slides), width, height, and duration_ms (for video slides). See "How do I get all the slides of a carousel?" below.

How do I get all the slides of a carousel? Read the carousel_slides array on any row where type == "carousel". Each element has index (0-based position), type (photo or video), image_url (always populated, video slides return their thumbnail), video_url (only for video slides), width, height, and duration_ms (only for video slides). Slides are returned in the order Instagram serves them. The stats.likes / stats.comments on the parent row are aggregate values across the whole carousel, not per slide (Instagram does not expose per-slide engagement publicly). The field is absent on non-carousel rows.

Why is my reel's play_count lower than the in-app number? The in-app number includes Facebook cross-post views. This API returns Instagram-only views. See "Required caveats" above.

Do I need an Instagram login? No. The Actor accesses publicly visible content only.

Does the Actor handle pinned reels? Yes. Pinned reels surface through the posts feed (the reels feed excludes them by default). The dedup logic merges them cleanly.

What if a profile has zero reels? The reels task returns an empty list and the run continues with just the posts data. No error.

What about rate limits? The Actor retries 429 / 502 / 503 / 504 responses three times with exponential backoff. Hard failures emit an error row and the Actor moves on.

Can I get historical data older than X? The Actor follows whatever Instagram exposes through the public feeds. There is no cutoff date you control - you bound the volume with max_items_per_profile.

Can I use this for AI training? No. Instagram's Terms of Service prohibit using Instagram data to train AI / ML models without Meta's authorization, and creators retain copyright. See Legal and compliance.

Is there an Instagram API I could use instead? Yes - Meta's Instagram Graph API. It requires a business or creator account, OAuth consent from the account holder, app review by Meta, and only returns data from the accounts that have connected to your app. This Actor works on public Instagram content without any of that, which is why buyers reach for a scraper: the official API's rate limits and account gates block most of the workflows this Actor is used for (influencer vetting, competitor tracking, UGC research).

How do I calculate an Instagram engagement rate from the output? Divide stats.engagement_total (or stats.likes + stats.comments) by the creator's follower count, then multiply by 100 to get a per-post engagement rate percentage. Average across all rows for a profile-level rate. Views are not part of the standard engagement-rate formula because they include lurkers who did not react; use stats.views separately as a reach signal.

Is this Actor an alternative to Instagram scrapers on GitHub or PyPI? Yes. Instaloader, instagram-scraper, and similar GitHub / PyPI projects work but require you to run and maintain infrastructure, handle Instagram's login and blocking, and update code when Instagram changes its endpoints. This Actor runs in Apify's managed cloud, requires no login, and stays maintained.

Can I use this as a monitoring tool for a brand or competitor? Yes. Schedule the Actor to run on a cadence (daily or weekly), point it at the brand or competitor handles you want to watch, and pipe results into a dashboard or webhook. See the Demo video section for the scheduling walkthrough.

Can I run this without cookies, session tokens, or an Instagram login? Yes. This Actor accesses publicly visible Instagram content through a third-party data provider that handles the upstream requests. You supply Instagram handles or profile URLs; you never supply Instagram credentials.

What does this Actor return that Instagram's Graph API does not? Public post-level and reel-level data from any public profile without OAuth. Meta's Graph API only exposes data from business / creator accounts that have explicitly connected to your app. This Actor also returns fields Meta's API omits from most surfaces (video URLs without watermark, carousel media counts, deduped pinned reels).

Is Instagram scraping legal? Publicly visible Instagram data has been established as legally distinct from behind-login data in precedents like hiQ Labs v. LinkedIn (Ninth Circuit, 2022). This Actor accesses publicly visible Instagram content only. Your downstream use has its own obligations under Instagram's Terms of Service, GDPR / CCPA / Israeli Privacy Protection Law where applicable, and copyright law where you redistribute creator content. See Legal and compliance and the full Terms of Service and Actor-Specific Addendum for the binding agreement you accept when running this Actor. When in doubt about your specific use, consult qualified counsel.

How do I scrape Instagram posts without getting blocked? This Actor delegates upstream requests to a third-party data provider that handles Instagram's rate limits, IP rotation, and anti-scraping measures. You supply handles or profile URLs; the provider handles the network layer. On the Actor side, the client retries 429 / 502 / 503 / 504 responses three times with exponential backoff and emits an error row rather than failing the whole run when a request hard-fails. You do not need proxies, session cookies, or a login of your own.

Can I scrape Instagram posts by hashtag? No, this Actor scrapes by profile. You provide handles, profile URLs, or numeric user IDs, and get every public post + reel for those profiles in a unified dataset. For hashtag-based scraping you need a different Actor built for that endpoint.

Is this Actor free? There is a free tier (first 50 results per run on the Apify free plan - see Free plan limit). Paid usage is $5.00 per 1,000 results, platform usage included (see Pricing). Every row counts as one result. A 350-item run costs $1.75. There are no per-request or platform-compute surcharges beyond that.

What are the best Instagram Reels scraper tools? This Actor covers reels as first-class content alongside posts (unified schema, one row per item, deduped by shortcode). If you only need reels, the reels-only preset is at unseenuser/IG-posts/examples/igc-audit-creator-reels. Alternatives include open-source Python projects like Instaloader that require you to run and maintain your own infrastructure, and other Apify Actors focused on different Instagram content types (profile data, hashtags, comments).

Can I scrape specific post or reel URLs instead of a whole profile? Yes. Paste them straight into the profiles input alongside any handles or profile URLs - the Actor auto-detects which is which and routes each entry to the right processor. Each specific URL becomes one row (same unified schema as profile-scraped rows). Query params like ?stkn=... are stripped automatically. Rows fetched this way carry _metadata.source_endpoint = "post_detail" and _metadata.input_identifier set to the URL you supplied. Reels fetched by URL also get transcripts if enrich_reel_transcripts is on. Existing scheduled runs that pass a legacy post_urls field still work - it is silently accepted for backward compatibility.

Can I get transcripts of the reels? Yes, as an opt-in extra. Set enrich_reel_transcripts: true in the input and each reel under 2 minutes will get an AI-generated transcript field (string of the spoken audio, or null if there is no speech). Only reel-type rows are transcribed; photos, carousels, standalone video posts, and text-only posts are never sent to the transcript endpoint. Off by default because each transcript call takes 10 to 30 seconds, so wall time on profiles with many reels increases significantly. Responses are cached upstream for 7 days, so a reel appearing in both feeds within a single run is only transcribed once. Reels 2 minutes or longer are skipped (the upstream transcript API rejects them). Works across both results_type settings. When left off, output rows are byte-for-byte identical to previous runs, so existing automations are unaffected.

Why do scraped counts sometimes not match what I see in Instagram? Two reasons, both benign:

1. Logged-out visibility. This Actor sees what Instagram serves a logged-out visitor, which is what any third-party scraper without a session can see. Engagement from private accounts is hidden from logged-out visitors. Open the post in an incognito browser — the numbers there should match this Actor's output.
2. Snapshot in time. Views, likes, and comments keep changing after the run finishes. A reel returning 976 views in the morning can show 982 by afternoon. Always compare against the run's timestamp, not the live page. If both checks pass and numbers still don't line up, open a support ticket with the run ID and post URL.

Why is stats.likes sometimes -1? When a creator has hidden the like count on their post, Instagram doesn't publish this data. The Actor returns -1 for likesCount in that specific case to disambiguate "hidden by creator" from "zero likes" and from "not available". stats.likes_disabled: true on the same row confirms the reason.

How do I get comments for each post? Turn on include_comments in the input. Each comment becomes its own dataset row with source: "comment", linked to its parent via post_shortcode and post_url. Cap the count per post with max_comments_per_post (default 10). Turn on include_comment_replies to also fetch replies as source: "reply" rows. Both flags are opt-in and off by default so existing tasks are unaffected.

Can I get story highlights (the permanent stories on a profile)? Yes, as an opt-in. Set include_story_highlights: true to list the profile's highlight albums (source: "highlight" rows). Add include_highlight_details: true to expand each album into its individual stories (source: "highlight_item" rows, with media URLs, dimensions, timestamps). Neither reads ephemeral 24-hour stories.

How do I filter out pinned posts from the results? Turn on skip_pinned in the input. Pinned posts get dropped before they hit the dataset; the run's per-profile summary counter dropped_by_skip_pinned tells you how many were skipped. The flag only affects the posts feed — pinned reels are still included unless you also add a downstream filter.

How do I integrate with Zapier / n8n / Google Sheets / Slack? Apify has native integrations for all of these plus Make, Airbyte, IFTTT, Lindy, Gumloop, CrewAI, GitHub, and Google Drive. See the Integrations section below. For any service Apify doesn't have a direct integration for, use a webhook: the Actor can POST run-finished events to your endpoint with the dataset URL and the full OUTPUT KVS record.

Can I use this Actor from my own Python or Node.js code? Yes. Use apify-client — pip install apify-client for Python, npm install apify-client for Node. The Actor's API tab on its Store page gives you copy-paste starter code with your API key already substituted in.

Does this Actor work with Apify's MCP server for Claude Desktop or LibreChat? Yes. Any Actor on Apify is callable through Apify's MCP server. Point your MCP-aware client (Claude Desktop, LibreChat, etc.) at the Apify MCP endpoint on the Actor's API tab, and the LLM can invoke this Actor's runs directly. See Apify's MCP setup guide for wiring it up.

What is this Actor's success rate? 99.7% across the most recent 691/693 runs (data from July 2026 analytics). Failures are almost always upstream Instagram rate-limits or account-deletion between input and fetch; these emit an error row rather than failing the whole run, so a partial failure still delivers the rows that did succeed.

How do I know if my run returned zero rows because nothing matched, vs. because something broke? Every run writes a machine-readable OUTPUT record to its default key-value store. Read it at /v2/key-value-stores/{defaultKeyValueStoreId}/records/OUTPUT or via the client libraries. The outcome field is one of "ok" (run completed, whatever it delivered is what the profile had), "partial" (some targets failed — details in failed_target_reasons), or "denied" (run was refused before starting — nothing was charged). delivered is the row count, delivered_by_source breaks down which source types contributed. See Knowing why a run returned nothing for the full schema.

Why is stats.saves always null? Instagram does not publicly expose save counts to third-party APIs. Save counts are a creator-private metric visible only in Instagram Insights (when the account owner logs in). The Actor reads save_count from the upstream response for forward-compat, but in practice Instagram returns null for this field on public content. The same applies to stats.shares on posts (though not on reels — reels sometimes have a shares count) and stats.reposts. If you need Insights-only metrics, they're only reachable through Meta's Graph API with OAuth consent from the account owner.

How do I track how a post's views/likes/comments change over time? Turn on include_deltas in the input. The Actor keeps a private history of every shortcode it has seen in a named key-value store scoped to your Apify account (isolated per account — nobody else sees your history). On the second and every subsequent run for the same shortcode, each row carries a stats.deltas object with views, likes, comments, and hours_since_prior — the changes since the last time the Actor saw that post. First run for any shortcode returns no delta (nothing to compare to yet). Perfect for viral-post alerts, growth dashboards, and time-series analysis without you having to manage state yourself. Off by default; existing runs and tasks produce byte-for-byte identical output until you turn it on.

What is author.account_type? Instagram tags every profile as one of personal, business, or creator (with a fourth internal category that most third-party APIs cannot see). The Actor exposes this as author.account_type on every post/reel/tagged row when Instagram includes it in the response. Value is null when the response didn't carry the field. Useful for segmenting your dataset into brand accounts vs individual creators vs personal accounts without a second lookup.

What are hashtags and mentions on each row? Ready-to-use arrays of hashtag and mention handles parsed from the caption. #nature #travel in a caption produces hashtags: ["nature", "travel"]; @nasa produces mentions: ["nasa"]. Hashtags are lowercased for consistency; mentions preserve the exact handle. Arrays are always present (empty when the caption has none), so downstream code can iterate without null checks.

What is location on the row? When the creator geotagged the post, location is an object with name (as shown on Instagram), lat, and lng. When there's no geotag, location is null.

What does is_pinned mean? true when the post is pinned to the top of the profile grid at the time of the scrape, false otherwise. If you want to drop pinned posts from your results entirely rather than just flag them, turn on skip_pinned.

I saw the input form got shorter. Where did the include_* fields go? The collapsed fields (tagged_per_profile, comments_per_post, replies_per_comment, stories_per_album) replace the old include_X + max_X pairs so the form is half as long. Every legacy field is still accepted in Task JSON — existing saved Tasks continue to run exactly as before. If you pass a legacy field (e.g. include_comments: true with no comments_per_post), the Actor uses your legacy value; if you set the new collapsed field to a positive value, the collapsed one wins. Legacy fields are grouped under a "Legacy inputs" section in the Console form; safe to ignore for new runs.

---

Demo video

New to Apify? Schedule this Instagram posts scraper to run automatically:

Connect this Actor to your stack - webhooks, Zapier, Make, Slack, and 20+ integrations:

---

Live view API

While the Actor is running, an HTTP server is exposed on the container port and accessible via the Apify run detail page's "Live view" tab.

Method	Path	Returns
GET	/health	Liveness probe { status, uptime_ms }.
GET	/progress	Current pushed count, item cap, cap reached flag, current profile.
GET	/summary	Per-profile counts gathered so far.

The full OpenAPI v3 spec ships in .actor/web_server_openapi.json.

---

Legal and compliance

This Actor accesses publicly visible Instagram content. Your downstream use must independently comply with Instagram's Terms of Service.

You may NOT use this Actor to:

• Train commercial AI / LLM models on Instagram content (Meta prohibits this; creators retain copyright).
• Scrape content of users you know or suspect are minors. Instagram has many under-18 users and minor-data violations carry the highest regulatory penalties (COPPA, GDPR Article 8, Illinois BIPA, Israel PPL).
• Republish creator content as your own.
• Build mass-DM tools targeting commenters or engagers.
• Strip creator attribution before redistribution.
• Aggregate Instagram data with Facebook, LinkedIn, TikTok, X / Twitter to build cross-platform identity profiles of named individuals.
• Process personal data without a lawful basis under GDPR, UK GDPR, CCPA, or Israel PPL.

You agree to:

• Honor data subject deletion requests within 30 days under GDPR.
• Disclose to your end users that play counts are Instagram-only (do not include Facebook cross-post views).
• Notify the Publisher within 48 hours if Meta or a creator issues a cease-and-desist regarding data obtained via this Actor.

By running this Actor you accept the Publisher's Terms of Service V4.0 (referenced in the log on every run) and the actor-specific addendum. Full terms are available on the Apify Actor page.

---

Changelog

1.1.0 — pending publish (branch state)

• Six opt-in Instagram data types: tagged posts (source tagged), comments (source comment), comment replies (source reply), story highlight albums (source highlight), highlight items (source highlight_item). Every flag defaults off; existing tasks and schedules produce byte-for-byte identical output until an operator turns a flag on.
• skip_pinned input filter for the posts feed. Dropped pinned posts are counted in the per-profile summary as dropped_by_skip_pinned.
• Machine-readable OUTPUT KVS record: outcome, delivered, delivered_by_source, failed_targets, failed_target_reasons fields added on top of every pre-existing key.
• Denied-outcome OUTPUT is also written on early-exit paths (invalid input, upstream preflight failure), so an operator can always distinguish "no rows because nothing was requested" from "no rows because the account had no posts."
• New always-present row fields: author.account_type (personal/business/creator/null), hashtags (array parsed from caption), mentions (array parsed from caption), is_pinned (boolean), location (object or null). All backward-compatible additions — existing rows keep every field they carried; consumers reading specific keys see no change.
• New opt-in include_deltas flag: when on, each row carries stats.deltas (views/likes/comments/hours_since_prior) comparing current stats to the last time the Actor saw the same shortcode. Persistence via a per-account named KVS; first observation of any shortcode returns no delta.
• Five additional FAQ entries covering the new fields (stats.saves limitation, include_deltas, author.account_type, hashtags/mentions, location, is_pinned).
• README additions: Integrations, Limitations and scope, and 10 new FAQ entries covering common buyer questions.
• Store metadata refreshed: title, short description, and keyword tags updated for the current "Instagram Content Scraper" positioning.

1.0.0 (2026-06)

• Initial public release.
• Unified posts + reels schema with shortcode-based dedup.
• Bulk profiles input accepting URLs, handles, and numeric IDs.
• Three pre-built dataset views, key-value store summaries, live-view HTTP API.
• Free plan cap of 50 results per run with SUCCEEDED exit status.

---

Support

• Bugs, feature requests, or questions: open an issue on the Actor's Apify page contact form.
• Found a profile that returns weird data? Include the handle and the run ID and we can usually fix the normalizer the same day.
• For commercial questions (volume pricing, white-label, custom fields): contact via the Apify profile.

---

Integrations

This Actor runs on Apify's platform and works with every integration Apify supports:

• Zapier, Make, n8n, IFTTT, Lindy, Gumloop, CrewAI, Airbyte — trigger runs, react to completed runs, pipe results into your automation stack.
• Google Sheets, Google Drive, GitHub, Slack — push results directly.
• Webhooks — POST to your endpoint the moment a run finishes, with the dataset URL and the OUTPUT KVS record in the payload.
• Apify API — the full REST API for run management, dataset access, and the KVS. apify-client packages available for both Python (pip install apify-client) and Node.js (npm install apify-client).
• MCP server access — this Actor is callable through the Apify MCP server, so you can invoke it from Claude Desktop, LibreChat, or any MCP-aware LLM client. See the API tab for the MCP endpoint.

See Apify integrations for the full list.

---

Related scrapers

Build the complete cross-platform creator intelligence stack:

• Instagram Profile Scraper - profile-level data to pair with content.
• TikTok Trends Scraper - evaluate cross-platform creators (flagship).
• Facebook Page Posts & Reels Scraper - extend brand monitoring to Facebook.
• Meta Ad Library Scraper - paid + organic intelligence on the same brand.

See all scrapers by unseenuser

---

Example tasks

Ready-to-run preset configurations of this Actor for the most common buyer jobs. Open one, click Try, and you have a populated dataset in minutes.

• Vet an Instagram Creator Before a Brand Partnership - audit a creator's full content history, engagement, and branded-content flags before sending a partnership offer.
• Track a Competitor Brand's Instagram Posts and Reels - pull every public post and reel from a competing brand for weekly competitive review.
• Audit Every Reel from an Instagram Creator - reels-only snapshot with play counts, engagement, and direct video URLs.
• Bulk Export Posts and Reels for Many Creators - feed a list of handles and get a unified dataset of posts and reels, built for agency-scale vetting.
• Build a UGC Dataset from Brand Instagram Accounts - aggregate posts from multiple brand accounts to analyze community engagement signals.
• Export Instagram Reel Videos and Thumbnails for AI - MP4 URLs, thumbnails, durations, and dimensions for transcription, content analysis, and RAG pipelines.

---

Quick start

1. Click Try for free on the Actor page.
2. Paste URLs, handles, or user IDs into the profiles field.
3. Run the Actor.
4. Download results as JSON, CSV, or XLSX, or pull via the Apify API.

---

Keywords: instagram posts scraper, instagram reels scraper, scrape instagram content, instagram bulk scraper, instagram api alternative, no login instagram, influencer content audit, brand monitoring instagram, instagram analytics, ugc research, creator analytics, social media monitoring

---

---

Terms of Service

Version: 4.0 Effective Date: May 5, 2026

0. Acceptance by use

These Terms of Service ("Terms") form a binding legal agreement between you ("User," "you," "your") and the Publisher of this Apify Actor ("the Publisher," "we," "us," "our").

You accept these Terms by any of the following acts:

• (a) Running the Actor on the Apify platform
• (b) Using any output returned by the Actor for any purpose
• (c) Continuing to access the Actor's listing or documentation after these Terms are visible

Each time you run the Actor or use its outputs, you reaffirm your acceptance of the then-current Terms. If you do not agree to these Terms, you must not run the Actor.

Architecture

You (User) -> Apify Platform -> Actor (software) -> Third-Party API Provider -> Source Platform
                                                              |
You (User) <- Apify Platform <- Actor (software) <- Third-Party API Provider

• You (the User): Run the Actor on the Apify platform with input parameters you choose.
• Apify: Operates the cloud infrastructure that hosts and executes Actors, governed by Apify's own Terms of Service.
• The Publisher (us): Publishes software code (the Actor) on Apify's platform. The Actor is a thin wrapper that translates your input into requests to a third-party data provider and returns the responses to you. The Publisher does not operate scraping infrastructure. The Publisher does not store or retain data returned by the Actor.
• Third-Party API Provider: An independent third-party company that operates the scraping infrastructure and returns data from the source platform. The provider is responsible for the lawfulness of the data collection itself.
• Source Platform: Instagram (the platform whose publicly visible data is accessed).

Your relationship with the Publisher is that of a software user to a software vendor. The Publisher has the responsibilities of a software vendor (functional code, accurate documentation) and the limits of one (the Publisher is not responsible for how you use the data you obtain).

These Terms operate alongside but do not replace:

• Apify's Terms of Service and Acceptable Use Policy
• Source Platform terms (Instagram) governing the public data accessed
• Applicable law in your jurisdiction and the jurisdictions of data subjects

1. Nature of the service

The Actor is a software program published on the Apify platform. It accepts structured input, translates that input into requests to a third-party data provider, receives responses, and returns the data to you in a structured format. The Actor's source code is hosted on Apify's infrastructure. The Actor runs in Apify's cloud, not on the Publisher's servers.

The Actor is not:

• A scraping tool - the Publisher does not operate scraping infrastructure, proxies, headless browsers, or fake accounts
• A direct connection to Instagram - that connection is made by the Third-Party API Provider
• A data storage or data retention service
• A licensed access channel to Instagram or Meta
• Affiliated with, endorsed by, sponsored by, or authorized by Instagram or Meta

The Publisher's role is limited to designing and writing the Actor's source code, publishing it on the Apify Store, maintaining it, and providing documentation and customer support via Apify's contact mechanism. The Publisher is a software vendor, similar to a developer who publishes an app on the App Store or Google Play. The Publisher is not a data provider, data broker, data processor, or data controller for purposes of GDPR, CCPA, Israel's Privacy Protection Law, or equivalent.

2. Who may use the Actor

You may use the Actor only if you are at least 18 years old (or the age of majority in your jurisdiction), you have legal capacity to enter into binding contracts, you are not located in or resident of a country subject to comprehensive sanctions by the United States, European Union, United Kingdom, or Israel, and you are not on any prohibited persons list.

By using the Actor, you represent and warrant that your intended use complies with applicable law in your jurisdiction, that you will independently comply with Instagram's Terms of Service, that you will respect data subject rights under applicable law where outputs include personal data, and that you will not use the Actor for any prohibited purpose listed below.

3. Permitted uses

The Actor may be used for any lawful purpose, including market research and competitive analysis, academic research, journalism and investigative reporting, internal business intelligence, brand monitoring, recruitment research where consistent with applicable employment law, and building products that further process publicly available information lawfully.

4. Prohibited uses

You may not use the Actor for any of the following:

• Activity illegal under the law of your jurisdiction or the jurisdiction of any data subjects.
• Harassment, stalking, doxxing, or tracking individuals without their knowledge.
• Discriminatory employment, lending, housing, or insurance decisions based on protected characteristics.
• Sending unsolicited marketing in violation of CAN-SPAM, CASL, GDPR, PECR, Israeli Anti-Spam Law, or equivalent.
• Identity theft, impersonation, fake reviews / coordinated inauthentic behavior, election interference, or securities fraud.
• Circumventing technical protection measures of Instagram, creating fake accounts, engagement manipulation, or building services that competitively substitute for Instagram.
• Reselling raw Actor outputs as your own data product or scraping-as-a-service. Sharing your Apify credentials to provide third parties indirect access.
• Using Actor outputs as training data for commercial AI/ML models without separate licensing.
• Specifically targeting or profiling based on health conditions, sexual orientation, religious beliefs, political opinions, or other sensitive characteristics. Targeting children under 16.
• Processing personal data of EU/UK/California/Israeli residents without complying with applicable privacy law. Failing to honor data subject access, deletion, or objection requests.

5. Source platform terms - your responsibility

The Actor accesses publicly visible data on Instagram. You are solely responsible for ensuring your downstream use of data obtained through the Actor complies with Instagram's Terms of Service: https://help.instagram.com/581066165581870

The Publisher makes no representation that any specific use is permitted under Instagram's terms. If you receive a cease-and-desist or other legal demand regarding your use of Actor outputs, you must cease the contested use immediately, notify the Publisher within 48 hours via the Apify profile contact form, and cooperate as needed to mitigate.

6. Data protection

For purposes of GDPR, UK GDPR, CCPA, Israel's Privacy Protection Law (PPL) including Amendment 13, and equivalents:

• You (the User) are the Data Controller of any personal data you obtain through the Actor and subsequently process for your own purposes.
• The Third-Party API Provider that performs the collection bears responsibilities relating to the collection itself.
• The Publisher acts solely as a software vendor, not as a data controller or processor, because the Publisher does not store, retain, or substantively process personal data.

The Publisher confirms: no database of personal data obtained through the Actor is maintained; data flows from the Third-Party API Provider directly through the Apify runtime to you; Apify's standard execution and operational logging is governed by Apify's own privacy practices.

Where your use of the Actor involves processing personal data, you are responsible for establishing a lawful basis, providing transparent notice to data subjects, honoring data subject access / rectification / erasure / restriction / portability requests, implementing appropriate security measures, conducting Data Protection Impact Assessments where required, and any cross-border transfer safeguards required by your law.

You will not use the Actor to target, profile, or build datasets focused on health or medical conditions, religious beliefs, political opinions, sexual orientation or gender identity, genetic or biometric data, criminal history, or children under 16.

7. Intellectual property

The Actor's source code, schemas, documentation, and branding are owned by the Publisher. You receive a limited, non-exclusive, non-transferable, revocable license to use the Actor for permitted purposes.

The Publisher claims no ownership over the public data the Actor returns. Source Platforms may have copyright or database rights in their data; data subjects may have copyright in user-generated content. Your use of output data must respect these rights independently. You may not reverse engineer or decompile the Actor's code, or reuse it in a competing actor.

8. Pricing

Pricing is administered through Apify's pricing models. Apify processes all payments. Apify's payment terms govern refunds and disputes. The Publisher may change Actor pricing with at least 14 days' notice via the Actor's Apify listing. If your access is suspended or terminated for breach of these Terms, you forfeit any unused balance and are not entitled to refunds.

9. Service availability

The Actor depends on the Apify platform, the underlying upstream data provider, and Instagram's continued public accessibility. Any of these may change behavior, restrict access, or become unavailable without notice. The Publisher makes no uptime guarantees and may discontinue the Actor at any time, with reasonable notice when feasible.

10. Disclaimers

THE ACTOR IS PROVIDED "AS IS" AND "AS AVAILABLE" WITHOUT WARRANTIES OF ANY KIND, INCLUDING WARRANTIES OF MERCHANTABILITY, FITNESS FOR PURPOSE, NON-INFRINGEMENT, OR ACCURACY OF DATA. The Publisher makes no representation that your specific use of the Actor or the data it returns is lawful in your jurisdiction or under Instagram's terms. Content returned by the Actor was created by third parties; the Publisher does not endorse, verify, or take responsibility for it.

11. Limitation of liability

TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL THE AGGREGATE LIABILITY OF THE PUBLISHER FOR ALL CLAIMS RELATING TO THE ACTOR EXCEED THE GREATER OF (a) ONE HUNDRED U.S. DOLLARS (US $100), OR (b) THE AMOUNTS YOU PAID THROUGH APIFY FOR USE OF THE ACTOR IN THE THREE (3) MONTHS IMMEDIATELY PRECEDING THE EVENT. THE PUBLISHER IS NOT LIABLE FOR INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR FOR LOSS OF PROFITS, REVENUE, OR DATA. Any claim must be brought within one (1) year of the event.

12. Indemnification

You agree to defend, indemnify, and hold harmless the Publisher from any claims arising from your use of the Actor, your violation of these Terms, your violation of any law (including privacy law), your violation of Instagram's Terms of Service, or your processing of personal data obtained through the Actor.

13. Suspension and termination

The Publisher may terminate your access for material breach, illegal use, breach of warranty, or upon credible legal demand. You may stop using the Actor at any time.

14. Dispute resolution

Send a detailed written description of any dispute via the Publisher's Apify profile contact form and wait 60 days for resolution attempt before any formal claim. These Terms are governed by the substantive laws of the State of Israel. Any dispute shall be brought exclusively in the competent civil courts of Tel Aviv-Jaffa, Israel. You agree to bring claims only in your individual capacity. The prevailing party recovers reasonable attorneys' fees.

15. Miscellaneous

These Terms (with the addendum below) are the entire agreement. Unenforceable provisions are severed. You may not assign without the Publisher's consent. Neither party is liable for failure due to events beyond reasonable control. Apify is an intended third-party beneficiary of Sections 4, 5, and 12. Sections 0, 4, 5, 6, 7, 10, 11, 12, 14, and 15 survive termination. English controls. The Publisher's full legal identity may be disclosed upon receipt of valid legal process directed through Apify's official channels.

---

Actor-Specific Addendum

This addendum supplements the Terms above. By running this Actor, you accept both.

A. Nature of data returned

This Actor returns unified output combining posts and reels for an Instagram profile. Each item includes media identity (shortcode, URL), media type (photo / video / carousel / reel), caption text (when available - posts always have it, reels do not), engagement metrics (likes, comments, plays for video / reels), video URLs, thumbnail URLs, dimensions, duration, branded-content flags, and owner identity (handle, name, verification status). Note: play counts are Instagram-only and do not include Facebook cross-post views.

Where the output includes individuals' names, photos, or content authored by them, that data constitutes personal data subject to GDPR, CCPA, Israeli Privacy Protection Law (including Amendment 13), and equivalent privacy laws in your downstream processing - but only in your hands as the data controller, not the Publisher's.

B. Specifically prohibited uses

In addition to the prohibitions in the Terms above, you may NOT:

• Republish creator content as your own on Instagram, TikTok, or any other platform
• Download videos at scale to host on competing platforms or facilitate piracy
• Train commercial AI / LLM models on Instagram content without proper licensing
• Build mass-DM tools targeting commenters or engagers identified through this data
• Mass-extract content from minor creators
• Aggregate posts across many profiles to build a comprehensive Instagram content database for resale (data broker activity)
• Strip creator attribution before redistribution
• Use posts to identify and harass creators
• Build deep-fake training datasets from creator face / voice footage in videos

C. Platform terms

Meta has aggressively litigated against Instagram scrapers. Instagram's Terms of Service explicitly prohibit automated extraction. This Actor accesses publicly visible Instagram content via a third-party data provider that bears responsibility for the lawfulness of the data collection. Your downstream use must independently comply with Instagram's Terms. If Meta issues a cease-and-desist regarding data obtained via this Actor, notify the Publisher within 48 hours via the Apify profile contact form and cease your use immediately.

D. Minor protection - CRITICAL

Instagram has significant under-18 user populations. Many creators do not disclose age. You MUST:

• NOT use this Actor to scrape content of users you know or suspect are minors
• NOT use this Actor for any product or service targeted at minors without parental consent mechanisms compliant with COPPA (US), GDPR Article 8 (EU), and Israeli Privacy Law
• DELETE any data you discover relates to a minor unless you have valid parental consent
• If profile metadata or content suggests the subject is under 18 (school references, age-related hashtags, parental "manage account" notes), treat the profile as belonging to a minor by default

Minor-data and likeness-protection violations carry the highest regulatory penalties under COPPA, GDPR Article 8, Illinois BIPA, and Israeli Privacy Law.

E. Image, video, and caption copyright

Instagram content is multi-layered copyright: images by the creator; videos by the creator AND any music rights holders separately; captions by the creator; filters and effects subject to Meta's platform license.

You may use this content for analysis (typically fair use), quoted excerpts with attribution (typically fair use), and aggregated metrics (no copyright issue). You may NOT republish full content as your own, train commercial AI without proper licensing, strip creator attribution, or use content to create competing platforms. For anything beyond analysis or attributed quotation, get explicit licensing from the creator and any music / IP rights holders.

F. AI training - special notice

Instagram's Terms of Service explicitly prohibit using Instagram data to train AI / ML models without Meta's authorization. Both captions AND visual content fall under this restriction. The Publisher does NOT authorize, and has no ability to authorize, AI training use. Your AI training use is your own legal exposure. Get proper licensing or do not train on this data.

G. Play count caveat - disclosure to your users

Play counts returned for reels are Instagram-only. When a reel is cross-posted to Facebook, the in-app view count shows combined IG + FB views, but this Actor returns only the Instagram portion. If you redistribute play-count data to your users, you MUST disclose this. Otherwise creators will dispute your numbers against their in-app stats and your product credibility erodes.

H. Cross-platform aggregation limit

Do NOT aggregate Instagram data with Facebook, LinkedIn, TikTok, X / Twitter, or other personal data to build comprehensive cross-platform identity profiles of named individuals. Cross-platform aggregation multiplies the personal data risk, triggers heightened scrutiny under GDPR, and creates "people search" / "data broker" profiles that the California Delete Act, GDPR Article 14, and Israeli Privacy Law Amendment 13 specifically target.

I. Cease-and-desist protocol

If Meta contacts the Publisher regarding your use, the Publisher will notify Apify, may suspend access to this Actor pending investigation, and you agree to provide documentation of your lawful basis and processing activities upon reasonable request. If a creator contacts you directly demanding deletion of their content data, honor the request promptly (typically within 30 days under GDPR), do not route them to the Publisher (the Publisher is the software vendor, not the data controller), and document the request and your response.

---

These Terms are not a substitute for legal advice. Consult qualified counsel before any commercial deployment.