MCP App Store
by KeenEthics
Linkeddit icon

Linkeddit MCP Server for ChatGPT

By Pavado

Overview

Linkeddit is a product of Pavado Technologies Inc. Linkeddit provides demand and competitor intelligence for founders, marketers, and growth teams at B2B and ecommerce businesses. Connect your Linkeddit account to explore recorded evidence and research. What you can do: - Search visibility: find buying questions where answer engines recommend competitors, and inspect recorded answers and citations. - Competitive intelligence: read competitor briefs, complaint themes, website changes, and switching signals. - Keyword research: explore search results, autocomplete suggestions, keyword research jobs, and connected search performance data. - Communities: search public discussions to understand where buyers discuss their needs. A Linkeddit account with access to the relevant tools is required. Results depend on the data and connected services available to your account. Linkeddit returns research and evidence; it does not post to communities or contact people on your behalf. Account records are limited to those available to your connected account. Saved-lead search, Reddit profile and lead insights, lead pipeline execution and results, raw Reddit JSON fetching, and DM draft generation are currently disabled in this connector.

How to connect

  1. ChatGPT: Open the Linkeddit listing in the ChatGPT app directory and choose Connect. ChatGPT listing Linkeddit exposes 32 tools here.

Tools

answer_action_get

ChatGPT
Get one action card: its label, status, type, the observed facts behind it with their citation ids, the impact counts and the confidence, plus the gap, run, prompt and competitor it links to. Use mode=evidence to resolve the citation ids into the recorded sources (URL, domain, title) -- ids that no longer resolve are reported rather than quietly dropped. There is no written brief: the evidence is here so you can write one.

answer_action_update

ChatGPT
Move one action card: todo (staged), in_progress (started), done (the work is finished) or dismissed (do not suggest this again). done and dismissed are final and there is no way back -- they differ in what happens next time the audit runs: done releases the finding so a regression comes back as a NEW card, dismissed suppresses it permanently. Legal moves depend on the current status; asking for one that is not legal returns a conflict naming the moves that are. Replaying the same idempotency_key returns the original result; the same move under a different key on an already-closed card is a conflict, correctly.

answer_actions_get

ChatGPT
Get the action queue: what the audits found that is worth doing. Two forms. Without action_id: the queue, newest first, each card a short label plus the evidence behind it (observed facts with citation ids, impact counts, confidence) and no written brief, because you write that. Filter by project_id, gap_id, type, one status, or state=open (suggested/todo/in_progress) or state=closed (done/dismissed); page with limit and offset; mode=evidence inlines the observed facts; mode=reference returns counts only. With action_id: one card with its gap, run, prompt and competitor links; mode=evidence resolves the citation ids into the recorded sources (URL, domain, title), and ids that no longer resolve are reported, not dropped. A mode a form lacks answers in the nearest one it has. Arguments that belong to the other form are rejected. Next step: answer_action_update to move a card.

answer_actions_list

ChatGPT
List the action queue: what the audits found that is worth doing, newest first. Each card is a short label plus the evidence behind it -- the observed facts with their citation ids, the impact counts and a confidence value -- and no written brief, because you write that. Filter by project, gap, type, a single status, or state=open (suggested/todo/in_progress) or state=closed (done/dismissed). With no filter you get every card including the closed ones. Use mode=evidence for the observed facts inline, or answer_action_get for one card with its citations resolved to real URLs.

answer_activity_list

ChatGPT
List what Answer Radar did on this account and what it refused: scheduled audits that were skipped and why, budget reservations that were denied, runs created and charged. Use this to answer 'why did my scheduled audit not run?' -- a skipped slot is recorded here as action='schedule.dispatch', outcome='denied', with the reason and the slot it was for in metadata (evidence mode). Newest first. Absence is not evidence: each action is only recorded from the date its writer shipped, so an empty result does not prove nothing happened. Events are resourced on what they acted on -- schedule.dispatch on the project, run.reserve on the run -- so filtering by a project id returns scheduled skips and not the reservation denials for that project's runs.

answer_audit_estimate

ChatGPT
Estimate what an audit will cost in credits before you start it, without spending anything. Counts the project's approved buying questions (or the prompts you pass) times the enabled engines times the samples per prompt, bounded by the same per-run cap a real audit obeys. Use answer_usage_get to see whether the account has that many credits left, then answer_audit_start to spend them.

answer_audit_launch

ChatGPT
Launch a pre-created (pending) audit run: queues the budget reservation and provider fan-out to run asynchronously and returns immediately. Use when the caller already inserted the answer_runs row itself; poll answer_run_get for progress.

answer_audit_run

ChatGPT
Measure a project: asks every enabled answer engine the project's buying questions and aggregates the results into gaps. This spends credits, so a call without confirm=true returns only the estimate (status awaiting_confirmation) and starts nothing, and needs no idempotency_key. Tell the user the cost, and only after they agree call again with the same arguments, confirm=true and an idempotency_key. Pass project_id to audit a project (optionally prompts, samples_per_prompt, geography, language), or run_id to launch a pending run the web app already created. Then poll progress with answer_runs_get. Recurring audits are answer_schedule_set.

answer_audit_start

ChatGPT
Start a managed recommendation-gap audit for a project (reserves budget, fans out provider measurements, aggregates into gaps).

answer_content_gaps_get

ChatGPT
Score each tracked page of a project against each measured question: does the page contain what the answer engines' answers contained. Returns, per question, the requirements the engines agreed on (a phrase counts only when at least two different providers used it, plus the products their judged mentions named), which of them each page covers, and which it misses by name. A question no page covers is flagged as a content gap and the closest page is named. Filter by url, prompt_id, prompt_text, only_gaps, or a min/max coverage band; scope by run_id or a start/end window. Use mode=evidence for the per-requirement verdicts. It reports what is missing and writes no advice about it -- that part is yours.

answer_digest_get

ChatGPT
The recurring decision for one account: what moved across every active project in the last N days versus the equal window before it, which queued actions are outstanding and which are new, and what was completed or dismissed. Returns nothing_meaningful_changed when all three are quiet, with the reason -- a window that could not be compared is reported as not_comparable, never as a fall to zero. Every number carries its own disclosure and there is no confidence value and no written summary: this is the evidence for the week, and the sentence about what to do with it is yours to write.

answer_fanout_get

ChatGPT
Get the query fan-out for a project: the web searches each answer engine actually issued while answering your tracked prompts, grouped by prompt and then by segment (provider, model, tool version, locale), with how many samples issued each query and how many times in total. This is the retrieval layer between a buyer's question and the answer they get, so it is the closest thing to a keyword list an answer engine will give you. Scope it to one run with run_id, or to a period with start/end; evidence mode returns every query with the sample ids that issued it. Two limits are reported rather than hidden: a provider may issue searches it does not report, so treat a list as evidence and not as the complete set; and Perplexity reports related topics it suggests rather than searches it ran, so its segments carry a reason and no queries instead of a plausible-looking list we cannot stand behind.

answer_fix_check

ChatGPT
Check a fix you wrote yourself against the evidence Answer Radar actually measured for a gap. Returns, for every URL in your content and every citation id you pass, whether it appears in the citations that gap's run recorded -- plus the evidence that does exist, so you can rewrite an unsupported passage instead of guessing. Writes nothing and rejects nothing: use it before answer_fix_update, which does reject. This checks sourcing, not accuracy -- it cannot tell you whether a cited page supports the specific claim you attached to it.

answer_fix_draft

ChatGPT
Build the evidence skeleton for a fix (brief, article, or response): the gap's summary, the facts observed during measurement, and the recommended actions, assembled deterministically from the run's recorded evidence and saved as a fix artifact. No model is involved and no prose is generated -- you write the words, this gives you the evidence to write them from. When you have written them, answer_fix_check tells you whether your draft cites only sources the run actually recorded, and answer_fix_update stores it under the same check.

answer_fix_get

ChatGPT
Get one fix artifact: its type, title, status, body, and the ids of the citations it was built from. Use mode=evidence to resolve those ids into the recorded sources (URL, domain, title) so you can see exactly which measured evidence backs it -- and which cited ids no longer resolve, which are reported rather than quietly dropped.

answer_fix_save

ChatGPT
Save a fix you have drafted into the Linkeddit review workspace, where a human approves or edits it, and get back the deep link to that page. This is the governed step: it creates a row a person will act on. Use answer_fix_draft first to get the evidence skeleton, and answer_fix_check to test a draft against the evidence without saving anything.

answer_fix_update

ChatGPT
Edit a fix artifact: its title, body, cited sources, or status (draft, saved, in_review, discarded). Any change to the body or the cited sources is re-checked against the measured evidence for the fix's gap, exactly as answer_fix_draft is -- an edit that cites a source the run never recorded is rejected and nothing is written, so run answer_fix_check first if you are unsure. 'approved' and 'published' cannot be set here: approval is a human action in the Linkeddit workspace, and a fix that has reached either state can no longer be edited through this tool.

answer_fixes_get

ChatGPT
Get fix artifacts: the briefs, articles and responses drafted against recommendation gaps. Two forms. Without fix_id: the account's fixes, newest first, filtered by project_id, gap_id, status (draft, saved, in_review, approved, published, discarded) or type and paged with limit and offset; the summary reports each fix's size, mode=evidence returns the bodies, mode=reference returns counts only. With fix_id: one fix with its type, title, status, body and the ids of the citations it was built from; mode=evidence resolves those ids into the recorded sources (URL, domain, title), and ids that no longer resolve are reported, not dropped. A mode a form lacks answers in the nearest one it has. Arguments that belong to the other form are rejected. Next step: answer_fix_check to test an edit, answer_fix_save to store it.

answer_fixes_list

ChatGPT
List the fix artifacts on this account -- the briefs, articles, and responses drafted against recommendation gaps -- newest first. Filter by project, gap, status (draft, saved, in_review, approved, published, discarded) or type. The summary reports each fix's size rather than its text; use mode=evidence to get the bodies, or answer_fix_get for one of them.

answer_gap_get

ChatGPT
Get one recommendation gap in full: the observations (what the engines actually said), the citations they used, the hypotheses for why a competitor won, and the recommended actions -- kept strictly separate so a claim is never confused with a guess. Use answer_gaps_list to find a gap_id first.

answer_gaps_get

ChatGPT
Get recommendation gaps: the buying questions where an engine recommended somebody else, or nobody. Three forms. With project_id alone: the project's gaps ranked by intent, evidence and confidence (filter by status; page with limit and offset); mode=reference returns counts only; a mode a form lacks answers in the nearest one it has. With gap_id: one gap in full, with the observations (what the engines said), the citations used, the hypotheses for why a competitor won and the recommended actions, kept strictly separate; mode=evidence adds them, mode=raw adds the stored rows. With project_id and view=content: each tracked page scored against each measured question, naming the requirements the engines agreed on that the page misses (filter by url, prompt_id, prompt_text, only_gaps or a coverage band; scope by run_id or start/end). It reports what is missing and writes no advice. Arguments that belong to another form are rejected. Next step: answer_fix_draft for a gap_id, or answer_sources_fetch to read the cited pages.

answer_gaps_list

ChatGPT
List a project's recommendation gaps -- the buying questions where an engine recommended somebody else, or nobody -- ranked by intent, evidence and confidence so the most actionable come first. This is the starting point for deciding what to fix. Use answer_gap_get for one gap's full evidence, or answer_content_gaps_get to ask which of your existing pages was supposed to answer the question.

answer_metrics_get

ChatGPT
Get visibility metrics for a project: presence rate, recommendation rate, share of voice, mean ordinal position, sentiment mix, and citation share. Returns one set of numbers per measured segment (provider, model, tool version, locale) and never averages across them, because two providers are two different measuring instruments. Scope it to one run with run_id, or to a period with start/end. Every metric carries its own definition and a disclosure block naming the sample counts and versions behind it. A segment with no admissible samples reports usable=false and no metrics at all -- that means the measurement failed, not that visibility is zero. Pass topic to restrict the measurement to the prompts carrying that topic. scope.prompt_filter is present on every response and says whether a filter was applied and how many prompts it matched, so a filtered number can never be read as an unfiltered one.

answer_project_create

ChatGPT
Create an Answer Radar project from a domain and commercial context (brand, competitors, buyer segment, category, geography, language).

answer_project_get

ChatGPT
Get one project's configuration: the brand and domain being tracked, the competitors it watches, the buyer segment, category, geography and language that shape every measurement, and how many buying questions sit in each approval state. Use this to check a project is configured before starting an audit. Use answer_prompts_list for the questions themselves.

answer_project_save

ChatGPT
Create an Answer Radar project, or archive or restore one. Without project_id it creates a project from a domain plus commercial context (brand_name, competitors, buyer_segment, category, geography, language) and returns its project_id. With project_id and status 'archived' it stops the project's recurring audits and hides it from the default list, keeping every run and citation; status 'active' restores it. Always pass idempotency_key. Next: answer_prompts_update to add questions, then answer_audit_run.

answer_project_update

ChatGPT
Archive an Answer Radar project, or restore an archived one. Archiving is the reversible delete: it stops the project's recurring audits from spending, removes it from the default project list, and keeps every run, sample and citation it has accumulated, so a restore returns the full measurement history. Use answer_projects_list with status='archived' to find one to restore.

answer_projects_get

ChatGPT
Without project_id, lists your Answer Radar projects: the domains being tracked, brand, geography, language and status (active by default; status='archived' or 'all' widens it). With project_id, returns that one project's configuration: brand, buyer segment, category, competitors in evidence mode, the schedule, and how many buying questions sit in each approval state. Start here when you do not have a project_id, since almost every other answer_* tool needs one. Next: answer_prompts_list for the questions, answer_audit_run to measure.

answer_projects_list

ChatGPT
List your Answer Radar projects: the domains being tracked, their brand and commercial context, and how far each is through setup. Start here when you do not have a project_id, since almost every other answer_* tool needs one. Use answer_project_get for one project's full configuration.

answer_prompts_list

ChatGPT
List a project's buying questions (prompts) and their approval status, so the workflow can show existing questions. Each row carries its topics, and 'topic' filters to one of them. Topics are your own grouping of questions -- topics and tags are one mechanism and a prompt may carry several. They are stored lowercase with whitespace collapsed, so 'Pricing' and 'pricing' are the same topic.

answer_prompts_propose

ChatGPT
Generate commercial-intent buying questions for a project (creates a draft prompt set of proposed questions for you to approve).

answer_prompts_update

ChatGPT
Approve, remove (soft), add, reprioritize, and classify a project's buying questions. Only approved prompts are audited. Use classify to label many prompts at once: 'type' is the question's shape (best_of, comparison, alternatives, pricing, how_to, review) and 'intent' is its funnel stage (free text, e.g. bofu). One value applies to every id in the list; an omitted field is left as it is. Classifying does NOT approve -- labelling and deciding what gets measured are separate acts. Nothing generates a type: read the prompts, decide the labels, and write them back here. Use topics to apply your own grouping to many prompts at once: every topic in 'add' goes onto every id you list, and 'remove' takes them off. Topics are your own grouping of questions -- topics and tags are one mechanism and a prompt may carry several. They are stored lowercase with whitespace collapsed, so 'Pricing' and 'pricing' are the same topic. A topic exists only because prompts carry it, so there is nothing to create or delete -- to rename one, list its prompts with answer_prompts_list(topic=...) and send them back with the new name in 'add' and the old one in 'remove'. Like classify, assigning a topic does NOT approve anything.

answer_results_get

ChatGPT
Get the measured results for a project, in one of four views. view=metrics (default): visibility metrics per segment (presence, recommendation, share of voice, position, sentiment, citation share) for one run (run_id) or a period (start/end), optionally narrowed to one topic. Citation share lists every domain the engines cited with its share, so this is the view for which websites the engines cite. view=trends: the same metrics per day, week or month (interval), one line per segment, with gaps reported as unmeasured rather than zero. view=fanout: the web searches each answer engine issued while answering your tracked prompts, for a run or a period; it lists search queries, not the sites the answers cited. view=digest: what moved across every active project in the last N days (days) versus the window before, with queued and completed actions; it needs no project_id. metrics, trends and fanout need project_id. Every view carries its own definitions and disclosure, reports an unmeasured scope with a reason rather than as zero, and notes when an engine's history spans two measuring instruments. Arguments that belong to another view are rejected. Next step: answer_gaps_get to see where competitors are named instead of you.

answer_run_get

ChatGPT
Poll an audit run: status, sample outcomes (failures stay visible), credits reserved and measured, and — in raw mode — normalized samples with every citation. Each sample names the engine that answered and an opaque instrument token, never a model id.

answer_runs_get

ChatGPT
With project_id, lists that project's audit runs, newest first: each run's status, when it started and finished, and what it reserved in credits. Use it to find a run_id, or to see whether a scheduled audit actually fired. With run_id, returns that one run: status, sample outcomes with failures kept visible, credits reserved and measured, and in raw mode every normalized sample with its citations. Each sample names the engine that answered and an opaque instrument token, never a model id. Poll a run started by answer_audit_run here. For metrics computed across runs use answer_results_get (view=metrics).

answer_runs_list

ChatGPT
List a project's audit runs, newest first: each run's status, when it started and finished, how many samples it measured and what it cost in credits. Use this to find a run_id, or to see whether a scheduled audit actually fired. For one run's sample-by-sample outcomes use answer_run_get; for the metrics computed across runs use answer_metrics_get.

answer_schedule_set

ChatGPT
Set or pause a project's recurring audit: weekly or monthly, in the timezone you name. (Daily exists but is restricted to internal accounts; the response's disclosure.cadences lists what THIS account may pick.) Every field is optional and an omitted one is left alone, so pausing is enabled=false on its own -- and pausing keeps the cadence, so resuming does not need it again. Enabling does NOT start a run now; the first fires one cadence from now, at next_run_at in the response. Scheduled runs reserve budget and are refused by the same caps as manual ones. Missed slots are skipped, never replayed as a backlog.

answer_share_create

ChatGPT
Create a link that shows one gap, run, fix, or a project's metrics to someone without a Linkeddit account, so a client or colleague can see a result without a seat. The link shows the SUMMARY only, never the underlying answer text or cited sources, and it expires in 30 days. The full URL is returned once and cannot be recovered afterwards, so save it now. Use answer_shares_list to see what you have shared, and answer_share_revoke to switch one off early.

answer_share_revoke

ChatGPT
Switch off a share link immediately, before it expires on its own. Anyone who opens it afterwards is told it was revoked rather than that it does not exist, which is the honest answer and stops them hunting for a typo. This cannot be undone: create a new link if you need one again. Find the share_id with answer_shares_list.

answer_share_update

ChatGPT
Create or revoke a share link, chosen by action. action=create with resource_type (gap, run, fix or metrics) and resource_id makes a link that shows one gap, run, fix or a project's metrics to someone without a Linkeddit account, so a client or colleague can see a result without a seat. The link shows the SUMMARY only, never the underlying answer text or cited sources, and it expires in 30 days. The full URL is returned once and cannot be recovered afterwards, so save it now; label is your own note and is never shown to the recipient. action=revoke with share_id switches a link off immediately: anyone who opens it afterwards is told it was revoked, and this cannot be undone, so create a new link if you need one again. Arguments that belong to the other action are rejected. Find a share_id with answer_shares_get.

answer_shares_get

ChatGPT
Get the share links on this account, newest first: what each one points at, whether it is still active, expired or revoked, how many times it has been opened, and when it stops working. Filter by resource_type (gap, run, fix, metrics) and page with limit and offset. Use this to find a link that is still live and should not be, then pass its share_id to answer_share_update with action=revoke. The URLs themselves are not recoverable and are not returned here.

answer_shares_list

ChatGPT
List the share links on this account, newest first: what each one points at, whether it is still active, expired or revoked, how many times it has been opened, and when it stops working. Use this to find a link that is still live and should not be, then pass its share_id to answer_share_revoke. The URLs themselves are not recoverable and are not returned here.

answer_sources_fetch

ChatGPT
Fetch a cited web page and store it in your Answer Radar evidence store, so a fix can cite it. Returns what was stored -- a document id, a status and a content hash -- plus the extracted text in evidence mode. The fetch is guarded: a URL that resolves to a private or internal address, redirects into one, returns a non-text content type, or exceeds the size cap comes back with status 'blocked' or 'too_large' and a reason. Those mean WE REFUSED TO FETCH IT, not that the page is empty. A page fetched recently is served from the stored copy unless you pass force. Requires the Compete plan.

answer_usage_get

ChatGPT
Get this account's Answer Radar spend position before starting work: what has been reserved and consumed today, the remaining daily allowance, the per-run cost cap, whether the operator kill switch is engaged, and the per-run size limits a request may ask for. Pass project_id to also get that project's lifetime consumption. Everything is in credits: one credit is one measured sample, meaning one question asked of one engine. A null cap means that ceiling is not configured -- it does not mean unlimited, and it does not mean zero. can_start_run.allowed=true means nothing visible here refuses a run, not that one is guaranteed to be accepted: the per-run cap is checked against an estimate, and a platform-wide daily cap that is not visible to you also applies.

answer_verify_get

ChatGPT
Get a re-verification: its status, when the follow-up is due, and once it has settled, the observed delta per segment. report is null until the follow-up run finishes -- that means 'not measured yet', NOT 'no change'. Outcomes are about movement only: improved, declined, mixed, no_significant_change, not_comparable, or ambient_change_not_isolated when untargeted control prompts moved as much as the target. Nothing here attributes movement to your change, and no confidence value is reported because none is computed.

answer_verify_start

ChatGPT
Register a re-verification of a recommendation gap: re-measure the same prompts with the same configuration after an indexing delay, then report what moved. This starts NO run now -- the delay is the point, because content published today is not retrievable today, so an immediate re-measurement would report 'no change' about something nothing has seen yet. The response carries followup_due_at; poll answer_verify_get after that. Pass fix_id to record which fix is being tested. The result is always an OBSERVED DELTA, never evidence that your change caused it.

compete_brief_get

ChatGPT
Get a Compete brief. view=competitor (the default) returns the latest graded brief for one tracked competitor: moves, complaint themes, feature gaps, pricing signals, switch triggers and recommended actions; pass monitor_id or competitor to choose which. view=weekly returns the latest weekly brief across every monitor, with its intro summary and the individual signals that fed it; pass week_of (YYYY-MM-DD) for an earlier week. Returns {"brief": null} when nothing has been generated yet. Use compete_monitors_get first to find monitor ids, and compete_signals_get to read the signals behind a brief. Customer reviews are not in the brief: read them with compete_signals_get view=reviews.

compete_monitors_get

ChatGPT
List your tracked competitor monitors, the competitors Linkeddit watches for moves, complaints and page changes. Returns each monitor's id, competitor, sources, frequency, status, priority and when it last ran and last produced a brief. Use it first to find the monitor_id that compete_brief_get and compete_signals_get accept. Page with limit and offset.

get_competitor_brief

ChatGPT
Get the latest graded competitor brief — moves, complaint themes, feature gaps, pricing signals, switch triggers, and recommended actions for a tracked competitor.

get_competitor_changes

ChatGPT
Recent competitor page snapshots for pricing/landing-page change detection. The content hash + timestamp signal a change between snapshots of the same URL.

get_keyword_results

ChatGPT
Get scored keywords for one of your jobs — priority score, intent, conversion potential, and suggested landing page. Only your jobs.

get_switching_signals

ChatGPT
List individual switching / market signals — competitor moves and buyer-intent events, most recent first.

get_weekly_brief

ChatGPT
Get the latest weekly competitor brief — the intro summary plus the individual switching/market signals that fed it.

gsc_queries_get

ChatGPT
Get the search queries real buyers used to reach this project's site, from the customer's own Google Search Console, ranked by impressions. This is first-party demand data rather than a guess: use it to decide which buying questions are worth measuring, to sanity-check a proposed prompt set against what people actually type, or to find high-impression questions where the site ranks poorly. Returns the query, its impressions and clicks, and its average position. Requires the customer to have connected Search Console; the response says plainly when they have not.

keyword_autocomplete

ChatGPT
Get Google autocomplete suggestions for a seed query — long-tail keyword variations people actually search.

keyword_research_get

ChatGPT
Read your keyword-research jobs. With no job_id it lists your jobs and their status, most recent first, with keyword counts; filter by status. With a job_id it returns that job's scored keywords: priority score, intent, conversion potential, relevance, type and suggested landing page, highest priority first; filter by min_score or include_filtered. Page with limit and offset. Only your own jobs are readable; an id that is not yours returns no keywords. Use keyword_serp or keyword_autocomplete for a live look at one query. With view=brief, keywords and a job_id it assembles a writing brief for the chosen keywords; then write the article and store it with article_save.

keyword_serp

ChatGPT
Get structured Google SERP data for a query — People Also Ask, related searches, and top organic titles.

list_competitor_monitors

ChatGPT
List your tracked competitor monitors — the competitors Linkeddit watches for moves, complaints, and page changes.

list_keyword_jobs

ChatGPT
List your keyword-research jobs and their status, most recent first.

search_competitors_get

ChatGPT
Get who else shows up for this project's keywords, from checks already run. Free and read only. view=footprint (the default) lists each competing domain with the keywords where it ranks in the Google top 10, its average position, the keywords where it ranks above the project, how many AI Overviews cited it, and how many times each AI answer engine (ChatGPT, Claude, Gemini, Perplexity, Google AI Overviews) cited it. The project's own domain is left out. Pass domain to get one competitor's winning pages and the keywords where each page ranks above the project. view=content_map needs a domain and reads that site's public sitemap, returning its pages grouped into editorial sections (articles and guides) and templated sections (many pages built from one pattern, such as /integrations/{x}), with counts and example URLs; it uses no search checks. Page with limit and offset. If nothing has been checked yet, the reply says how to start.

search_research_get

ChatGPT
Read a keyword research run started with search_research_run. view=summary (the default) returns the status, progress as checks done out of checks planned, and how many topics carry each action. view=topics returns each topic: its head keyword, the member keywords with the project's rank for each, the project's best rank and owner URL, the action (striking_distance, gap, protected, cannibalised or hold), the competing URLs and the classifier version; narrow it with action and page with limit and offset. view=map returns a keyword map (kind=map): format=tree (the default) nests each keyword under the keyword it came from, format=table gives flat rows paged with limit and offset; every node has its depth, the project's rank, the top domain, whether Google showed an AI Overview, an intent label from the keyword's shape (best_of, comparison, alternatives, pricing, how_to, review or other) and a difficulty (proxy) score, which is a rough guide and is defined in the response. view=history lists the project's past lab and map runs, newest first, with kind, status, dates and checks used. summary, topics and map read the project's latest run of that kind unless job_id is given. Read only and free: it runs no checks. Each response defines its terms.

search_research_run

ChatGPT
Research a project's keywords on Google: look up each keyword and record where the project ranks. kind=lab (the default) groups keywords that Google answers with the same pages into topics; it starts from the seeds you pass, the tracked keywords and the top Search Console queries. kind=map builds a keyword map: a tree that grows from roots (or the tracked keywords), each keyword expanding into its own results page's related searches (source=related, the default) or People Also Ask questions (source=paa); source=ai_fanout starts from the searches AI answer engines ran for the project's prompts. A map takes children per node (default 5), depth up to 3 (default 2) and max_nodes up to 150, and every node is one check. This uses checks from the monthly search allowance, so the first call (confirm=false) returns only the estimate: checks planned (the worst case for a map), how many are free from recent checks, allowance left, and whether it fits, with the largest run that does. Nothing is started or spent. Tell the user the number, and only after they agree call again with the same arguments and confirm=true. The run works in the background: read progress, topics, the map or past runs with search_research_get.

search_tracked_update

ChatGPT
Change which keywords this project's weekly rank checks follow: add keywords by name, remove keywords, or pass seed_from_gsc=true to start from the top non-brand queries in Search Console. Free: this call runs no checks. Tracked keywords are checked weekly in the background against the monthly search allowance, and the per-project cap keeps that use bounded. Returns the resulting tracked list and how many slots remain under the cap. remove switches a keyword off and keeps its history, and a removed keyword is never seeded again; adding it by name turns it back on. Repeating a call changes nothing. Read the ranks with search_visibility_get.

search_visibility_get

ChatGPT
Get how this project's tracked keywords rank on Google, from the weekly rank checks. view=ranks (the default) lists each tracked keyword with its latest rank, the change since the previous check, the project's URL, whether Google showed an AI Overview, whether that Overview cited the project, the top domain and the check date. A rank of null means not in the top 10, which is a result and not a missing check. view=history returns the rank series for one keyword, or all of them, over the last weeks weeks. view=aio_impact splits the keywords into those with and those without an AI Overview and compares their Search Console clicks before and after, returning both groups, a verdict with its version, and caveats; it needs Search Console connected. Read only and free: it runs no checks. If nothing is tracked yet, the reply says how to start.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/linkeddit"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/linkeddit)