Guides

Instagram Competitor Analysis: Tools and a Practical Workflow

Build an Instagram competitor analysis with fair metrics, free and paid tools, a reproducible report and regional checks. Turn content patterns into tests.

Gideon ReedGideon Reed32 min read

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.
evidence-map

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:

texttext
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.

post-grid

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.

  1. 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.
  2. 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.
  3. Retain source reference, capture time, visible evidence and any manual format classification in the evidence sheet. Omit personal commenter names.
  4. 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.
  5. 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.

windsor-connection

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:

  1. In Windsor, select Instagram Public, authorize the eligible source account and enter the target username in Account to follow.
  2. 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.
  3. 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
pythonpython
"""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"])}))
powershellpowershell
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.

claude-connector
adapter-results

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:

csvcsv
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.

pythonpython
"""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:

powershellpowershell
py .\instagram_competitor_report.py .\competitor_sample.csv

macOS/Linux:

bashbash
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.

grouped-results

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.

subaccount

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.

proxy-setup

Run a diagnostic baseline and a bounded proxy check

Install the named client using the same interpreter you will run:

powershellpowershell
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
pythonpython
"""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))
powershellpowershell
.\.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.

client-compatibility

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
report-overview

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:

texttext
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.

FAQs

Choose the tool that matches the decision you need to make. Fanpage Karma and Sotrender suit competitor benchmarking and recurring reports, while Brand24 focuses on mentions and conversation research. A public-data connector can support structured AI queries, and a spreadsheet can handle a small audit. Check eligible profiles, historical coverage, missing metrics, export access and the exact plan before paying. Compare the same accounts and date range rather than relying on a universal ranking.

Latest articles

Global proxy network illustration

Plug into the global proxy network — every connection faster and more stable

Start for Free