# ASOLens (npm · @asolens/mcp) ASOLens MCP server: App Store ranks, competitors and weaknesses, from your own machine - Trust score: 62/100 (medium) - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-10-17 ## Components - npm · `@asolens/mcp`: 62/100 (this document), [markdown](https://verifymcp.io/servers/dev-danielhan-asolens-mcp/asolens-mcp.md), [page](https://verifymcp.io/servers/dev-danielhan-asolens-mcp/asolens-mcp) ## Channel facts - Registry: `npm` - Package: `@asolens/mcp` - Version: `0.4.1` - Transport: `stdio` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-10-17. - **Supply Chain Security**: 98/100 - No malware found by supply-chain analysis. - No known CVEs affecting this package version or its production dependencies. - No install/post-install scripts declared. - 31 of 92 dependencies flagged as unhealthy. - **Provenance & Transparency**: 19/100 - Repository check failed: no source repository is declared. - Provenance check failed: no build-provenance attestation is published. - Clear OSI-approved license (MIT). - Actively maintained (last published 4 days ago). - Security-disclosure policy not yet verified: we couldn't inspect the source repository. - **Schema Quality & AI Usability**: 61/100 - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 5254 tokens (~350/item across 15 items; 15 tools + 0 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 0/100 - Stability not yet verified: not enough scan history yet (needs a 30-day window). - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - We read all 15 captured tool definition(s), and no name or description among them implies an irreversible operation. - An AI judge read all 15 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. **Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm. ## Install ### How do I install the ASOLens MCP server? ASOLens runs locally as an npm package, launched with npx -y @asolens/mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add dev-danielhan-asolens-mcp -- npx -y @asolens/mcp ``` ### Cursor ```json { "mcpServers": { "dev-danielhan-asolens-mcp": { "command": "npx", "args": [ "-y", "@asolens/mcp" ] } } } ``` ### VS Code ```json { "servers": { "dev-danielhan-asolens-mcp": { "command": "npx", "args": [ "-y", "@asolens/mcp" ] } } } ``` ### Codex ```bash codex mcp add dev-danielhan-asolens-mcp -- npx -y @asolens/mcp ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "dev-danielhan-asolens-mcp": { "type": "local", "command": [ "npx", "-y", "@asolens/mcp" ], "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add dev-danielhan-asolens-mcp --command npx --arg -y --arg @asolens/mcp ``` ### Hermes ```yaml mcp_servers: dev-danielhan-asolens-mcp: command: "npx" args: ["-y", "@asolens/mcp"] ``` ### Netclaw ```json { "McpServers": { "dev-danielhan-asolens-mcp": { "Transport": "stdio", "Command": "npx", "Arguments": [ "-y", "@asolens/mcp" ] } } } ``` ### Vellum ```bash assistant mcp add dev-danielhan-asolens-mcp -t stdio -c npx -a -y @asolens/mcp ``` ### Other ```json { "mcpServers": { "dev-danielhan-asolens-mcp": { "command": "npx", "args": [ "-y", "@asolens/mcp" ] } } } ``` ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-10-14 (score 62, +29) - [security improvement] Injection markers: unverified → pass - [security] First check of Judged manipulation: pass - [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window). - [functional improvement] Tool coverage: unverified → 100 - [functional improvement] MCP protocol: unverified → pass - [functional] First check of Schema quality: fail - [functional] First check of Schema quality: excellent - [functional] First check of Destructive annotations: pass - [functional] First check of Schema quality: fail - [functional] First check of Tool coverage: 100 ### 2026-10-13 (score 33) First indexed and scored. ## MCP tools (15) ### `find_app` (~115 tokens) Find an App Store app Looks up an app by id, App Store URL, or name and returns candidate matches with rating and developer info. Input parameters: - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. - `limit` (integer): Maximum matches to return for a name search (max 200, Apple's own ceiling). Ignored when query is a numeric id or App Store URL. - `query` (string, required): App name or search text to look up on the App Store. ### `app_snapshot` (~92 tokens) App snapshot with developer's other apps Resolves an app by id, App Store URL, or name and returns its current listing data plus the developer's other apps in this storefront. Input parameters: - `app` (string, required): App to resolve: a numeric App Store id, an App Store URL, or an app name. - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. ### `search_ranks` (~271 tokens) App Store search ranks Ranked apps for one keyword in one country, as the App Store lists them (fetched from this machine; cached for the UTC day). Bundles are kept as ranked rows. resultCount is what Apple returned (250 is a ceiling), not how many apps compete. Input parameters: - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. - `keyword` (string, required): Search keyword to rank apps for. Accents matter: Apple usually treats an accented and an unaccented spelling as different searches, and neither is reliably better (br 'jogos de matemática' ranked #19… - `top` (integer): How many ranked entries to return, most-relevant first (max 250 — the ceiling Apple's search returns). ### `keyword_ranks` (~801 tokens) Keyword ranks for one app across countries Looks up where one app ranks for a list of keywords, in one or more storefronts, with day-over-day trend where available. Input parameters: - `app` (string, required): App to check: a numeric App Store id, an App Store URL, or an app name. - `countries` (array): Storefront country codes to check, up to 8, paired with every entry in `keywords`. Defaults to the server's configured default country. Keywords x countries must not exceed 25 pairs total. - `coverage` (boolean): For YOUR OWN app (App Store Connect credentials required), report which of each keyword's words actually appear in the text Apple indexes -- name, subtitle and the keywords field, checked together ra… - `depth` (boolean): Add autocompleteDepth (how many App Store autocomplete suggestions begin with the keyword) to each row, and to each variant when variants is on. Free, works in every storefront, and adds no wall-cloc… - `keywords` (array): Keywords to check this app's rank for (max 50; keywords x countries must not exceed 25 pairs total). Accents matter: Apple usually treats an accented and an unaccented spelling as different searches,… - `pairs` (array): Explicit keyword/country pairs instead of the keywords x countries cross product. Use this whenever the storefronts need different keywords: 13 Brazilian plus 9 Nordic terms is 22 rows here, against… - `variants` (boolean): For every keyword with an accent on a Latin, Greek or Cyrillic letter, ALSO look up the stripped spelling and return the two side by side in one row, with identicalResults saying whether Apple actual… ### `compare_queries` (~288 tokens) Compare two searches' result sets Runs two keywords in one storefront and reports how much their ranked results overlap. Use this BEFORE concluding anything from a rank difference between two queries: rank is relative to whoever else is in that result set, so an app at #19 for one phrase and #131 for another has not necessarily been hurt by the extra word -- the two searches may simply have different competitors. identicalResults: true means Apple answered one query for both (it does this for some accented/unaccented pairs, and for some rewordings), so any rank difference is noise; NULL means both queries returned nothing, so there was no list to compare and no conclusion to draw either way. A low overlap means the two are genuinely different searches and their ranks are not comparable at all. Input parameters: - `a` (string, required): First search keyword. - `app` (string): Optional app (id, URL, or name) to also report the rank of in each result set, so you can see the rank difference and the overlap that qualifies it together. - `b` (string, required): Second search keyword, the one to compare against. - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. - `top` (integer): How deep to compare the two ranked lists (default 25). identicalResults always compares the FULL lists, not just this depth. ### `my_listing` (~195 tokens) Your own App Store listing text Reads YOUR OWN app's indexed listing text -- name, subtitle and the keywords field -- from App Store Connect, per locale. This is the only way to see the keywords field: it is private to the developer and no public endpoint exposes it, so for anyone else's app it stays unavailable. Requires App Store Connect API credentials; without them the tool says so rather than failing. Use it before judging a keyword: coverage of a query's words across name+subtitle+keywords is what you can actually change. Input parameters: - `app` (string, required): Your app: a numeric App Store id, an App Store URL, or a bundle id. It must be an app your App Store Connect API key can see. - `country` (string): Two-letter storefront country code. Given, the response leads with the locale that storefront serves (and says so when the app has no localization for it and falls back). Omitted, every locale is ret… ### `audit_keywords` (~463 tokens) Which words in your keyword field earn their place Tests every word in YOUR OWN keywords field by searching a phrase where that word is the distinguishing one -- an anchor your app certainly covers, plus the word under test ('matemática' + 'escola'). Ranking for the probe means the word is working; not ranking means it is not earning its 100 characters. Searching each word alone instead would mostly measure how small your app is. READ THE SUMMARY FIRST: if almost nothing ranks, the answer is usually not 'fix these words' -- a live audit found 1 of 19 German probes ranking, with the app at zero ratings against competitors holding thousands, which means keyword work is not the lever in that storefront at all. Requires App Store Connect credentials (the keywords field is private). Input parameters: - `anchor` (string): The context word each probe is built from. Omitted, one is picked from your app name and reported back as anchorSource: "auto" -- check it. A mechanical anchor can produce a phrase no human would typ… - `app` (string, required): Your app: numeric App Store id, App Store URL, or bundle id. Must be visible to the configured App Store Connect key. - `country` (string): Storefront to test in, e.g. "br". Defaults to the server's configured default country. The keyword field tested is the one for the locale that storefront serves. - `probes` (array): Override the generated probe for specific words, e.g. {word: "contar", probe: "aprender a contar"} where natural phrasing beats " contar". Words not listed here still use the anchor. - `suggestions` (boolean): Include, per word, what App Store autocomplete says people typing that word are actually looking for. Free, adds no measurable wall-clock (autocomplete has its own request lane), and works in all 17… ### `compare_markets` (~373 tokens) Which storefront is worth working on Runs the keyword-field audit across several storefronts at once and puts them side by side: how much of your keyword field places in each, your rating count there, and the competitor median with its sample size. This is the 'which market should I work on' question, which no single-market answer can settle. Uses auto-picked anchors only -- to override an anchor or a probe, run audit_keywords for that one market. Requires App Store Connect credentials (the keywords field is private). READ THE ANCHOR COLUMN: each market's numbers come from a different anchor in a different language, so the medians are NOT commensurable and only large differences mean anything. Input parameters: - `anchors` (array): Per-market anchor overrides, e.g. {country: 'jp', anchor: '算数'}. Markets not listed pick one automatically. Worth setting wherever you know the category term a person there would actually search: the… - `app` (string, required): Your app: numeric App Store id, App Store URL, or bundle id. Must be visible to the configured App Store Connect key. - `countries` (array, required): Storefronts to compare, up to 8. Each costs roughly one App Store search per word in that locale's keyword field (free, but a four-market comparison takes about half a minute). - `probes` (array): Per-market probe overrides, e.g. {country: 'br', word: 'soma', probe: 'soma e subtração'}. This is where market knowledge pays: measured in br, natural phrasing put words at #23 and #35 that mechanic… ### `snapshot_save` (~356 tokens) Save a named rank snapshot Captures a named, kept measurement of a keyword set: rank (including null, which is a value here), resultCount, the top 10 app ids, keyword coverage with the listing version it was read from, and your rating count against the competitor median per storefront. Take one BEFORE shipping a metadata change -- the moment cannot be recovered afterwards, because Apple publishes no rank history and this tool's own cache is per-UTC-day. Label each keyword ('target', 'control', 'regression watch') so a later diff can tell signal from drift: if the controls move while nothing about them changed, the reading is noise. Input parameters: - `app` (string, required): The app to record ranks for: numeric App Store id, App Store URL, or name. - `countries` (array): Storefronts to capture in, paired with every entry in `keywords`. Defaults to the server's configured default country. - `keywords` (array): Keywords to capture in every one of `countries` (a cross product). Use `pairs` instead when different storefronts need different keywords. Keywords x countries must not exceed 60. - `name` (string, required): Name to save under, e.g. "pre-release-2026-08-29". Re-using a name overwrites that snapshot. - `pairs` (array): Explicit keyword/country pairs, instead of the keywords x countries cross product. Use this whenever storefronts need different keyword sets -- 13 Brazilian plus 9 Nordic keywords is 22 rows here, ag… ### `snapshot_diff` (~141 tokens) Compare two rank snapshots Compares two named snapshots keyword by keyword: rank before and after (null included), how the result set size changed, which apps entered or left the top 10, and your ratings against the competitor median on each date. Rows are grouped by the labels given when saving. READ THE CONTROLS FIRST: if keywords you expected to hold still have moved, the whole comparison is drift and the targets prove nothing. Deliberately reports no significance or confidence -- with small numbers there is no statistical power, and a confidence label would be theatre. Input parameters: - `after` (string, required): Name of the later snapshot. - `before` (string, required): Name of the earlier snapshot. ### `niche_report` (~803 tokens) Niche competitive report Builds a competitive report across a set of keywords: the union of top-ranked apps, a weakness score per competitor, difficulty per keyword, and gaps for your own app. Input parameters: - `app` (string): Your own app, to compare against competitors and compute gaps: id, URL, or name. - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. - `depth` (boolean): Fetch App Store autocomplete for each keyword and report autocompleteDepth: how many suggested queries begin with that keyword. Free, works in every storefront (unlike volume, which is 'us'-only), an… - `include_inputs` (boolean): If true, every modelled value (weakness, difficulty, ownTrend, volume) also includes the raw inputs it was computed from. Default false keeps kind, value and model -- far smaller for reports with man… - `keywords` (array, required): Keywords defining the niche (max 30). Accents matter: Apple usually treats an accented and an unaccented spelling as different searches, and neither is reliably better (br 'jogos de matemática' ranke… - `name` (string): Name for this niche; required (together with save: true) to save it for later reuse. - `save` (boolean): If true, saves this niche definition for later reuse -- requires name to also be given, otherwise nothing is saved (see saved/savedReason in the response). - `top` (integer): How many top-ranked apps per keyword to include in the report. - `volume` (boolean): DataForSEO's Apple keyword dataset covers the 'us' storefront ONLY -- in every other storefront volume comes back unavailable saying exactly that, at no cost and without failing the call. Look up key… ### `low_star_reviews` (~122 tokens) Low-star reviews for an app Fetches recent low-star reviews for an app so you can read what's actually bothering users; theme extraction is left to the caller. Input parameters: - `app` (string, required): App to fetch reviews for: a numeric App Store id, an App Store URL, or an app name. - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. - `limit` (integer): Maximum number of reviews to return. - `maxStars` (integer): Only include reviews with this star rating or lower. ### `suggest_keywords` (~271 tokens) Keyword autocomplete suggestions Returns App Store autocomplete suggestions for a search term, showing what people actually search for -- the way to check a keyword's intent is what you assume (e.g. 'rakna' autocompleting to calorie counting, not maths). Suggestion order is Apple's own ranking. Autocomplete is PREFIX completion, so a count of zero means nothing popular extends the term -- NOT that nobody searches it ('math quiz for kids' returns none and is plainly a real search). Read a low count as a prompt to look closer, never as proof a keyword is dead. This tool never spends money. It cannot buy search volume (no vendor prices a bare App Store keyword), but a suggestion that a niche_report, keyword_table or price_keywords run already bought a price for in 'us', on any of the last 7 UTC days (today counted as the first), comes back priced for free in `volumes`, carrying the day the price was bought so an older number says it is older; when none of the suggestions has such a price, a single `volume` field says why. Input parameters: - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. - `term` (string, required): Search term to get App Store autocomplete suggestions for. ### `price_keywords` (~391 tokens) Search volume for a keyword list Looks up DataForSEO search volume for keywords you already have, by naming each one to the vendor. Use this to RANK a list -- 'which of these 40 terms is biggest' -- which niche_report cannot answer, because it reads each competitor's top 50 keywords only and everything below that comes back unpriced. This asks across each app's full ranked list instead. Paid: keywords are sent in batches of 150, and each batch is $0.012 per app, plus $0.00012 per keyword actually found -- so 200 keywords across 2 apps is 4 batches, about $0.05. Free for the rest of the UTC day once bought. US storefront only, like all volume in this server. A keyword still comes back unavailable if none of the queried apps ranks for it -- volume exists only as 'the keywords this app ranks for', so the answer depends on which competitors are reached, and it is NEVER evidence a keyword is unpopular. Input parameters: - `apps` (array): Competitor app ids to price through. STRONGLY PREFERRED: supplying these makes the call cost ZERO App Store requests. Leave empty and the tool searches the App Store for a few of your keywords to fin… - `country` (string): Two-letter App Store storefront country code. Volume is "us"-only; any other storefront returns unavailable at no cost. - `keywords` (array, required): The keywords to price. Duplicates and casing are normalised. - `max_apps` (integer): How many competitor apps to query. Cost is per app AND per 150-keyword batch: $0.012 x ceil(keywords/150) x apps, so 100 keywords at 2 apps is $0.024 before per-keyword charges. Each app reaches a di… ### `keyword_table` (~572 tokens) Saved keyword tracking table Builds a table of your saved keywords with current rank, difficulty and trend, refreshing today's data by default. Input parameters: - `add` (array): Keywords to save before building the table (max 50 - each triggers a live App Store search when refresh is true, which it is by default). - `app` (string): Your own app, to compute rank/trend against in the table: id, URL, or name. - `country` (string): Two-letter App Store storefront country code, e.g. "us". Defaults to the server's configured default country. - `depth` (boolean): Fetch App Store autocomplete for each keyword and report autocompleteDepth: how many suggested queries begin with that keyword. Free, works in every storefront (unlike volume, which is 'us'-only), an… - `notes` (array): Notes to attach to already-saved keywords, applied before the table is built. - `refresh` (boolean): Re-fetch today's rank data for each saved keyword that hasn't been refreshed yet today, before building the table. Keywords already refreshed today are served from cache for free; up to 20 newly-fetc… - `volume` (boolean): DataForSEO's Apple keyword dataset covers the 'us' storefront ONLY -- in every other storefront volume comes back unavailable saying exactly that, at no cost and without failing the call. Look up key… ## Diagnostics Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/dev-danielhan-asolens-mcp/asolens-mcp#diagnostics ## Score history - 2026-10-17: 62 - 2026-10-16: 62 - 2026-10-15: 62 - 2026-10-14: 62 - 2026-10-13: 33 ## Common questions ### What is the ASOLens MCP server? ASOLens is an MCP server listed in the public MCP registry as dev.danielhan.asolens/mcp. ASOLens MCP server: App Store ranks, competitors and weaknesses, from your own machine. This page covers its npm package (@asolens/mcp). ### Is the ASOLens MCP server safe to use? ASOLens scores 62 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 17 October 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the ASOLens MCP server expose? ASOLens exposes 15 tools: find_app, app_snapshot, search_ranks, keyword_ranks, compare_queries, and 10 more. Their descriptions and schemas cost roughly 5,254 tokens of context every time the server is loaded. ### Is the ASOLens MCP server still maintained? ASOLens is still listed as active in the MCP registry. We last reached this channel on 17 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ### What licence is the ASOLens MCP server under? ASOLens declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls. ## Links - npm package: https://www.npmjs.com/package/@asolens/mcp - Socket report: https://socket.dev/npm/package/@asolens/mcp - Website: https://asolens.danielhan.dev/ - Changelog RSS feed: https://verifymcp.io/servers/dev-danielhan-asolens-mcp/asolens-mcp.xml - Changelog JSON feed: https://verifymcp.io/servers/dev-danielhan-asolens-mcp/asolens-mcp.json - HTML version of this page: https://verifymcp.io/servers/dev-danielhan-asolens-mcp/asolens-mcp