An Instagram competitor analysis compares relevant accounts to find content gaps, useful benchmarks and experiments worth running on your own account. Start with three to five comparable competitors, a consistent publication window and metrics you can actually observe. The goal is a decision—what to publish, test or stop—not a leaderboard built from follower counts alone.
For a first audit, use a spreadsheet and permitted public observations. For recurring reports, shortlist a dedicated benchmarking tool; for brand conversation and sentiment, use social listening. Network infrastructure belongs in a separate decision: Socks5.IO can support an authorized regional browsing or collection route, but it is not an analytics dashboard and does not reveal private competitor Insights.
Key takeaways
- Compare similar markets, audience sizes and formats over the same period.
- Separate public interactions, conditionally available views, your own Insights and vendor estimates before calculating anything.
- Record missing likes as missing, not zero, and report the sample size behind every rate.
- Choose a tool for a defined reporting job, not for the largest advertised metric list.
- Use competitor patterns to design your own content tests; public engagement does not establish sales or ROI.

What can you learn from an Instagram competitor analysis?
A useful analysis answers four questions: who competes for the same audience, which themes receive visible interaction, what the publishing mix looks like, and where your brand can offer something different.
For example, a skincare brand might discover that rivals explain ingredients well but rarely show realistic product routines. That suggests a content hypothesis, not proof that routine videos will sell more. Your own watch-time, saves, clicks and conversion data determine whether the experiment works.
Keep three evidence layers separate:
| Evidence layer | Examples | Proper use |
|---|---|---|
| Permitted public observations or eligible public-data exports | Bio, captions, dates, formats, visible likes/comments, profile follower snapshots | Content and visible-interaction benchmarking |
| Authorized analytics for your own account | Metrics made available through the connected account’s Insights and permissions | Evaluate your own audience response and business funnel |
| Vendor-derived estimates | Estimated audience quality, reach or demographic models | Label the method and scope; do not mix estimates with observed counts |
You do not obtain a rival’s private reach, saves, watch time, audience demographics or sales merely by entering their username into a tool. Meta’s Insights API overview describes permissioned access. A public-data connector and an account owner’s authorized analytics connection are different products.
How to Analyze Instagram Competitors Step by Step
Define the comparison, collect permitted evidence, calculate consistent metrics and turn the result into one testable decision. Each report should answer a practical question, such as whether customers need a clearer demonstration or buying guide.
1. Select competitors who compete for the same customer
Start with three direct competitors and one or two aspirational accounts. Include the same product category, target country, language and buying context. A local fitness studio should not use a global sportswear brand as its only benchmark.
Use category keywords, public brand profiles, location references and accounts your customers mention. Search recommendations are leads, not an objective market census. Write down why each account belongs in the set; remove accounts that target a different audience even when they have impressive follower numbers.
| Account-selection field | Example decision |
|---|---|
| Competitor type | Direct substitute, attention competitor or aspirational reference |
| Market and language | US English; keep UK and German-language results in separate cohorts |
| Audience scale | Compare similar-size accounts first; show larger brands separately |
| Business model | Local service versus ecommerce versus creator sponsorship |
| Analysis purpose | Improve educational content, posting mix or campaign positioning |
2. Set the window and capture rules before looking for winners
Choose a manageable publication window, such as the previous 30 days, and collect the same fields for each account. Track capture time separately from publication time. Older posts have had longer to accumulate interactions.
A minimum maturity threshold—72 hours in the worked example below—keeps very new posts out of the rate calculation. It does not make a three-day post directly equivalent to a three-week post. For stronger comparisons, measure each post at the same age or group posts into age bands. Document the rule instead of silently removing inconvenient examples.
Collect through permitted manual viewing, authorized exports or a provider whose access method and data use fit the task. Public visibility is not blanket permission for automated collection. Review Instagram’s Terms of Use and the applicable API/provider conditions before automating. Do not circumvent login restrictions, private profiles or access refusals.
3. Use a small, explicit data dictionary
| Field | What to retain |
|---|---|
| Account and post identity | Stable identifier plus source permalink or provider reference |
| Publication and observation time | Timezone-aware timestamps; document the report timezone |
| Format | Reel, carousel or image; classify consistently |
| Content labels | Theme, hook, CTA, collaboration/giveaway label and visible campaign context |
| Likes/comments | Exact visible or permitted-export count, or null when unavailable |
| Follower denominator | Count and snapshot time; do not substitute today’s count without labeling it |
| Data origin and review status | Manual observation, authorized export or vendor estimate; explain exclusions |
Do not collect lists of individual followers just to compare brand content. Aggregate account metrics and post-level observations usually answer the question with less personal-data exposure. If reviewing comments for themes, minimize identifiers and avoid sensitive profiling.
4. Calculate visible engagement consistently
For a post with known counts:
Visible interaction rate by followers (%)
= (visible likes + visible comments) / followers at observation × 100
Period follower growth (%)
= (ending followers - starting followers) / starting followers × 100
The first formula is a public interaction proxy, not engagement by reach. Record which follower snapshot supplies the denominator. A 300-interaction post and 10,000 followers produce 3%; neither number tells you how many unique people saw or interacted with the post.
Use the median of eligible post rates within each account/format group so one viral post does not dominate the summary. Report both eligible and observed post counts. Missing likes, unknown followers and hidden counters are not zeros. With a zero or missing denominator, the rate is unavailable.
Follower growth requires at least two comparable snapshots. A tool connected today cannot necessarily reconstruct historical daily counts. Keep genuine net declines instead of clipping them to zero. If the starting count is zero, percentage growth is undefined; show the absolute change instead.
5. Diagnose positioning, objections and the conversion path
Audit the profile before attributing results to an individual post. Record the bio’s promise and target customer, pinned-post sequence, Highlights, link-in-bio destination, offer, shipping information and return policy. Identify the next step a visitor is asked to take: learn, compare, enquire or buy. A strong creative leading to an unclear destination can be a different problem from weak creative.
Use a consistent codebook, with one primary theme per post and additional flags where necessary:
| Dimension | Allowed labels / recording rule | What it helps decide |
|---|---|---|
| Purpose | Education, demonstration, comparison, review, offer, community | Whether content answers the same buying-stage question |
| Creative | Product-only, person-led, process, customer-use; record subtitle language and duration band | Which creative variable to test |
| Hook / CTA | Transcribe or summarize the opening promise; classify save, comment, profile, enquiry or purchase CTA | Whether the promise and next step align |
| Creator relationship | Brand-produced, customer/UGC, creator collaboration, unknown; record public partnership label separately | Keep collaborations and ordinary posts in separate comparisons |
| Offer / anomaly flags | Giveaway, discount, launch, holiday, collaboration, paid status unknown | Avoid explaining a spike as a format effect |
| Evidence quality | Post reference, capture age, missing counts and reviewer | Prevent unsupported labels from becoming findings |
A public partnership label does not reveal the contract, total compensation or campaign return. Customer-looking content is not necessarily independent UGC; record uncertainty instead of inferring a commercial relationship from style alone.
Turn comments into creative briefs
Define the comment sample first—for example, all accessible relevant comments on the selected posts, or a fixed visible sample with its order and truncation documented. Deduplicate repeated messages, keep an anonymized evidence reference, and code price, suitability, delivery, usage, comparison, trust or other/ambiguous. One comment can have several themes; theme totals may then exceed unique comments. Visible/top-ranked comments are not a representative customer survey.
| Objection code | What to record | Coverage check | Candidate creative |
|---|---|---|---|
| Delivery | Source post/comment reference and observed question count | Is shipping timing explained in posts, Highlights or the destination? | A delivery timeline and cutoff explainer |
| Suitability | Use-case question, not inferred medical/demographic profiling | Is the intended user/use case demonstrated? | A scenario-led demonstration |
| Price / trust | Question about value, returns or proof | Is the comparison or return policy easy to find? | A transparent comparison or policy walkthrough |
For sentiment labels, retain neutral and ambiguous categories and manually review sarcasm, mixed sentiment and a sample of each AI label. Positive sentiment is not purchase intent. Keep personal identifiers out of the creative brief and do not upload unrestricted comment histories to an AI service.

Compare ordinary and low-performing posts, not only winners
The Posts view in Figure 2 is a useful presentation pattern: put the format badge, caption, visible interactions and publication date together so reviewers can inspect the evidence behind a ranking. Keep a source link for each post and mark unavailable thumbnails as unavailable. A polished grid is a navigation aid, not a substitute for the underlying records.
Within each account, format and comparable age band, inspect posts above, near and below the group median. Flag promotions and collaborations separately. With only two eligible posts, use descriptive comparisons rather than quartile labels or a “winning formula.”
The following coded cross-table uses the same fictional ExampleAlpha records as the calculation example, solely to demonstrate how to connect labels to results:
Post |
Format / label |
Visible rate |
Comparison |
Creative-review question |
|---|---|---|---|---|
a1 |
Reel / product-only demonstration |
3.00% |
Lower of two eligible Reels |
Is the benefit clear before product details? |
a2 |
Reel / person-led usage tutorial |
4.00% |
Higher of two eligible Reels |
Would a matched person-led demonstration help your audience? |
a3–a4 |
Carousel / step-by-step education |
5.00% each |
Two equally rated carousels |
Which unanswered question could make the sequence more useful? |
These labels are fictional annotations, not descriptions of real posts. A 1-percentage-point difference between a1 and a2 does not isolate the effect of a person appearing on screen. To form a brief, link a real observed objection to verified post references, document the content gap, and test one variable on your own account.
Copy this evidence-to-experiment record for each recommendation:
Evidence |
Finding |
Proposed test |
Owner / review |
Outcome |
|---|---|---|---|---|
Verified post IDs and anonymized objection references, with counts and capture context |
State the supported gap only |
One creative/CTA change; retain offer and audience where practical |
Name, review date, primary metric, minimum useful sample |
Fill from your own authorized analytics; leave blank before the test |
For example, a repeated delivery question plus no verified delivery explainer could justify testing one shipping carousel. Evaluate your own qualified clicks or resolved delivery enquiries, not an invented competitor sales lift.
6. Turn findings into an experiment
End the audit with an owner, a hypothesis, an action and a success measure you can observe on your own account:
| Observation | Hypothesis | Your next test | Decision measure |
|---|---|---|---|
| Relevant rivals repeatedly explain a customer problem in carousels | Clear step-by-step education may help your audience | Publish a small matched series of educational carousels | Your saves/reach and qualified clicks, where available |
| Competitors publish the same product claim without showing the process | Demonstration could differentiate the brand | Test process-led Reels against your existing creative | Your retention, qualified profile visits and downstream outcomes |
| Local-language captions address a different buying concern | Translation alone may not match the market | Test market-specific messaging with a controlled offer | Your own market-level conversion and feedback |
Keep the offer, audience and measurement window as consistent as practical. A content test is directional evidence unless the design supports a causal conclusion. Do not call competitor interaction counts proof of their revenue or a guaranteed lift for your brand.
Find the best tool for Instagram competitor analysis
The best tool for Instagram competitor analysis depends on the reporting job. For a no-cost starting point, use a consistent manual sample or an eligible free dashboard. For repeatable competitor comparisons, shortlist Fanpage Karma or Sotrender. For mention and reputation questions, consider Brand24. For querying public-profile tables with an AI connector, evaluate Windsor.ai.
These are different categories, not interchangeable scoreboards. The following shortlist is based on the providers’ published functions and plan descriptions checked on November 19, 2026. It does not rank model accuracy, historical completeness or connection success.
| Instagram competitor analysis tool | Best starting use case | Published offer / access distinction | Check before committing |
|---|---|---|---|
| Spreadsheet + native account analytics | A small audit and your own performance baseline | No additional analytics subscription for manual calculation; native fields depend on account access | Manual effort, capture consistency and separation of your metrics from competitor observations |
| Fanpage Karma | Public-profile comparisons and reporting workflow | Free plan lists 5 owned and 5 competitor profiles, one analytics dashboard and 30 days of history | Eligible Instagram profiles/fields, export access and add-ons for advanced benchmarking |
| Sotrender | Recurring competitor benchmarking and client reports | Paid plans distinguish basic analysis from interactive benchmarking; 7-day trial advertised | Profile allowance, historical coverage, retention and report functionality for the chosen tier |
| Brand24 | Brand mentions, conversation themes and reputation research | Social-listening subscription; 14-day trial advertised | Instagram source coverage, keyword scope, mention limits and sentiment review |
| Windsor.ai Instagram Public connector | Querying permitted public-account data through a connector | Provider’s guide advertises the first public account free; AI connector access may require a compatible account/plan | Field availability, snapshot history and the separate cost of the AI application |
Sources: Fanpage Karma plans, Sotrender pricing, Brand24 plans and Windsor.ai’s connector guide. A free trial is temporary; a free plan can still have account, field, history and export limits. Do not choose using a “starting from” figure without matching the actual competitor workload.
Free Instagram Competitor Analysis Tools: What Can You Actually Get?
Start with a small manual report and explicit definitions. Use your authorized professional-account dashboard for your own baseline. If it exposes native competitor comparisons, record the fields and reporting period actually displayed; availability varies by account.
Fanpage Karma’s published free tier is a concrete dashboard option to inspect. Windsor.ai’s first-account offer can help explore a public-data connector, but it is not automatically a free multi-brand AI stack. Check both the data connector and AI application’s terms before starting.
Open-source scrapers and hosted scraping platforms are not the same as an analytics dashboard or platform permission. Neither installation nor a publicly visible profile grants unlimited automated access. A controlled export-to-report workflow is often enough for a first analysis without adding account automation, follower harvesting or another maintenance-heavy collector.
Evaluate one tool against your actual report
Use the same two or three eligible accounts and one date range when evaluating a provider. Check a small number of source posts against exported fields, inspect missing-count handling and verify what “engagement rate” means. Ask whether history is backfilled or begins when tracking starts.
Separate report features from data coverage. A polished PDF does not fix missing carousels, a changed username or an unexplained denominator. The useful buying measure is the cost and analyst time required to produce an accepted report with traceable observations—not the largest raw number of profiles.
Match the plan to a three-competitor, 90-day report
For three competitor profiles, a 90-day view and an exported report, a 30-day free dashboard is insufficient. On the plan pages checked November 19, 2026:
| Candidate | Entry point for that workload | Important purchasing distinction |
|---|---|---|
| Fanpage Karma | Professional lists 12 months of history, up to 20 profiles/dashboard and CSV/PDF/PowerPoint exports | Configurable tagging/custom metrics use the Benchmarking & Content Analysis add-on; scheduled/white-label needs may add another module |
| Sotrender | Essential lists 5 profiles, 90 days and PDF/PPTX/XLS; Plus lists interactive competitor dashboards and longer history | Choose Essential for a basic exported comparison only if the required fields fit; choose Plus for the stated interactive comparison workflow |
| Brand24 | Select by tracked keywords, mentions and update/report needs | Not a substitute for a post-complete 90-day profile export; validate Instagram source coverage first |
| Windsor.ai | Multi-account connector entitlement plus a compatible destination/client | Ask for the exact field-level export; daily follower history starts with tracking, not automatic 90-day backfill |
The plan sources are linked above. Treat “history” as a product allowance, not proof that every old post or counter can be recovered. Before paying, ask the vendor to show the required accounts and a small permitted export from your date window.
| Acceptance question | What the purchase must explicitly answer |
|---|---|
| Account eligibility / login | Business/Creator versus personal; whether your own Meta professional account must connect; whether target permission is required |
| Reels, carousels and counters | Product-type field, hidden-like null handling, views definition, and whether comment text is included or needs separate access |
| History | Post backfill versus snapshots accumulated from connection; timezone and earliest usable date |
| Report | CSV/XLS/PDF format actually included; manual versus scheduled delivery; white label |
| Workflow | Interactive comparisons, custom tags, review permissions and team seats |
| Total cost | Base plan + profiles/brands + seats + tagging/report add-ons + connector/AI destination + tax/billing term |
If a quote or sample cannot answer a required field, do not mark the tool accepted for that workload. Use the manual template for the missing portion or change the scope; do not buy a cheap tier and assume export access will appear later.
Two additional candidates, checked against their own pages
Metricool’s pricing page lists a free plan with one brand, five competitor profiles and 30 days of analytics. Starter lists more competitors, reporting and longer history. Confirm Instagram eligibility and the precise export format; a free scheduling limit is not a competitor-data completeness guarantee.
Not Just Analytics’ subscription page separates profile comparison, smart-analysis sample size and export features by tier; CSV/Excel download is explicitly listed for Pro. Its temporary trial/promotion is not a permanent free reporting entitlement. Do not assume that three months of own-business data equals three months of complete competitor history. These distinctions make it an additional candidate to inspect, not an automatic cheaper replacement.
Get usable data before running the report
Free manual route: collect, validate and export
For a first report, no API or paid export is necessary. With permission to view and use the selected records, choose one account, a short publication window and a fixed observation time. In a spreadsheet, create the eight columns used below plus a separate evidence sheet.
- Open each permitted post and record its permalink, format, publication timestamp and observed likes/comments. Capture unavailable counts as blanks. If the interface only gives a rounded count or a relative date, mark that field for review rather than inventing precision.
- Record the account’s exact follower count at the same observation time, where available. This is a current snapshot, not the follower count when the post was published.
- Retain source reference, capture time, visible evidence and any manual format classification in the evidence sheet. Omit personal commenter names.
- Select one observation per post using the latest snapshot at or before a fixed cutoff. Keep older snapshots separately; do not sum snapshots as if they were different posts.
- Save UTF-8 CSV, check timestamps include offsets, and run the report. If a required field cannot be established, leave it missing or route the record to review. Do not invent a timestamp merely to make the script run.
The report expects exact integer counts, explicit Reel/carousel/image labels and timezone-aware timestamps. Manually inspecting three source rows against the exported file catches many locale, separator and column mistakes before a full report.

Tool route: map Windsor-style fields without guessing the export
Windsor.ai’s guide describes selecting Instagram Public, authorizing your own eligible Meta professional account, adding target usernames and connecting an MCP-compatible client. Query the documented fields as structured rows, not a prose summary. Retain retrieval UTC and an export reference. If the plan/client cannot return a downloadable table, copy an authorized small table into the manual template instead; do not assume a CSV button exists.
Use the connection screens in Figures 3–4 as a visual guide to the handoff:
- In Windsor, select Instagram Public, authorize the eligible source account and enter the target username in Account to follow.
- Open the Windsor.ai connector in Claude and choose Connect. Review the requested access and complete the account authorization; seeing the button alone does not establish that data is connected.
- In a new chat with the connector enabled, request a small structured table before asking for a narrative report. Check the returned account identities, date window and available fields.
For the first request, use: “For the selected accounts and publication window, return one row per post with media_permalink, media_timestamp, media_type, media_product_type, media_like_count, media_comments_count and the current profile_followers_count. Preserve missing values and state the retrieval time.” Keep that current follower snapshot distinct from historical followers at publication. Then apply the mapping and validation below before producing comparisons.
| Local field | Documented source / supplied metadata | Mapping rule |
|---|---|---|
| account | profile_username | Stable profile key; keep source IDs separately |
| post_id | media_permalink | Use canonical path; drop tracking query parameters |
| format | media_type + media_product_type | REELS → reel; CAROUSEL_ALBUM → carousel; IMAGE → image; ambiguous VIDEO → review |
| published_at | media_timestamp | Require explicit timezone; convert to UTC |
| observed_at | export_observed_at, supplied with the capture | Actual retrieval time, never publication time |
| followers_at_observation | profile_followers_count | Match the capture; never call it followers-at-publication |
| likes / comments | media_like_count / media_comments_count | Exact integers or blanks; no silent 1.2K → 1200 conversion |
The provider field names come from the connector guide linked in the tool section. export_observed_at and source_reference are local audit columns you add, not promised connector fields. Current profile values joined to old media timestamps remain current denominators. Historical follower snapshots begin accumulating from connection; do not backfill them by relabeling today’s count.
Save the mapped source table as provider_export.csv. The adapter below enforces the documented field contract, preserves review rows and chooses the latest observation on/before the cutoff. Its fixture tests demonstrate that contract, not compatibility with every vendor export layout.
Complete export adapter — save as instagram_export_adapter.py
"""Map documented Windsor-style CSV columns; no login, API or network requests."""
import argparse
import csv
import json
from pathlib import Path
from urllib.parse import urlsplit
from instagram_competitor_report import timestamp, count
FIELDS = ["account", "post_id", "format", "published_at", "observed_at",
"followers_at_observation", "likes", "comments"]
def exact_count(value):
value = (value or "").strip()
if value.lower() in {"", "null", "none", "n/a", "hidden"}:
return ""
try:
return str(count(value))
except ValueError:
return "" # Rounded/uncertain values remain missing, never invented precision.
def normalize(rows, cutoff):
limit = timestamp(cutoff)
selected, review, lineage = {}, [], []
for number, row in enumerate(rows, 2):
try:
if not row["source_reference"].strip():
raise ValueError("missing_source_reference")
account = row["profile_username"].strip().lstrip("@")
link = urlsplit(row["media_permalink"].strip())
if not account or link.scheme != "https" or link.hostname not in {"www.instagram.com", "instagram.com"}:
raise ValueError("missing_account_or_permalink")
# Preserve the canonical path, not tracking query parameters.
post_id = link.path.rstrip("/")
if not post_id.startswith(("/p/", "/reel/", "/tv/")):
raise ValueError("unrecognized_permalink")
observed = timestamp(row["export_observed_at"])
published = timestamp(row["media_timestamp"])
if observed < published:
raise ValueError("observation_before_publication")
if observed > limit:
continue
media = row["media_type"].upper().strip()
product = row["media_product_type"].upper().strip()
if product == "REELS":
fmt = "reel"
elif media == "CAROUSEL_ALBUM":
fmt = "carousel"
elif media == "IMAGE":
fmt = "image"
else:
raise ValueError("unclassified_video")
result = dict(zip(FIELDS, [account, post_id, fmt, published.isoformat(), observed.isoformat(),
exact_count(row["profile_followers_count"]), exact_count(row["media_like_count"]),
exact_count(row["media_comments_count"])]))
key = (account, post_id)
old = selected.get(key)
if old and timestamp(old["observed_at"]) == observed and old != result:
raise ValueError("conflicting_same_time_snapshot")
if old is None or observed > timestamp(old["observed_at"]):
selected[key] = result
lineage.append({"input_row": number, "account": account, "post_id": post_id,
"observed_at": observed.isoformat(), "source_reference": row["source_reference"]})
except (KeyError, ValueError) as exc:
reason = str(exc) if type(exc) is ValueError else "missing_column"
if reason == "conflicting_same_time_snapshot":
raise
review.append({"input_row": number, "reason": reason})
return list(selected.values()), {"observation_rule": "latest snapshot on/before cutoff",
"cutoff": cutoff, "lineage": lineage, "excluded_rows": review}
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("input_csv")
parser.add_argument("output_dir")
parser.add_argument("--cutoff", required=True)
args = parser.parse_args()
with open(args.input_csv, newline="", encoding="utf-8-sig") as stream:
records, audit = normalize(list(csv.DictReader(stream)), args.cutoff)
out = Path(args.output_dir)
if out.exists():
raise ValueError("choose_fresh_output_directory")
out.mkdir(parents=True)
with (out / "normalized.csv").open("x", newline="", encoding="utf-8") as stream:
writer = csv.DictWriter(stream, fieldnames=FIELDS)
writer.writeheader()
writer.writerows(records)
(out / "mapping-audit.json").write_text(json.dumps(audit, indent=2), encoding="utf-8")
print(json.dumps({"normalized_posts": len(records), "excluded_rows": len(audit["excluded_rows"])}))
py .\instagram_export_adapter.py .\provider_export.csv .\mapped-run-001 --cutoff 2026-11-19T12:00:00Z
py .\instagram_competitor_report.py .\mapped-run-001\normalized.csv --start 2026-11-01T00:00:00Z --end 2026-11-15T00:00:00Z |
Out-File -FilePath .\competitor_report.json -Encoding utf8
macOS/Linux uses python3 and forward-slash paths; save output with > competitor_report.json. Keep mapping-audit.json, the untouched source export and the report together. Review excluded rows before interpreting coverage. A missing timezone or unclassified video is a reason to correct the source metadata, not to substitute a guessed value.


Published-source check: what Meta’s actual documentation supplies
Meta’s published Business Discovery sample contains these media counts, reproduced here as a documentation fixture, not as current observations of the account or an API request made for this article:
Source media ID |
Likes |
Comments |
Returned views |
Derived visible interactions |
|---|---|---|---|---|
17858843269216389 |
5,837 |
50 |
7,757 |
5,887 |
17894036119131554 |
2,997 |
11 |
blank |
3,008 |
17894449363137701 |
3,643 |
28 |
blank |
3,671 |
17844278716241265 |
4,943 |
43 |
blank |
4,986 |
The counts were transcribed from the official sample and the interaction sums were recomputed locally. Only one of four records includes views. The sample does not supply the publication times, formats and matching observation-time follower snapshots needed for this report’s rates. All four therefore stay outside the rate-ready dataset. The fictional CSV below provides complete inputs for testing; it must not be merged with these external sample counts.
A practical report you can reproduce for free
The following small dataset uses fictional ExampleAlpha and ExampleBeta accounts to demonstrate the calculation. It is a transparent worked example, not a benchmark for real brands. Nine posts are observed; eight have complete counts and meet the maturity rule. One missing-like record stays in the observed sample but is excluded from rate calculations.
Create competitor_sample.csv:
account,post_id,format,published_at,observed_at,followers_at_observation,likes,comments
ExampleAlpha,a1,reel,2026-11-02T12:00:00Z,2026-11-18T12:00:00Z,10000,280,20
ExampleAlpha,a2,reel,2026-11-05T12:00:00Z,2026-11-18T12:00:00Z,10000,370,30
ExampleAlpha,a3,carousel,2026-11-08T12:00:00Z,2026-11-18T12:00:00Z,10000,460,40
ExampleAlpha,a4,carousel,2026-11-11T12:00:00Z,2026-11-18T12:00:00Z,10000,450,50
ExampleBeta,b1,reel,2026-11-02T12:00:00Z,2026-11-18T12:00:00Z,20000,460,40
ExampleBeta,b2,reel,2026-11-05T12:00:00Z,2026-11-18T12:00:00Z,20000,650,50
ExampleBeta,b3,carousel,2026-11-08T12:00:00Z,2026-11-18T12:00:00Z,20000,370,30
ExampleBeta,b4,carousel,2026-11-11T12:00:00Z,2026-11-18T12:00:00Z,20000,560,40
ExampleBeta,b5,carousel,2026-11-12T12:00:00Z,2026-11-18T12:00:00Z,20000,,20
The snapshot denominators are 10,000 and 20,000 followers. All timestamps are UTC; publication dates are filtered to November 1 inclusive through November 15 exclusive. The script groups formats rather than blending Reels and carousels into one brand score.
Save the following as instagram_competitor_report.py. It uses only Python’s standard library and analyzes a local export; it does not log in to Instagram, collect posts or require API keys.
Complete local report script — expand to copy
The local examples were executed with Python 3.12.14. Use that interpreter for the supplied scripts and keep the output with the source records.
"""Analyze an authorized export; does not connect to Instagram or collect data."""
import csv
import json
from collections import defaultdict
from datetime import datetime, timezone
from decimal import Decimal
from statistics import median
def timestamp(value):
parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
if parsed.tzinfo is None:
raise ValueError("timezone_required")
return parsed.astimezone(timezone.utc)
def count(value):
if value == "":
return None
if not value.isascii() or not value.isdigit():
raise ValueError("invalid_count")
return int(value)
def analyze(rows, start="2026-11-01T00:00:00Z", end="2026-11-15T00:00:00Z"):
lower, upper = timestamp(start), timestamp(end)
if lower >= upper:
raise ValueError("invalid_window")
groups = defaultdict(lambda: {"sample_posts": 0, "rates": [], "review_posts": 0,
"review_reasons": defaultdict(int)})
seen = set()
for row in rows:
identity = (row["account"], row["post_id"])
if not all(identity) or identity in seen:
raise ValueError("empty_or_duplicate_post")
seen.add(identity)
if row["format"] not in {"reel", "carousel", "image"}:
raise ValueError("unknown_format")
published, observed = timestamp(row["published_at"]), timestamp(row["observed_at"])
if observed < published:
raise ValueError("observation_before_publication")
followers, likes, comments = [count(row[k]) for k in
("followers_at_observation", "likes", "comments")]
if not lower <= published < upper:
continue
group = groups[(row["account"], row["format"])]
group["sample_posts"] += 1
reasons = []
if (observed - published).total_seconds() < 72 * 3600:
reasons.append("immature_post")
if followers is None or followers == 0:
reasons.append("missing_or_zero_followers")
if likes is None or comments is None:
reasons.append("missing_count")
if reasons:
group["review_posts"] += 1
for reason in reasons:
group["review_reasons"][reason] += 1
continue
group["rates"].append(Decimal(likes + comments) / Decimal(followers) * 100)
totals = defaultdict(int)
for (account, _), values in groups.items():
totals[account] += values["sample_posts"]
weeks = Decimal(str((upper - lower).total_seconds())) / Decimal(604800)
return [{"account": account, "format": fmt, "sample_posts": values["sample_posts"],
"eligible_posts": len(values["rates"]), "review_posts": values["review_posts"],
"review_reasons": dict(values["review_reasons"]),
"format_share_percent": format(Decimal(values["sample_posts"]) / totals[account] * 100, ".2f"),
"eligible_coverage_percent": format(Decimal(len(values["rates"])) / values["sample_posts"] * 100, ".2f"),
"observed_posts_per_week": format(Decimal(values["sample_posts"]) / weeks, ".2f"),
"median_visible_er_percent": format(median(values["rates"]), ".2f")
if values["rates"] else None}
for (account, fmt), values in sorted(groups.items())]
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("input_csv")
parser.add_argument("--start", default="2026-11-01T00:00:00Z")
parser.add_argument("--end", default="2026-11-15T00:00:00Z")
args = parser.parse_args()
with open(args.input_csv, newline="", encoding="utf-8-sig") as source:
result = analyze(list(csv.DictReader(source)), args.start, args.end)
print(json.dumps(result, indent=2))
Windows PowerShell:
py .\instagram_competitor_report.py .\competitor_sample.csv
macOS/Linux:
python3 instagram_competitor_report.py competitor_sample.csv
For an authorized export covering another period, pass timezone-aware --start and --end values. Keep the field contract; a blank count represents missing data, while the string 0 represents an observed zero.
The executed example returned:
Account |
Format |
Observed posts |
Eligible posts |
Review posts |
Median visible interaction rate |
|---|---|---|---|---|---|
ExampleAlpha |
Carousel |
2 |
2 |
0 |
5.00% |
ExampleAlpha |
Reel |
2 |
2 |
0 |
3.50% |
ExampleBeta |
Carousel |
3 |
2 |
1 |
2.50% |
ExampleBeta |
Reel |
2 |
2 |
0 |
3.00% |
The same 14-day sample also produces these quality and activity fields:
| Account / format | Share of observed account posts | Rate-eligible coverage | Observed posts per week |
|---|---|---|---|
| ExampleAlpha / Carousel | 50.00% | 100.00% | 1.00 |
| ExampleAlpha / Reel | 50.00% | 100.00% | 1.00 |
| ExampleBeta / Carousel | 60.00% | 66.67% | 1.50 |
| ExampleBeta / Reel | 40.00% | 100.00% | 1.00 |
Overall eligibility is 8/9 = 88.89%; missing likes affect 1/9 = 11.11%. These describe the fictional sample, not the industry. Weekly counts divide observed posts by the full window length; format share uses observed posts in that account, and coverage uses eligible/observed posts within the group. review_reasons distinguishes missing counts, missing/zero followers and immature posts. Reasons may overlap for one post, so do not sum them as unique exclusions. The script does not infer account-wide posting frequency from an incomplete export.
The missing-like post does not become a low-performing carousel. In this example, ExampleAlpha’s carousels merit qualitative review, but two eligible posts are not enough to establish a dependable format advantage. Inspect themes and capture age, then test a relevant idea on your own account. The script checks structure and calculation; it does not establish whether an imported count is accurate or licensed. It additionally reports format share, eligible-data coverage and observed posts per week. Those use the selected export, not a claim of complete account coverage; follower growth still requires a separate two-date snapshot table.

Can the Instagram API provide competitor data?
Meta’s Business Discovery documentation describes basic metadata and metrics for other eligible Instagram professional accounts. Its examples include follower/media counts and media queries; age-gated professional accounts are excluded. The access route, app permissions and account eligibility matter, so use the current endpoint reference rather than assuming any username can be queried with any token.
The current example includes view_count, which combines paid and organic views and is absent from some returned records. It is not unique reach; do not mix views, plays or impressions across sources or derive ROAS from them. Some media_url values are omitted because of ownership, audio/copyright or download restrictions. Metadata access is not a promise that an AI tool can fetch and inspect the video. Match account eligibility, API version and fields before using a connector.
Regional analysis: compare campaigns, not presumed IP effects
For a multinational brand, record the country-specific account, language, product availability, local events, landing-page offer and capture time. A separate regional account is stronger evidence of a localized content strategy than one visitor seeing a different recommended feed.
Use Meta Ad Library to inspect available ad creative and the country/platform filters provided by the interface. Record the advertiser, ad reference, selected filters and date. Available disclosures differ by category and region; do not assume that ordinary commercial ads reveal complete spend, targeting, reach or ROAS.
An observed browsing difference can reflect login state, language, personalization, consent, time or experiment assignment as well as the network route. It does not prove that an IP change unlocked every regional campaign or reproduced a typical resident’s feed.
| Regional-check field | What to record |
|---|---|
| Account and source | Regional brand profile, permitted public page or ad-library reference |
| Market and language | Intended country, interface language, caption language and selected filters |
| Browsing context | Logged-in/out state, browser/app version and consent state |
| Route context | Direct versus configured route and diagnostic result, kept in restricted logs |
| Observation | Exact content/offer seen, UTC time and whether access was refused |
Change one factor at a time where practical and keep explanations provisional. Never infer a competitor’s actual ad-targeting rules or audience nationality solely from your exit IP.
A cross-border brief that connects research to a network task
Record a verified local-language question or offer with its source reference and date. Locate the associated regional account, public ad or permitted landing page. If the task requires a selected route, configure that specific client’s country/session and record diagnostics. Check the displayed currency, shipping coverage, delivery timing, returns, offer and CTA destination while holding language/login/consent as consistent as practical. Recommend one localization experiment and measure it through your own business data; do not fill in an improvement percentage before running the test.
The network task records what appeared under specified conditions. The marketing task decides whether that observation supports a content or landing-page change.

Configure and verify one specific client: Requests 2.34.2
This path uses Python Requests 2.34.2 with PySocks 1.7.1, not an unspecified browser. It solves proxy authentication, destination-DNS choice, diagnostic-country checking and short-flow route-continuity checks. It does not change a hosted analytics provider’s server-side collection route. Local CSV analysis needs no proxy.
For a permitted client workflow, select the current Socks5.IO product, create a traffic-capped proxy sub-account and open that product’s Proxy Setup. Generate the country and session configuration there. Do not transplant a legacy endpoint, another brand’s username syntax or a session duration from an unrelated product page.
| Client input | Where it goes in Requests | Check |
|---|---|---|
| Protocol | Scheme of SOURCE_PROXY_URL: http:// or socks5h:// |
Match the product’s generated protocol/port |
| Host | Host component of that URL | Generated gateway hostname, not a resolved gateway IP presented as an exit |
| Port | Port component | Generated for this product/protocol, not an assumed default |
| Username / password | URL-encoded userinfo loaded from your secret manager | Full proxy username with generated country/session parameters; never console login |
| Route binding | client.proxies for both http and https |
client.trust_env=False; no silent direct fallback |
URL shape: socks5h://<ENCODED_PROXY_USER>:<ENCODED_PROXY_PASSWORD>@<GENERATED_GATEWAY>:<GENERATED_PORT>. Encode username/password separately, including reserved characters such as @, : or #. Keep the complete value private as SOURCE_PROXY_URL; do not print it in the report.
Requests supports proxy credentials through this URL; the SOCKS dependency supplies SOCKS5 username/password negotiation. In Requests, socks5h delegates destination DNS to the proxy. HTTPS destinations through an HTTP proxy use CONNECT. See the Requests proxy reference.
Chrome is a different client. Its native SOCKSv5 implementation does not support proxy authentication, so a username/password SOCKS5 endpoint cannot be assumed to work there. Chrome also does not consume credentials embedded in manual proxy settings. Use a compatible authenticated HTTP setup, another explicitly supported authentication mode, or a verified integration—not a guessed native SOCKS5 recipe. Chromium’s proxy documentation
| Task | Network choice | Acceptance focus |
|---|---|---|
| Local CSV or hosted analytics | No client-side proxy for calculation/provider collection | Data coverage and export contract |
| Permitted country-specific request | Country-selected route only if needed | Country, protocol, diagnostic result and traffic |
| Related short requests | Continuity within current session settings | Repeated diagnostics, idle boundary and required duration |
| Recurring need for the same assigned exit | Confirm appropriate assigned/static product | Assignment period and client authentication |
For a permitted short task, evaluate rotating residential proxies against country, session and authentication needs. Total cost includes the analytics plan, add-ons/AI destination, routing and human review. Routing cost uses the applicable purchased plan and supplier-metered traffic—not a bulk headline rate or saved JSON bytes.

Run a diagnostic baseline and a bounded proxy check
Install the named client using the same interpreter you will run:
py -m venv .venv
.\.venv\Scripts\python.exe -m pip install "requests[socks]==2.34.2" "PySocks==1.7.1"
Save this as instagram_route_check.py. It only calls the diagnostic endpoint; it never requests Instagram. It records IP hashes for comparison, not complete addresses or credentials. Populate the proxy secret through your existing secret-management process before selecting proxy mode.
Complete diagnostic script — save as instagram_route_check.py
"""Bounded diagnostic-only route check; never requests Instagram."""
import argparse
import hashlib
import ipaddress
import json
import os
import time
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlsplit
import requests
def make_client(mode):
client = requests.Session()
client.trust_env = False
if mode == "proxy":
proxy = os.environ["SOURCE_PROXY_URL"]
parsed = urlsplit(proxy)
if (parsed.scheme not in {"http", "socks5h"} or not parsed.hostname or not parsed.port
or not parsed.username or not parsed.password):
raise ValueError("invalid_generated_proxy_url")
client.proxies.update({"http": proxy, "https": proxy})
return client
def diagnostic(client):
with client.get("https://ipinfo.io/json", timeout=(10, 20), stream=True,
allow_redirects=False) as response:
if response.status_code != 200:
raise ValueError("diagnostic_http_" + str(response.status_code))
if "json" not in response.headers.get("Content-Type", "").lower():
raise ValueError("diagnostic_mime")
body = bytearray()
for chunk in response.iter_content(4096):
body.extend(chunk)
if len(body) > 65536:
raise ValueError("diagnostic_size")
data = json.loads(body)
address = str(ipaddress.ip_address(data["ip"]))
return {"utc": datetime.now(timezone.utc).isoformat(),
"ip_sha256": hashlib.sha256(address.encode()).hexdigest(),
"country": data.get("country"), "decoded_body_bytes": len(body)}
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("mode", choices=["direct", "proxy"])
parser.add_argument("output_file")
parser.add_argument("--country")
parser.add_argument("--samples", type=int, choices=range(1, 4), default=1)
args = parser.parse_args()
target = Path(args.output_file)
if target.exists():
raise ValueError("choose_fresh_output_file")
report = {"mode": args.mode, "requests_version": requests.__version__, "checks": []}
try:
with make_client(args.mode) as client:
for i in range(args.samples):
if i:
time.sleep(2)
row = diagnostic(client)
report["checks"].append(row)
if args.country and row["country"] != args.country:
raise ValueError("diagnostic_country_mismatch")
report["status"] = "diagnostic_checks_completed"
report["same_diagnostic_ip"] = len({x["ip_sha256"] for x in report["checks"]}) == 1
except Exception as exc:
# No raw exception text, credentials, complete IPs or request URLs in output.
report.update(status="stopped", error_class=type(exc).__name__)
if type(exc) is ValueError and (str(exc) in {"diagnostic_country_mismatch", "diagnostic_mime", "diagnostic_size"}
or str(exc).startswith("diagnostic_http_") and str(exc)[16:].isdigit()):
report["failure_code"] = str(exc)
with target.open("x", encoding="utf-8") as stream:
json.dump(report, stream, indent=2)
print(json.dumps(report, indent=2))
.\.venv\Scripts\python.exe .\instagram_route_check.py direct .\direct-check.json
.\.venv\Scripts\python.exe .\instagram_route_check.py proxy .\proxy-check.json --country US --samples 3
Use .venv/bin/python and forward-slash paths on macOS/Linux. Choose fresh output filenames. The three proxy checks are spaced two seconds apart; that short diagnostic series is not a stress test or a guarantee of session lifetime.
Compare the baseline and proxy hashes, expected country and repeated hashes in the proxy series. A matching baseline/proxy hash can indicate routing failed or a shared exit and requires investigation; a changed hash alone does not establish success. In a sticky workflow, unexpected changes within the required interval trigger review. In intentional rotation, different hashes are expected. Keep generated configuration constant while checking continuity.
The gateway resolves to the server your client connects to. Its DNS address is not necessarily the exit seen by a destination. The diagnostic result describes that diagnostic request; even a matching country and three equal hashes do not establish the exact exit of an Instagram request, platform access or a resident’s personalized feed. Verify each actual client separately—Python diagnostics do not validate Chrome’s configuration.

Acceptance record: keep network evidence separate from marketing evidence
Fill this record from the actual run; do not turn placeholders into successful measurements:
| Item | Evidence to enter | Accept / review rule |
|---|---|---|
| Client and route | Requests/PySocks versions, product/session setting reference, no secrets | Match the selected supported protocol and authentication |
| Direct baseline | UTC, diagnostic hash, country, connection result | Establish the non-proxied context with environment proxies disabled |
| Configured route | UTC, intended country, observed country, diagnostic hash | Resolve mismatch before any regional conclusion |
| Short-flow continuity | Three timestamped hashes using the same configuration | Interpret against sticky versus rotating intent |
| Traffic | Supplier meter before/after, elapsed interval and other concurrent jobs | Supplier meter is the billing reference; decoded response bytes are not billable GB |
| Error ownership | HTTP proxy auth, SOCKS negotiation, diagnostic endpoint, target site or account | Correct the failing layer; do not switch identities to defeat refusal |
| Source observation | Permitted source, time, login/language/consent and exact displayed result | A network pass is not a content-access or data-quality pass |
HTTP 407 is an HTTP-proxy authentication response. SOCKS5 negotiation/authentication failures may surface as a client ProxyError without HTTP 407. Source 403/429 and account checkpoints belong to different layers; stop and follow the applicable source/account process. Do not rotate to make them disappear.
Socks5.IO documentation and product pages can describe different session settings. Generate and confirm the setting for the purchased product; this workflow does not assume either a universal 10-minute or 90-minute session. For recurring logins versus short continuity, the static versus rotating proxy guide explains the conceptual difference without substituting for current product settings.
How to check Instagram competitor analysis results before publishing
| Check | Pass condition |
|---|---|
| Identity and window | Verified accounts/post references; same publication bounds and capture rules |
| Coverage | Observed, eligible and review counts; missing reasons disclosed |
| Interpretation | Formats and age bands separated; ordinary/low examples included |
| Recommendation | Traceable evidence → one test; no fabricated competitor revenue or lift |

A weekly report that leads to action
Keep the final brief to one page: a fixed competitor set, data window, coverage/missingness, format-level results, three annotated examples and one proposed experiment. Retain the source references behind the brief rather than pasting raw comment histories or personal identifiers into a shared AI workspace.
Borrow the visual hierarchy in Figure 10, rather than its sample numbers: identify the account and period first, show a small set of clearly defined metrics, and place the post-level evidence in a separate view. For this article’s dataset, the useful summary cards are 9 observed posts, 8 eligible posts and 1 post requiring review. The format chart then reports each account’s median and eligible sample count. Leave follower growth and previous-period change out unless matching snapshots exist; the sample report’s growth badges are not results from our dataset.
Use color consistently: one color per account, a separate warning color for missing data, and neutral styling for context. Give every percentage its denominator and period. A report is ready to share when a reviewer can move from a summary claim to its supporting rows—not merely when the dashboard looks finished.
| Weekly brief field | Fill from evidence |
|---|---|
| Objective / market / cohort | Buyer question, country/language and selected competitors |
| Period / coverage | Window, capture times, observed/eligible posts and missing reasons |
| Results | Posts/week, format share, matched-format median and sample count |
| Three observations | Source IDs, themes and both higher/lower examples |
| Next test | Owner, review date, primary metric and result when available |
| Optional region appendix | Configured client, diagnostic record and browsing context |
Use 7-day change monitoring, a 30-day editorial review or a longer seasonal view according to the business question; these are planning choices, not statistical minimums.
AI can help label themes and draft a summary from approved records. Require it to cite post IDs, preserve missing metrics and distinguish observations from hypotheses. It should not invent reach, sentiment certainty or a performance reason that the dataset cannot establish. Verify the arithmetic outside the generated narrative.
Copy this analysis prompt after computing the metrics:
Use only the attached approved records and precomputed rates.
List the cohort, window, capture times, sample counts and missing fields first.
Compare formats and comparable post-age bands; include ordinary and low examples.
For every content or objection finding, cite post IDs and supporting evidence.
Separate UGC, creator collaborations, promotions and unknown paid status.
Keep ambiguous sentiment for human review; do not infer purchase intent.
Return three evidence-backed findings and one experiment with an owner,
primary measure and review date. Leave outcome blank until our own test runs.
Do not invent reach, saves, follower history, demographics, sales or causation.
Conclusion
A strong Instagram competitor analysis uses comparable accounts, traceable data and consistent metrics to produce a content decision. Start with a small report, separate public observations from private analytics, and evaluate tools against the exact workflow you need.
Run one relevant content experiment, measure it through your own authorized analytics, and revisit the competitor set as the market changes. Where an approved regional task needs a particular network route, configure Socks5.IO with a dedicated traffic-capped proxy user and the appropriate session settings. Keep that route decision separate from your analytics-tool purchase and the evidence supporting the marketing recommendation.











