Competitor Intel

End-to-end competitor research and monitoring. Define the set, pull from every public surface that matters, diff against last run (or your own), and produce a brief that's actually useful — battle card, weekly digest, board update, or comparison-page input.

Out of scope — defer to other skills

competitor-intel is the integration layer — it pulls from every source and synthesizes. It uses HyperSEO for the rank/backlink/intersection slice but isn't the SEO research skill itself.

Requirements

• Hyper MCP installed and connected. https://app.hyperfx.ai/mcp
• At least one of these toolkits connected at https://app.hyperfx.ai/apps:
  • Firecrawl (highly recommended — backbone for any site/blog/pricing-page work)
  • HyperSEO (needed for rank, backlink, domain-overlap analysis)
  • Apify scrapers — Instagram, TikTok, LinkedIn, Twitter, Reddit, Google search, Google Trends
  • Image generation (optional — only if the brief feeds a comparison-page or battle-card asset downstream)

If no tool with those prefixes is found (firecrawl_*, hyperseo_*, instagram_scrape*, tiktok_*_scrape, x_tweets_search, reddit_scrape*, google_search_results_search, google_trends_scrape, web_pages_fetch), the toolkits to enable are Firecrawl and at least one social scraper. The LinkedIn scraper (scrape_linkedin_profiles) is only present when that specific integration is enabled — gracefully skip the LinkedIn slice if it's missing rather than failing the whole brief.

How to run the tools in this skill

Every tool in this skill is named by its canonical tool name. Run it with the call your surface gives you:

If a tool is not found: in Hyper chat, find its toolkit id with discover_toolkits and pass it to enable_toolkit. On an MCP client or the CLI, tell the user which integration to connect in Hyper.

Tool surface

Critical rules

1. Public-only data. Never scrape behind login walls or paywalls. If a target is gated, stop and surface that — don't try to bypass.
2. Pick the competitor set before scraping. 3–5 competitors is the sweet spot. 10+ produces an unreadable brief and burns scraper credits. If the user doesn't have a list, run hyperseo_competitors_search(domain=<their_domain>) first to surface the top organic competitors, then confirm the set with them.
3. Snapshot, then diff. First run is just a baseline — there's nothing to compare against. The value compounds on the second and third runs (what changed in pricing, what new posts went up, who lost rank). Make this expectation clear when the user runs it for the first time.
4. HyperSEO is credit-metered. Be intentional. Don't loop hyperseo_domain_overview_get over 12 competitors when you only need 4. Each call has cost — batch and cache.
5. Apify scrapers can be slow and rate-limited. Don't kick off 8 scrapes in parallel. Sequence them, and surface partial results to the user as they arrive instead of waiting for the full run.
6. Snapshot what you scraped, not just the analysis. Always include the source URL, scrape timestamp, and a short excerpt for any claim in the brief — otherwise next week's diff has nothing to compare against and the brief becomes unfalsifiable.
7. Don't over-interpret single data points. "Competitor X dropped a Reel that got 12K likes" is noise. "Competitor X has averaged 8K likes/post for the last 30 days, up from 2K" is signal. Build comparisons on aggregates, not anecdotes.
8. Stay clearly factual. Use neutral language ("Competitor X published Y on date Z, copy reads as…") not value judgments ("Competitor X's strategy is broken…"). The brief is intel, not opinion.
9. Disambiguate brand-name SERPs. A search for <competitor> alone often returns unrelated results that share the brand name (e.g. a search for "hyperfx" returns mostly HyperX headphones, not hyperfx.ai). Always pair the brand with a category modifier — <competitor> alternative, <competitor> reviews, <competitor> pricing, <competitor> vs <us> — to get clean SERPs.
10. Apify-backed scrapers fail intermittently. Expect occasional "fetch failed" or empty-result responses from instagram_scrape*, tiktok_*_scrape, reddit_scrape*, google_trends_scrape, x_tweets_search, and google_search_results_search. Retry once after a short delay before reporting the source as missing — and surface partial results to the user rather than failing the whole brief if a scraper stays down.

Workflow

Phase 1 — Define the competitor set

Ask the user (or infer):

1. Their domain — needed to ground all relative comparisons.
2. Their competitor set — 3–5 names + domains. If unclear, surface the top organic competitors. hyperseo_competitors_search takes the keywords the user wants to win, not their domain — so first agree on 3–5 high-intent keywords for the user's category, then run:

hyperseo_competitors_search(
  keywords=["<category keyword 1>", "<category keyword 2>", "<category keyword 3>"],
  location_code=2840,  # 2840=US, 2826=UK, 2124=CA, 2036=AU
  limit=10
)

Then confirm the surfaced set with the user before continuing — never guess and proceed.

3. The job — what is this brief for? The shape changes by job:
   • Battle card for sales → focus on positioning, pricing, "what to say when…" objection lines.
   • Weekly digest for marketing/exec team → focus on what changed this week.
   • Comparison-page input for marketing → focus on objective, comparable feature/pricing data.
   • Board / board-prep update → focus on aggregate position (share of voice, rank deltas, growth).
4. The cadence — one-shot or recurring? Recurring scopes the source matrix tighter so each run completes in reasonable time.

If the user can't answer #3, stop and ask. Building intel without knowing the artifact is a guaranteed waste.

Phase 2 — Build the source matrix

Not every source matters for every competitor or every job. Per-competitor, decide which surfaces to pull from.

The full per-source playbook (when to use, what it reveals, quirks) lives in references/source-by-source.md. Read it only when a source call fails or returns nothing; the brief needs only references/brief-templates.md.

Phase 3 — Pull the data

Sequence the pulls; don't fire everything in parallel. Order matters for cost and for letting partial results inform the next call.

Order to use:

1. Cheapest first — HyperSEO baselines (one call per competitor, reuse data across the brief):

hyperseo_domain_overview_get(domain="<competitor>.com", location_code=2840)
hyperseo_domain_keywords_get(domain="<competitor>.com", limit=50, location_code=2840)
hyperseo_domain_intersections_search(
  domain1="yourbrand.com",
  domain2="<competitor>.com",
  limit=50,
  location_code=2840
)

2. Site content via Firecrawl:

firecrawl_urls_scrape(url="https://<competitor>.com/pricing")
firecrawl_urls_scrape(url="https://<competitor>.com/")
firecrawl_branding_extract(url="https://<competitor>.com")  # logo, colors, voice

For a full-blog-archive deep dive use firecrawl_websites_crawl once and check status with firecrawl_crawls_status_check. If Firecrawl returns near-empty for a JS-heavy SPA, open a browser with browser_sessions_create(), go to the page with browser_navigate(url=...) and read it with browser_a11y_tree().

3. Social — sequenced per platform (note: most scrapers take arrays of identifiers, not a single username):

instagram_scrape(direct_urls=["https://www.instagram.com/<competitor>/"], results_type="posts", results_limit=30)
instagram_followers_count_scrape(usernames=["<competitor>"])  # cheap, do it weekly
tiktok_videos_scrape(profiles=["<competitor>"], results_per_page=30)
x_tweets_search(from_user="<competitor_handle>", max_items=50)

# Only if scrape_linkedin_profiles is found:
scrape_linkedin_profiles(urls=["https://www.linkedin.com/company/<competitor>"])

4. Sentiment & demand:

reddit_scrape(searches=["<competitor>"], max_items=50, sort="new", time="month")
google_trends_scrape(
  search_terms=["<competitor>", "yourbrand"],
  time_range="today 3-m",  # options: now 7-d, today 1-m, today 3-m, today 5-y, all
  geo="US"
)
google_search_results_search(query="<competitor> reviews", num_results=20, country="us")

5. AI search visibility (only for SaaS/B2B usually):

# AI Overview takes ONE keyword at a time + integer location_code
hyperseo_ai_overviews_get(keyword="<your category keyword>", location_code=2840)

# track_mentions runs the query against OpenAI / Claude / Perplexity and returns citations
hyperseo_mentions_track(
  query="best <your category> tools",
  brands=["<competitor>", "yourbrand"]
)

Surface partial results as each phase completes — don't wait for the whole pull to finish before showing the user something.

Phase 4 — Diff

The point of the skill is delta, not snapshot. For each competitor, compare:

For a first run, there's no "last" — the diff section in the brief becomes "baseline established, will diff against this on next run." Tell the user this explicitly so they don't expect insight on day 1.

Phase 5 — Brief

Synthesize into the artifact. Brief shapes by job (full templates in references/brief-templates.md):

• Battle card — 1 page, per-competitor: positioning summary, 3 strongest competitor claims, 3 counter-claims for our side, common objections + responses, win-loss patterns.
• Weekly digest — 1 page total, all competitors: bullet list of what changed this week per competitor, ranked by significance.
• Comparison-page input — feature matrix table, pricing table, plan limits table — all sourced with URLs and timestamps.
• Board-prep update — share-of-voice, rank deltas, content velocity, sentiment trend over the period.

Output standards (apply to every brief):

• Always cite source + timestamp for every claim. "Competitor X raised the Pro tier from $79 → $99 (pricing page, 2026-04-29)" beats "X raised prices."
• Use neutral language. Brief is for the reader to draw their own conclusion.
• Distinguish observation from interpretation. Mark interpretation explicitly: "Observation: rank dropped 12 positions on 'invoice automation' over 30d. Possible interpretation: …".
• Keep one ranked list of "things that matter" at the top of the brief. Bury everything else below it. Most readers stop after the first 3 bullets.

Phase 6 — Monitor on cadence (optional)

If the user wants ongoing monitoring rather than a one-shot:

1. Save the source matrix and competitor set somewhere durable (bigquery_*, Notion, a Sheets tab, or just inline in the user's prompt template).
2. Schedule the agent to re-run the pull on a cadence — weekly is the sweet spot. Daily produces too much noise; monthly misses fast moves.
3. The brief shape becomes the weekly digest by default, with the option to escalate to a deep brief when something significant changes.

Reference workflows