browser-compat-mcp-server

Name: browser-compat-mcp-server
Author: cyanheads

Server Details

Browser compatibility and Baseline status for any web feature — offline, from bundled MDN data.

If you are the author of this connector, you can claim ownership by verifying the domain or GitHub account it belongs to. Claimed connector authors can inspect health checks, view analytics, and manage their listing.

Status: Healthy
Uptime: 99.9% over 41 days
Last Tested: 2026-10-31 15:49
Transport: Streamable HTTP · MCP 2025-11-25
URL
Repository: cyanheads/browser-compat-mcp-server
GitHub Stars: 1
Server Listing: browser-compat-mcp-server

TDQS

A4.2/5.0

Scored 2026-10-26 19:25 across 5 tools

Disambiguation4/5

Each tool has a distinct role: search resolves names to keys, get returns a single record, list_reference exposes vocabulary, and the two evaluation tools answer different questions. The one soft boundary is between check_baseline (implicit Baseline/traffic verdict) and compare_support (explicit browserslist query verdict), which both answer 'can I ship this?'; the descriptions do distinguish them via Baseline state vs. an explicit query, so an agent can pick correctly with care.

Naming Consistency5/5

All five tools share the browsercompat_ namespace prefix and follow a clean verb_noun snake_case pattern (check_baseline, compare_support, get_feature, list_reference, search_features). No mixed conventions or casing drift.

Tool Count5/5

Five tools is tight and well-scoped for a read-only compatibility-data server: discovery, retrieval, two evaluation modes, and a reference vocabulary. No tool looks redundant or filler.

Completeness4/5

The surface covers the full read path — find a feature, fetch its record, evaluate it against Baseline or an explicit target, and resolve valid input vocabulary — with pagination/omission semantics handled inside the tools. Minor gaps remain: no way to enumerate features by Baseline state or group, and no bulk export of results already evaluated, which agents must reconstruct by paging.

Available Tools

5 tools

browsercompat_check_baselineBrowsercompat Check BaselineA

Read-onlyIdempotent

Inspect

Check whether web features are safe to ship: Baseline state and the date it crossed, the browser and version that limits support, whether the feature is deprecated or discouraged, and the percentage points of global traffic that requiring it would exclude. Evaluates up to 20 BCD keys or web-features ids per call; up to 100 may be sent, and entries past the 20th come back unevaluated in omitted_features for the next call.

Name	Required	Description	Default
`resolve`	No	When true, an entry that is neither a key nor an id falls back to the search index, such as "Container queries (size)" or "Element.prototype.animate". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with its feature-level Baseline and compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct.
`features`	Yes	Entries to check, each a browser-compat-data key such as css.selectors.has or a web-features id such as has, 1 to 200 characters. The first 20 are evaluated per call; up to 100 are accepted, and entries past the 20th are returned unevaluated in omitted_features. More than 100 entries, or an empty or longer entry anywhere in the list, is rejected against this schema; a whitespace-only entry anywhere returns invalid_feature_input. Call browsercompat_search_features first for any entry whose key you do not already know.

Output Schema

Name	Required	Description
`error`	No	Present when the call failed. Absent on success.
`results`	No	One result per evaluated entry — the first 20. A miss is a result, not a failure.
`totalCount`	No	Number of results returned.
`attribution`	No	Required attribution for the caniuse-derived usage figures in this response.
`data_version`	No	Vintage of each bundled dataset behind this answer.
`omitted_features`	No	Entries past the first 20, verbatim and in input order, that were not evaluated. Present only when the call sent more than 20; pass them as features in the next call.
`unresolvedNotice`	No	Names the entries that did not resolve and how to find the right key.
`all_widely_available`	No	True only when every entry resolved and reports Baseline widely. A single miss, or any entry in omitted_features, forces false. Deprecation and discouragement do not enter this answer.

TDQS

A4.1/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare a safe, read-only, idempotent, closed-world operation, so the bar is lower; the description adds important behavior by explaining the 20-entry evaluation limit and that excess entries return unevaluated in omitted_features. It also discloses the kinds of results returned, including Baseline status, limiting browser, deprecation flag, and excluded traffic percentage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the core purpose and then efficiently covers batching behavior and result content. It is dense but has no filler or redundant phrasing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has annotations, a complete input schema, and an output schema; the description provides enough purpose, batching behavior, and outcome context for an agent to invoke it correctly. No essential behavioral or contextual details are missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents the features and resolve parameters thoroughly. The description restates the batch limits and accepted key/id forms, but adds little beyond what the schema provides, especially for the resolve parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb and resource: checking web features for shipping safety via Baseline state, limiting browser/version, deprecation status, and excluded traffic. It is clear what the tool returns, but it does not explicitly distinguish itself from siblings such as browsercompat_compare_support or browsercompat_get_feature.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase "safe to ship" implies the usage context, and the batching limit is explained. However, the description does not explicitly say when to use this tool versus search_features, get_feature, or compare_support, nor does it state when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

browsercompat_compare_supportBrowsercompat Compare SupportA

Read-onlyIdempotent

Inspect

Compute whether a set of web features clears an explicit browserslist target query. Compares up to 20 features per call; up to 100 may be sent, and entries past the 20th come back unevaluated in omitted_features for the next call. Every call evaluates the whole query: each feature gets a verdict, the count of failing targets, those targets grouped into runs of consecutive query targets per browser in failing_ranges, and its own evaluated and unevaluated target counts with the percentage points of global traffic each covers. The target rows behind those numbers — which release each target maps to, which targets were not evaluated and why, and the failing and unevaluated targets of each feature, a failing row carrying the prefix, alternative name, or flag behind its verdict — cover at most ten query targets per call; page through them with target_offset and target_limit, and the verdicts, coverage, and totals stay identical on every page. A target counts as evaluated only where compatibility data was read for it, so a feature clears only when every target in the query was evaluated and supports it, and is inconclusive otherwise — a query that includes a browser with no compatibility data, as "defaults" does, never clears. A BCD key is judged on its own per-browser support. A web-features id spanning several keys, such as grid, is judged on the release web-features lists for the feature as a whole in each Baseline core browser, as support_source says; its other browsers are not evaluated.

Name	Required	Description
`resolve`	No	When true, an entry that is neither a key nor an id falls back to the search index, such as "Container queries (size)" or "Element.prototype.animate". Its best exact matches are accepted only when they name one feature: a single key resolves to that key and is judged on it, several keys of one web-features feature resolve to the feature and are judged on its feature-level support with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature.
`targets`	Yes	A self-contained browserslist query, for example "defaults" or "> 0.5%, last 2 versions", 1 to 500 characters. Config packages and custom configuration are unsupported; local config discovery is disabled.
`features`	Yes	Entries to compare, each a browser-compat-data key such as css.selectors.has or a web-features id such as has, 1 to 200 characters. The first 20 are compared per call; up to 100 are accepted, and entries past the 20th are returned unevaluated in omitted_features. More than 100 entries, or an empty or longer entry anywhere in the list, is rejected against this schema; a whitespace-only entry anywhere returns invalid_feature_input. Call browsercompat_search_features first for any entry whose key you do not already know.
`target_limit`	No	How many query targets this page covers, at most 10 per call; a value from 11 to 1000 is served as 10, and the cap enrichment field reports the size applied. It bounds every list of target rows in the response and never the evaluation: verdicts, coverage, and totals always describe the whole query.
`target_offset`	No	Zero-based position in the target list of the query at which this page of target rows starts. Pass the nextOffset of the previous response to continue. An offset at or past the number of targets returns the whole-query verdicts and totals with no target rows.

Output Schema

Name	Required	Description
`cap`	No	The page size applied: target_limit, or 10 when target_limit was above 10.
`error`	No	Present when the call failed. Absent on success.
`shown`	No	Number of query targets this page covers.
`results`	No	Per-feature verdicts and totals over the whole query for the first 20 entries, each with its own target rows for this page.
`all_clear`	No	True only when every feature clears, which requires every target in the query to have been evaluated for it — for a feature judged on web-features’ feature-level support, every target must be a Baseline core browser. Any entry in omitted_features forces false.
`truncated`	No	True when more query targets remain past this page.
`nextOffset`	No	The target_offset of the next page. Present only while targets remain past this page.
`query_echo`	No	The targets query as the server parsed it.
`totalCount`	No	Number of targets the query resolved to, across every page.
`attribution`	No	Required attribution for the caniuse-derived coverage figures in this response.
`data_version`	No	Vintage of each bundled dataset behind this answer.
`offsetNotice`	No	Why this page carries no target rows, and the offsets that do.
`uncheckedNotice`	No	How many of the query targets were not evaluated for every compared feature, the agents they belong to, and their combined usage share.
`omitted_features`	No	Entries past the first 20, verbatim and in input order, that were not compared. Present only when the call sent more than 20; pass them as features in the next call.
`targets_resolved`	No	The mapping inventory for the query targets on this page: each target that maps onto a browser-compat-data release, and whether it was evaluated. A target with no mapping appears only in unchecked_targets.
`unchecked_targets`	No	The query targets on this page that were not evaluated for every compared feature, each with the reason.
`comparable_features`	No	How many entries in features were compared against the targets, on a key or on web-features’ feature-level support. A miss or an ambiguous entry is not comparable; at 0 nothing was evaluated.
`targets_resolved_total`	No	Query targets that map onto a browser-compat-data release, across every page.
`evaluated_targets_total`	No	Query targets evaluated for every compared feature, across every page. evaluated_targets_total plus unchecked_targets_total is the number of targets in the query.
`target_coverage_percent`	No	Percentage points of global traffic covered by the targets evaluated for every compared feature; 0 when no feature was comparable.
`unchecked_targets_total`	No	Query targets not evaluated for every compared feature, across every page.
`unchecked_coverage_percent`	No	Percentage points of global traffic covered by the targets counted in unchecked_targets_total.

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Far exceeds the readOnly/idempotent annotations: it discloses the 20-evaluated / 100-accepted split with omitted_features overflow, the invariant that verdicts and totals are identical on every page, and the crucial semantic that a target counts as evaluated only where compat data was read, so 'defaults' never clears. It also explains that multi-key web-features ids are judged at feature level rather than per key, which an agent could not infer from any structured field.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded, but the prose is three dense paragraphs of long, multi-clause sentences, and the 20/100 feature cap plus omitted_features overflow is stated in the body and again inside the features parameter description. The information is worth having; the packaging is heavier than necessary.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with five parameters, an output schema, and strong annotations, the description covers evaluation semantics, overflow handling, paging invariants, and feature-id edge cases. The only gap is that it never clarifies when to use this versus browsercompat_check_baseline, which matters given the sibling set.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, but the description adds real cross-parameter meaning: target_limit/target_offset bound only the target rows, never the evaluation, so verdicts and coverage are page-invariant. It also explains where omitted_features entries should be re-submitted. Some cap details are restated from the schema, which keeps it from a 5.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Compute whether a set of web features clears an explicit browserslist target query.' It immediately distinguishes itself from browsercompat_search_features (referenced for key lookup) and implies a whole-query verdict model distinct from a single-feature baseline check, so an agent can tell what it is without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly routes unknown entries to browsercompat_search_features first, explains that resolve is off by default so typos fail visibly, and describes the paging protocol (pass nextOffset). It doesn't say when to prefer browsercompat_check_baseline instead, so the sibling-relationship guidance is incomplete rather than absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

browsercompat_get_featureBrowsercompat Get FeatureA

Read-onlyIdempotent

Inspect

Get the compatibility record for one web feature: Baseline state and the date it crossed, deprecation and standards status, per-browser version added and removed with flags, vendor prefixes and partial-implementation notes — with every other support statement recorded for that browser, such as an earlier prefixed or flagged release, in other_statements — and the MDN and specification links. Accepts a BCD key such as css.selectors.has or a web-features id such as has; the response echoes which one it matched. A web-features id that spans several BCD keys, such as grid, returns web-features’ own feature-level release per Baseline core browser in feature_support and its compat_keys, 100 per page, in place of per-key fields. An unresolved feature returns found: false with guidance rather than an error.

Name	Required	Description
`feature`	Yes	A browser-compat-data key such as css.selectors.has, or a web-features id such as has, 1 to 200 characters. An empty or longer string is rejected against this schema; a whitespace-only string returns invalid_feature_input. Call browsercompat_search_features first if you do not already know the key.
`resolve`	No	When true, a string that is neither a key nor an id falls back to the search index, such as "Container queries (size)" or "Element.prototype.animate". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with its feature_support and compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature.
`subkeys_offset`	No	Direct child keys to skip, default 0. Each subkeys page contains at most 100 keys; pass its next_offset to continue.
`include_runtimes`	No	Add the bun, deno, nodejs, and oculus rows to support. Leave off for browser ship decisions.
`compat_keys_offset`	No	compat_keys to skip, default 0, for a web-features id that spans several keys. Each page of compat_keys holds at most 100; pass compat_keys_next_offset to continue. Has no effect when the feature resolves to a single key.

Output Schema

Name	Required	Description
`name`	No	web-features display name for the feature.
`error`	No	Present when the call failed. Absent on success.
`found`	No	True when the feature string resolved to a tracked entry.
`status`	No	Standards status for the resolved key. Absent for webextensions keys, which record none, and when the id spans more than one key.
`mdn_url`	No	MDN reference page for the resolved key.
`outcome`	No	found when per-feature data was returned, no_compat_data when the entry is tracked but owns no browser-compat-data keys, miss when nothing matched.
`subkeys`	No	Direct child compat records of the resolved BCD key. Absent for childless keys and resolutions without a single key.
`support`	No	One row per reported browser, judged at its newest shipped release, with the other statements recorded for that browser in other_statements. Absent when the id spans more than one browser-compat-data key; feature_support covers that case.
`baseline`	No	Baseline state for the resolved key, or the feature rollup when a web-features id resolved to more than one key.
`guidance`	No	What to do next on a miss or with no compat data.
`spec_urls`	No	Specification URLs for the resolved key, always an array.
`compat_keys`	No	Present when the web-features id spans more than one browser-compat-data key, or as an empty list when it owns none: at most 100 of its keys in declaration order, starting at compat_keys_offset. Call this tool again with one of them for the per-key support, status, and links.
`description`	No	web-features description, or the browser-compat-data description with tags stripped.
`discouraged`	No	Feature-level discouragement, independent of leaf standards status. Also retained in status.discouraged when status exists.
`resolved_as`	No	How the feature string was matched, or null on a miss.
`data_version`	No	Vintage of each bundled dataset behind this answer.
`feature_support`	No	Present only when the web-features id spans more than one browser-compat-data key: one row per Baseline core browser with the release web-features lists for the feature as a whole, the data its feature-level Baseline is computed from. It is web-features’ answer for the feature, not a combination of its keys, and a key can differ from it either way — a lists Chrome 1 while one of its keys is unsupported, and anchor-positioning lists no Chrome release though most of its keys are supported there. Call this tool with one of compat_keys for a key-level answer. Non-core browsers are not covered.
`limiting_browser`	No	Among the Baseline core browsers, the one whose required release is newest by release date. For a single key, present only when every core browser has full, unprefixed, unflagged support at a resolvable added release; for an id spanning more than one key, read from feature_support and present only when it lists all seven core browsers.
`runtimesExcluded`	No	Notes that the feature carries server-runtime or XR data that was left out.
`baselineNotMapped`	No	Explains why a resolved key carries no Baseline state.
`compat_keys_total`	No	Every browser-compat-data key the id owns, before paging. Present with compat_keys.
`compat_keys_next_offset`	No	compat_keys_offset for the next page of compat_keys; absent at or past the end.

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations cover the read-only/idempotent safety profile, and the description adds substantial behavior on top: an unresolved feature returns found: false with guidance rather than an error, results are paginated at 100 per page, and resolve is off by default so typos return a correctable miss. These are exactly the non-obvious behaviors an agent needs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three dense sentences, front-loaded with what the record contains, followed by input acceptance and the multi-key/resolve edge cases. Efficient for the complexity involved, though the enumeration of return fields is lengthy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite an output schema existing, the description covers input forms, multi-key feature expansion, pagination, and the non-error miss path — everything an agent needs to invoke it correctly. Nothing material is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents feature, resolve, subkeys_offset, include_runtimes, and compat_keys_offset in detail. The description reinforces the key-vs-id distinction and the response echoing the matched form, but adds little semantic detail beyond the schema, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Get') and resource ('the compatibility record for one web feature') and enumerates the payload — Baseline state, deprecation/standards status, per-browser add/remove, prefixes, other_statements, MDN/spec links. This clearly distinguishes it from sibling browsercompat_search_features, which is the lookup-oriented tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explains the two accepted input forms (BCD key vs web-features id), the fallback behavior of resolve, and when a multi-key web-features id returns feature-level data. It does not explicitly compare against siblings like browsercompat_check_baseline or browsercompat_compare_support, so the routing guidance is clear but not exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

browsercompat_list_referenceBrowsercompat List ReferenceA

Read-onlyIdempotent

Inspect

Enumerate the reference vocabulary this server uses: BCD namespaces, BCD browser ids, browserslist agent ids and their BCD counterparts, Baseline states, web-features groups, and ECMAScript snapshots. Use it to build valid inputs for the other tools and to see which target browsers can be evaluated.

Name	Required	Description	Default
`topic`	Yes	Which vocabulary to list: bcd_namespaces for the 12 top-level browser-compat-data namespaces, bcd_browsers for the 17 tracked browsers, browserslist_agents for the 19 browserslist ids mapped to browser-compat-data browsers, baseline_states for the 4 Baseline states, groups for the 104 web-features groups, or snapshots for the 11 ECMAScript snapshots.

Output Schema

Name	Required	Description
`error`	No	Present when the call failed. Absent on success.
`topic`	No	The topic that was listed.
`entries`	No	Every entry in the requested vocabulary.
`attribution`	No	Required attribution for the caniuse-derived usage figures in this response.
`data_version`	No	Vintage of each bundled dataset behind this answer.

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so safety and determinism are covered. The description adds that this is a static vocabulary listing used to validate inputs, but it does not disclose output volume (e.g. 104 groups) or whether the vocabularies can shift between server versions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the verb and resource, then the use case. The long enumeration of vocabularies is somewhat duplicative of the enum but still earns its place by signalling scope up front.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

A single required parameter, fully documented in the schema, plus an output schema that carries return values. The description supplies the missing 'why' — that these vocabularies define valid inputs for the sibling tools — so an agent has everything needed to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the enum description already spells out each topic with element counts, so the schema does the heavy lifting. The description restates the same category list without adding format, sizing or selection guidance beyond it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Enumerate') plus resource ('the reference vocabulary this server uses') and then enumerates exactly which vocabularies are covered. The agent can distinguish this static reference tool from the sibling feature-lookup tools without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says when to use it: 'to build valid inputs for the other tools and to see which target browsers can be evaluated.' That is a clear positive trigger, but there are no explicit exclusions or named alternatives (e.g. 'do not use for looking up a feature — use browsercompat_get_feature').

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

browsercompat_search_featuresBrowsercompat Search FeaturesA

Read-onlyIdempotent

Inspect

Find web features by plain name or keyword when the canonical key is unknown, across CSS, JavaScript, HTML, Web APIs, SVG, MathML, WebAssembly, and HTTP headers. Returns ranked matches with the BCD key, the web-features id, the Baseline state, a one-line support summary, and which field matched. Feed a result key into browsercompat_get_feature for the full record.

Name	Required	Description
`group`	No	Restrict results to features in one web-features group or any group nested under it, for example "selectors" or "css". Keys with no web-features mapping never match. Call browsercompat_list_reference with topic groups for valid ids.
`limit`	No	Maximum results to return, at most 50 per call; a value from 51 to 1000 is served as 50. When matches remain, cap reports the size applied and nextOffset continues.
`query`	Yes	Plain-language name, keyword, or code notation, for example "container query", "fromAsync", "Array.prototype.at", "display: grid", or "<dialog>".
`offset`	No	Number of ranked matches to skip before returning results, for paging past limit. Pass the nextOffset from the previous response.
`baseline`	No	Restrict results to one Baseline state.
`snapshot`	No	Restrict results to features in one ECMAScript snapshot, for example "ecmascript-2023". Call browsercompat_list_reference with topic snapshots for valid ids.
`namespace`	No	Restrict results to one top-level browser-compat-data namespace.

Output Schema

Name	Required	Description
`cap`	No	The page size applied: limit, or 50 when limit was above 50.
`error`	No	Present when the call failed. Absent on success.
`shown`	No	Number of results on this page.
`results`	No	Ranked matches, best first. An empty array is a successful search with no hits.
`truncated`	No	True when more matches remain past this page.
`nextOffset`	No	The offset of the next page. Present only while matches remain past this page.
`totalCount`	No	Matches across every page, before offset and limit apply.
`data_version`	No	Vintage of each bundled dataset behind this answer.
`offsetNotice`	No	Why a page came back empty although the search matched.
`noMatchNotice`	No	How to broaden a search that matched nothing.
`appliedFilters`	No	Filters the server applied to this search.

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/closed-world, so safety is covered. The description adds real context beyond that: what each result carries (BCD key, web-features id, Baseline state, support summary, matched field) and that results are ranked, which tells the agent how to interpret ordering. Pagination behavior is left to the schema rather than the description.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, zero filler: purpose and scope first, return shape second, workflow hand-off last. Every sentence earns its place and nothing is buried.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values need not be spelled out, yet the description summarizes them helpfully and closes the loop to get_feature. The remaining gap is silent about the filtering capability exposed by four of the seven parameters, which an agent would only discover by reading the schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds query-shape intuition ("plain name or keyword", canonical key unknown) but never mentions the filter parameters (group, baseline, snapshot, namespace) that materially narrow results, so it contributes little beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ("Find web features by plain name or keyword") and names the exact scope: when the canonical key is unknown, across the enumerated standards areas. It is clearly distinguishable from browsercompat_get_feature, which the description names as the follow-up for a known key.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives an explicit trigger ("when the canonical key is unknown") and an explicit next step ("Feed a result key into browsercompat_get_feature for the full record"), which routes the agent between siblings. It stops short of stating the inverse exclusion — that a known key should go straight to get_feature — leaving that to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

4 tool updatesOct 26, 2026

Changedbrowsercompat_check_baseline1 field changed

changedOutput schema / properties / results / items / properties / usage_percent_excluded / description

Previous value: -"Feature-level share of tracked traffic excluded. A resolved BCD key receives it only when it is the feature’s sole declared compat key. Absent without caniuse data — never zero in that case."New value: +"Feature-level percentage points of global traffic excluded. A resolved BCD key receives it only when it is the feature’s sole declared compat key. Absent without caniuse data — never zero in that case."

Changedbrowsercompat_compare_support8 fields changed

changedInput schema / properties / targets / description

Previous value: -"A browserslist query, for example \"defaults\" or \"> 0.5%, last 2 versions\", 1 to 500 characters. Required: with no query browserslist would read config from the process working directory rather than from your project."New value: +"A self-contained browserslist query, for example \"defaults\" or \"> 0.5%, last 2 versions\", 1 to 500 characters. Config packages and custom configuration are unsupported; local config discovery is disabled."

changedOutput schema / properties / error / properties / data / properties / reason / description

Previous value: -"Machine-readable failure mode. Declared by this tool: `invalid_target_query`: browserslist rejected the targets query. `no_targets_resolved`: The query matched no browser versions at all, or only agents with no browser-compat-data counterpart. A mapped agent whose version token does not resolve is reported in unchecked_targets instead. `invalid_feature_input`: An entry in features is whitespace-only, including an entry past the 20th. An empty or over-200-character entry is rejected against the input schema instead. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `invalid_target_query`: browserslist rejected the targets query, or it requires config packages or custom configuration. `no_targets_resolved`: The query matched no browser versions at all, or only agents with no browser-compat-data counterpart. A mapped agent whose version token does not resolve is reported in unchecked_targets instead. `invalid_feature_input`: An entry in features is whitespace-only, including an entry past the 20th. An empty or over-200-character entry is rejected against the input schema instead. Other values are possible when a failure originates below the handler."

changedOutput schema / properties / results / items / properties / evaluated_coverage_percent / description

Previous value: -"Share of tracked global traffic the targets evaluated for this feature cover."New value: +"Percentage points of global traffic the targets evaluated for this feature cover."

changedOutput schema / properties / results / items / properties / unchecked_coverage_percent / description

Previous value: -"Share of tracked global traffic the targets not evaluated for this feature cover."New value: +"Percentage points of global traffic the targets not evaluated for this feature cover."

changed

Output schema / properties / results / items / properties / unchecked_targets / items / properties / usage_percent / description

Previous value: -"Share of tracked global traffic this target covers."New value: +"Percentage points of global traffic this target covers."

changedOutput schema / properties / target_coverage_percent / description

Previous value: -"Share of tracked global traffic covered by the targets evaluated for every compared feature; 0 when no feature was comparable."New value: +"Percentage points of global traffic covered by the targets evaluated for every compared feature; 0 when no feature was comparable."

changedOutput schema / properties / unchecked_coverage_percent / description

Previous value: -"Share of tracked global traffic covered by the targets counted in unchecked_targets_total."New value: +"Percentage points of global traffic covered by the targets counted in unchecked_targets_total."

changedOutput schema / properties / unchecked_targets / items / properties / usage_percent / description

Previous value: -"Share of tracked global traffic this target covers."New value: +"Percentage points of global traffic this target covers."

Changedbrowsercompat_list_reference1 field changed

changedOutput schema / properties / entries / items / properties / usage_percent / description

Previous value: -"Share of tracked global traffic attributed to this browserslist agent."New value: +"Percentage points of global traffic attributed to this browserslist agent."

Changedbrowsercompat_search_features1 field changed

changedOutput schema / properties / results / items / properties / support_summary / description

Previous value: -"One line over the Baseline core browsers, with — for unsupported and ? for unknown."New value: +"One line over the Baseline core browsers: addition release with ≤ for an upper bound and (partial), (prefixed), or (flagged) for qualified support; — for unsupported, removed, or preview-only; ? for unknown."

4 tool updatesOct 15, 2026

Changedbrowsercompat_check_baseline13 fields changed

changedInput schema / properties / features / description

Previous value: -"Up to 20 entries, each a browser-compat-data key such as css.selectors.has or a web-features id such as has, 1 to 200 characters. An empty or longer entry is rejected against this schema; a whitespace-only entry returns invalid_feature_input. Call browsercompat_search_features first for any entry whose key you do not already know."New value: +"Entries to check, each a browser-compat-data key such as css.selectors.has or a web-features id such as has, 1 to 200 characters. The first 20 are evaluated per call; up to 100 are accepted, and entries past the 20th are returned unevaluated in omitted_features. More than 100 entries, or an empty or longer entry anywhere in the list, is rejected against this schema; a whitespace-only entry anywhere returns invalid_feature_input. Call browsercompat_search_features first for any entry whose key you do not already know."

changedInput schema / properties / features / maxItems
```
Previous value: -20New value: +100
```

changedOutput schema / properties / all_widely_available / description

Previous value: -"True only when every entry resolved and reports Baseline widely. A single miss forces false. Deprecation and discouragement do not enter this answer."New value: +"True only when every entry resolved and reports Baseline widely. A single miss, or any entry in omitted_features, forces false. Deprecation and discouragement do not enter this answer."

changedOutput schema / properties / error / properties / data / properties / reason / description

Previous value: -"Machine-readable failure mode. Declared by this tool: `invalid_feature_input`: An entry in features is whitespace-only. An empty or over-200-character entry is rejected against the input schema instead. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `invalid_feature_input`: An entry in features is whitespace-only, including an entry past the 20th. An empty or over-200-character entry is rejected against the input schema instead. Other values are possible when a failure originates below the handler."

addedOutput schema / properties / omitted_features

Added value: +{
+  "description": "Entries past the first 20, verbatim and in input order, that were not evaluated. Present only when the call sent more than 20; pass them as features in the next call.",
+  "items": {
+    "type": "string"
+  },
+  "type": "array"
+}

changedOutput schema / properties / results / description

Previous value: -"One result per requested feature. A miss is a result, not a failure."New value: +"One result per evaluated entry — the first 20. A miss is a result, not a failure."

changedOutput schema / properties / results / items / description

Previous value: -"One result per input entry, in input order."New value: +"One result per evaluated entry, in input order."

changedOutput schema / properties / results / items / properties / compat_keys / description

Previous value: -"Present when the web-features id spans more than one browser-compat-data key. Call browsercompat_get_feature with one of them for per-browser data."New value: +"Present when the web-features id spans more than one browser-compat-data key, or as an empty list when it owns none: its first 10 keys in declaration order, with compat_keys_total counting all of them. Call browsercompat_get_feature with the id for the rest and its feature-level support per core browser, or with one of these keys for per-browser data."

addedOutput schema / properties / results / items / properties / compat_keys_total

Added value: +{
+  "description": "Every browser-compat-data key the id owns. Present with compat_keys.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

changedOutput schema / properties / results / items / properties / limiting_browser / description

Previous value: -"Among the Baseline core browsers, the one requiring the newest release. Present only when every core browser has full, unprefixed, unflagged support at a resolvable added release."New value: +"Among the Baseline core browsers, the one whose required release is newest by release date. For a single key, present only when every core browser has full, unprefixed, unflagged support at a resolvable added release; for an id spanning more than one key, read from web-features’ feature-level support for the feature as a whole and present only when it lists all seven core browsers."

changedOutput schema / properties / results / items / properties / limiting_browser / properties / version / description

Previous value: -"Release of that browser the feature requires."New value: +"Release of that browser the feature requires, without any ≤ prefix — see version_is_upper_bound."

addedOutput schema / properties / results / items / properties / limiting_browser / properties / version_is_upper_bound

Added value: +{
+  "description": "True when the data says support arrived at or before version, not exactly at it. Absent when version is exact.",
+  "type": "boolean"
+}

changedOutput schema / properties / results / items / properties / resolved_as / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "baseline_id": {
-        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "bcd_key": {
-        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "input": {
-        "description": "The feature string as the caller sent it, trimmed.",
-        "type": "string"
-      },
-      "resolved_via": {
-        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
-        "enum": [
-          "bcd_key",
-          "web_features_id",
-          "web_features_id_normalized",
-          "redirect",
-          "search"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "input",
-      "bcd_key",
-      "baseline_id",
-      "resolved_via"
-    ],
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "baseline_id": {
+        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "bcd_key": {
+        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key or owns none.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "input": {
+        "description": "The feature string as the caller sent it, trimmed.",
+        "type": "string"
+      },
+      "resolved_via": {
+        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
+        "enum": [
+          "bcd_key",
+          "web_features_id",
+          "web_features_id_normalized",
+          "redirect",
+          "search"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "input",
+      "bcd_key",
+      "baseline_id",
+      "resolved_via"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

Changedbrowsercompat_compare_support35 fields changed

changedInput schema / properties / features / description

Previous value: -"Up to 20 entries, each a browser-compat-data key such as css.selectors.has or a web-features id such as has, 1 to 200 characters. An empty or longer entry is rejected against this schema; a whitespace-only entry returns invalid_feature_input. Call browsercompat_search_features first for any entry whose key you do not already know."New value: +"Entries to compare, each a browser-compat-data key such as css.selectors.has or a web-features id such as has, 1 to 200 characters. The first 20 are compared per call; up to 100 are accepted, and entries past the 20th are returned unevaluated in omitted_features. More than 100 entries, or an empty or longer entry anywhere in the list, is rejected against this schema; a whitespace-only entry anywhere returns invalid_feature_input. Call browsercompat_search_features first for any entry whose key you do not already know."

changedInput schema / properties / features / maxItems
```
Previous value: -20New value: +100
```

changedInput schema / properties / resolve / description

Previous value: -"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries (size)\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key and gets a verdict, several keys of one web-features feature resolve to the feature as verdict ambiguous with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."New value: +"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries (size)\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key and is judged on it, several keys of one web-features feature resolve to the feature and are judged on its feature-level support with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."

changedInput schema / properties / target_limit / description

Previous value: -"How many query targets this page covers, 1 to 10. It bounds every list of target rows in the response and never the evaluation: verdicts, coverage, and totals always describe the whole query."New value: +"How many query targets this page covers, at most 10 per call; a value from 11 to 1000 is served as 10, and the cap enrichment field reports the size applied. It bounds every list of target rows in the response and never the evaluation: verdicts, coverage, and totals always describe the whole query."

changedInput schema / properties / target_limit / maximum
```
Previous value: -10New value: +1000
```

changedOutput schema / properties / all_clear / description

Previous value: -"True only when every feature clears, which requires every target in the query to have been evaluated for it."New value: +"True only when every feature clears, which requires every target in the query to have been evaluated for it — for a feature judged on web-features’ feature-level support, every target must be a Baseline core browser. Any entry in omitted_features forces false."

changedOutput schema / properties / cap / description

Previous value: -"The target_limit that was applied."New value: +"The page size applied: target_limit, or 10 when target_limit was above 10."

changedOutput schema / properties / comparable_features / description

Previous value: -"How many entries in features were compared against the targets. A miss or an ambiguous entry is not comparable; at 0 nothing was evaluated."New value: +"How many entries in features were compared against the targets, on a key or on web-features’ feature-level support. A miss or an ambiguous entry is not comparable; at 0 nothing was evaluated."

changedOutput schema / properties / error / properties / data / properties / reason / description

Previous value: -"Machine-readable failure mode. Declared by this tool: `invalid_target_query`: browserslist rejected the targets query. `no_targets_resolved`: The query matched no browser versions at all, or only agents with no browser-compat-data counterpart. A mapped agent whose version token does not resolve is reported in unchecked_targets instead. `invalid_feature_input`: An entry in features is whitespace-only. An empty or over-200-character entry is rejected against the input schema instead. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `invalid_target_query`: browserslist rejected the targets query. `no_targets_resolved`: The query matched no browser versions at all, or only agents with no browser-compat-data counterpart. A mapped agent whose version token does not resolve is reported in unchecked_targets instead. `invalid_feature_input`: An entry in features is whitespace-only, including an entry past the 20th. An empty or over-200-character entry is rejected against the input schema instead. Other values are possible when a failure originates below the handler."

addedOutput schema / properties / omitted_features

Added value: +{
+  "description": "Entries past the first 20, verbatim and in input order, that were not compared. Present only when the call sent more than 20; pass them as features in the next call.",
+  "items": {
+    "type": "string"
+  },
+  "type": "array"
+}

changedOutput schema / properties / results / description

Previous value: -"Per-feature verdicts and totals over the whole query, each with its own target rows for this page."New value: +"Per-feature verdicts and totals over the whole query for the first 20 entries, each with its own target rows for this page."

changedOutput schema / properties / results / items / description

Previous value: -"One result per input entry, in input order."New value: +"One result per evaluated entry, in input order."

changedOutput schema / properties / results / items / properties / compat_keys / description

Previous value: -"Present on an ambiguous verdict — the browser-compat-data keys the feature owns. Re-run with one of them."New value: +"The browser-compat-data keys a web-features id owns, its first 10 in declaration order: present when the id spans more than one key and was judged on its feature-level support, and as an empty list on an ambiguous verdict. compat_keys_total counts all of them; call browsercompat_get_feature with the id for the rest. Call again with one of them for a key-level verdict that also covers non-core browsers."

addedOutput schema / properties / results / items / properties / compat_keys_total

Added value: +{
+  "description": "Every browser-compat-data key the id owns. Present with compat_keys.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

addedOutput schema / properties / results / items / properties / failing_ranges

Added value: +{
+  "description": "Every failing target across the whole query, grouped into runs: consecutive query targets of one browserslist agent that fail with the same verdict, in query order — agents in browserslist’s order, newest run first. A run breaks at any target that passed or was not evaluated for this feature, so it spans only versions the query contains. The counts sum to failing_total, and the list is the same on every page. Empty when nothing failed.",
+  "items": {
+    "additionalProperties": false,
+    "description": "A run of consecutive failing query targets.",
+    "properties": {
+      "agent": {
+        "description": "browserslist agent id of every target in the run.",
+        "type": "string"
+      },
+      "count": {
+        "description": "Query targets in the run.",
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "newest": {
+        "description": "Version token of the run’s first, newest target.",
+        "type": "string"
+      },
+      "oldest": {
+        "description": "Version token of the run’s last, oldest target; equals newest for a run of one.",
+        "type": "string"
+      },
+      "verdict": {
+        "description": "Why this target failed. From a key: partial means the implementation does not meet the mandatory specified behavior, prefixed means it only ships under a vendor prefix or a different name, flagged means it only works behind a preference or runtime flag, removed means it shipped and was later removed before this target version, unsupported means it was never added, preview_only means it only works in a preview channel. From web-features’ feature-level support: before_feature_support means the target predates the release web-features lists for the feature, no_feature_support means web-features lists no release of this core browser for the feature — which also covers a feature it lists no release for at all, such as a discontinued one (mutation-events) that older releases shipped; call again with one of compat_keys for a key-level verdict on such a target.",
+        "enum": [
+          "partial",
+          "prefixed",
+          "flagged",
+          "removed",
+          "unsupported",
+          "preview_only",
+          "before_feature_support",
+          "no_feature_support"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "agent",
+      "newest",
+      "oldest",
+      "count",
+      "verdict"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

changedOutput schema / properties / results / items / properties / failing_targets / description

Previous value: -"The failing targets among the query targets on this page, with the verdict that caused each. Empty on a page that holds none even when failing_total is above zero."New value: +"The failing targets among the query targets on this page, with the verdict that caused each. A row judged on a key also carries the fields of the support statement behind its verdict — version_added, prefix, alternative_name, flags, and the rest — each only when that statement has it; an unsupported or preview_only row, and a row judged on web-features’ feature-level support, carry none. Empty on a page that holds none even when failing_total is above zero."

addedOutput schema / properties / results / items / properties / failing_targets / items / properties / alternative_name

Added value: +{
+  "description": "Entirely different name the feature is implemented under.",
+  "type": "string"
+}

addedOutput schema / properties / results / items / properties / failing_targets / items / properties / flags

Added value: +{
+  "description": "Flags gating support in this browser.",
+  "items": {
+    "additionalProperties": false,
+    "description": "A flag that must be configured for support.",
+    "properties": {
+      "name": {
+        "description": "Name of the flag or preference to configure.",
+        "type": "string"
+      },
+      "type": {
+        "description": "Whether the gate is a user preference or a runtime flag.",
+        "enum": [
+          "preference",
+          "runtime_flag"
+        ],
+        "type": "string"
+      },
+      "value_to_set": {
+        "description": "Value the flag must be set to.",
+        "type": "string"
+      }
+    },
+    "required": [
+      "name",
+      "type"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

addedOutput schema / properties / results / items / properties / failing_targets / items / properties / partial

Added value: +{
+  "description": "True when the implementation does not meet the mandatory specified behavior.",
+  "type": "boolean"
+}

addedOutput schema / properties / results / items / properties / failing_targets / items / properties / prefix
```
Added value: +{
+  "description": "Vendor prefix the feature ships under.",
+  "type": "string"
+}
```

changedOutput schema / properties / results / items / properties / failing_targets / items / properties / verdict / description

Previous value: -"Why this target failed: partial means the implementation does not meet the mandatory specified behavior, prefixed means it only ships under a vendor prefix or a different name, flagged means it only works behind a preference or runtime flag, removed means it shipped and was later removed before this target version, unsupported means it was never added, preview_only means it only works in a preview channel."New value: +"Why this target failed. From a key: partial means the implementation does not meet the mandatory specified behavior, prefixed means it only ships under a vendor prefix or a different name, flagged means it only works behind a preference or runtime flag, removed means it shipped and was later removed before this target version, unsupported means it was never added, preview_only means it only works in a preview channel. From web-features’ feature-level support: before_feature_support means the target predates the release web-features lists for the feature, no_feature_support means web-features lists no release of this core browser for the feature — which also covers a feature it lists no release for at all, such as a discontinued one (mutation-events) that older releases shipped; call again with one of compat_keys for a key-level verdict on such a target."

changedOutput schema / properties / results / items / properties / failing_targets / items / properties / verdict / enum

Previous value: -[
-  "partial",
-  "prefixed",
-  "flagged",
-  "removed",
-  "unsupported",
-  "preview_only"
-]New value: +[
+  "partial",
+  "prefixed",
+  "flagged",
+  "removed",
+  "unsupported",
+  "preview_only",
+  "before_feature_support",
+  "no_feature_support"
+]

addedOutput schema / properties / results / items / properties / failing_targets / items / properties / version_added
```
Added value: +{
+  "description": "Release that added support.",
+  "type": "string"
+}
```

added

Output schema / properties / results / items / properties / failing_targets / items / properties / version_added_is_upper_bound

Added value: +{
+  "description": "True when the data says support arrived at or before version_added, not exactly at it.",
+  "type": "boolean"
+}

addedOutput schema / properties / results / items / properties / failing_targets / items / properties / version_last
```
Added value: +{
+  "description": "Last release that still supported the feature.",
+  "type": "string"
+}
```
addedOutput schema / properties / results / items / properties / failing_targets / items / properties / version_removed
```
Added value: +{
+  "description": "Release that removed support.",
+  "type": "string"
+}
```

changedOutput schema / properties / results / items / properties / failing_total / description

Previous value: -"Failing targets across the whole query. Present when the feature was compared, as are the five fields after it."New value: +"Failing targets across the whole query. Present when the feature was compared, as are the six fields after it."

changedOutput schema / properties / results / items / properties / resolved_as / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "baseline_id": {
-        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "bcd_key": {
-        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "input": {
-        "description": "The feature string as the caller sent it, trimmed.",
-        "type": "string"
-      },
-      "resolved_via": {
-        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
-        "enum": [
-          "bcd_key",
-          "web_features_id",
-          "web_features_id_normalized",
-          "redirect",
-          "search"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "input",
-      "bcd_key",
-      "baseline_id",
-      "resolved_via"
-    ],
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "baseline_id": {
+        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "bcd_key": {
+        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key or owns none.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "input": {
+        "description": "The feature string as the caller sent it, trimmed.",
+        "type": "string"
+      },
+      "resolved_via": {
+        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
+        "enum": [
+          "bcd_key",
+          "web_features_id",
+          "web_features_id_normalized",
+          "redirect",
+          "search"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "input",
+      "bcd_key",
+      "baseline_id",
+      "resolved_via"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

addedOutput schema / properties / results / items / properties / support_source

Added value: +{
+  "description": "What the verdict was judged on. bcd_key: one browser-compat-data key’s per-browser support. web_features_feature: for an id spanning more than one key, web-features’ own release per Baseline core browser for the feature as a whole — never a combination of its keys, and a key can differ from it either way; browsers outside the core set are then not evaluated. Present on every compared result.",
+  "enum": [
+    "bcd_key",
+    "web_features_feature"
+  ],
+  "type": "string"
+}

changed

Output schema / properties / results / items / properties / unchecked_targets / items / properties / reason / description

Previous value: -"no_bcd_browser when the agent has no browser-compat-data counterpart, unknown_version when the token maps to no release, no_bcd_data when a compared feature records nothing for that browser, no_comparable_feature when every entry in features was a miss or ambiguous so nothing was compared."New value: +"no_bcd_browser when the agent has no browser-compat-data counterpart, unknown_version when the token maps to no release, no_bcd_data when a compared key records nothing for that browser, no_feature_level_data when a feature judged on web-features’ feature-level support has no answer for the target — a browser outside the Baseline core set, or a release before a ≤ bound — so call again with one of its compat_keys for a key-level answer, no_comparable_feature when every entry in features was a miss or ambiguous so nothing was compared. In the top-level list a target unchecked by several compared features takes the reason of the first of them."

changedOutput schema / properties / results / items / properties / unchecked_targets / items / properties / reason / enum

Previous value: -[
-  "no_bcd_browser",
-  "unknown_version",
-  "no_bcd_data",
-  "no_comparable_feature"
-]New value: +[
+  "no_bcd_browser",
+  "unknown_version",
+  "no_bcd_data",
+  "no_feature_level_data",
+  "no_comparable_feature"
+]

changedOutput schema / properties / results / items / properties / verdict / description

Previous value: -"Judged over the whole query, never over one page. fails when any evaluated target does not support the feature; inconclusive when nothing failed but at least one target in the query was not evaluated for this feature, including when none was; clears only when every target in the query was evaluated and supports it; miss when the entry did not resolve; ambiguous when the id spans more than one compat key or owns none."New value: +"Judged over the whole query, never over one page. fails when any evaluated target does not support the feature; inconclusive when nothing failed but at least one target in the query was not evaluated for this feature, including when none was; clears only when every target in the query was evaluated and supports it; miss when the entry did not resolve; ambiguous when the web-features id owns no browser-compat-data keys, so there is no support data to judge."

changedOutput schema / properties / targets_resolved / items / properties / evaluated / description

Previous value: -"True when every compared feature has compatibility data for this target. False when at least one compared feature records nothing for its browser, or when no feature in the call was comparable — the target then also appears in unchecked_targets. Mapping onto a release is not evaluation."New value: +"True when every compared feature has compatibility data for this target. False when at least one compared feature records nothing for its browser or has no feature-level data for it, or when no feature in the call was comparable — the target then also appears in unchecked_targets. Mapping onto a release is not evaluation."

changedOutput schema / properties / unchecked_targets / items / properties / reason / description

Previous value: -"no_bcd_browser when the agent has no browser-compat-data counterpart, unknown_version when the token maps to no release, no_bcd_data when a compared feature records nothing for that browser, no_comparable_feature when every entry in features was a miss or ambiguous so nothing was compared."New value: +"no_bcd_browser when the agent has no browser-compat-data counterpart, unknown_version when the token maps to no release, no_bcd_data when a compared key records nothing for that browser, no_feature_level_data when a feature judged on web-features’ feature-level support has no answer for the target — a browser outside the Baseline core set, or a release before a ≤ bound — so call again with one of its compat_keys for a key-level answer, no_comparable_feature when every entry in features was a miss or ambiguous so nothing was compared. In the top-level list a target unchecked by several compared features takes the reason of the first of them."

changedOutput schema / properties / unchecked_targets / items / properties / reason / enum

Previous value: -[
-  "no_bcd_browser",
-  "unknown_version",
-  "no_bcd_data",
-  "no_comparable_feature"
-]New value: +[
+  "no_bcd_browser",
+  "unknown_version",
+  "no_bcd_data",
+  "no_feature_level_data",
+  "no_comparable_feature"
+]

Changedbrowsercompat_get_feature12 fields changed

addedInput schema / properties / compat_keys_offset

Added value: +{
+  "default": 0,
+  "description": "compat_keys to skip, default 0, for a web-features id that spans several keys. Each page of compat_keys holds at most 100; pass compat_keys_next_offset to continue. Has no effect when the feature resolves to a single key.",
+  "maximum": 9007199254740991,
+  "minimum": 0,
+  "type": "integer"
+}

changedInput schema / properties / resolve / description

Previous value: -"When true, a string that is neither a key nor an id falls back to the search index, such as \"Container queries (size)\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."New value: +"When true, a string that is neither a key nor an id falls back to the search index, such as \"Container queries (size)\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with its feature_support and compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."

changedOutput schema / properties / compat_keys / description

Previous value: -"Present when the web-features id spans more than one browser-compat-data key. Call this tool again with one of them for the per-browser fields."New value: +"Present when the web-features id spans more than one browser-compat-data key, or as an empty list when it owns none: at most 100 of its keys in declaration order, starting at compat_keys_offset. Call this tool again with one of them for the per-key support, status, and links."

addedOutput schema / properties / compat_keys_next_offset

Added value: +{
+  "description": "compat_keys_offset for the next page of compat_keys; absent at or past the end.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

addedOutput schema / properties / compat_keys_total

Added value: +{
+  "description": "Every browser-compat-data key the id owns, before paging. Present with compat_keys.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

addedOutput schema / properties / feature_support

Added value: +{
+  "description": "Present only when the web-features id spans more than one browser-compat-data key: one row per Baseline core browser with the release web-features lists for the feature as a whole, the data its feature-level Baseline is computed from. It is web-features’ answer for the feature, not a combination of its keys, and a key can differ from it either way — a lists Chrome 1 while one of its keys is unsupported, and anchor-positioning lists no Chrome release though most of its keys are supported there. Call this tool with one of compat_keys for a key-level answer. Non-core browsers are not covered.",
+  "items": {
+    "additionalProperties": false,
+    "description": "web-features’ support for one core browser.",
+    "properties": {
+      "browser_id": {
+        "description": "browser-compat-data browser id of a Baseline core browser.",
+        "type": "string"
+      },
+      "supported": {
+        "description": "True when web-features lists a release for this browser for the feature as a whole; false when it lists none.",
+        "type": "boolean"
+      },
+      "version": {
+        "description": "Release web-features lists for the feature, without any ≤ prefix. Absent when supported is false.",
+        "type": "string"
+      },
+      "version_is_upper_bound": {
+        "description": "True when web-features lists the release as ≤, so support arrived at or before version, not exactly at it.",
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "browser_id",
+      "supported"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

changedOutput schema / properties / limiting_browser / description

Previous value: -"Among the Baseline core browsers, the one requiring the newest release. Present only when every core browser has full, unprefixed, unflagged support at a resolvable added release."New value: +"Among the Baseline core browsers, the one whose required release is newest by release date. For a single key, present only when every core browser has full, unprefixed, unflagged support at a resolvable added release; for an id spanning more than one key, read from feature_support and present only when it lists all seven core browsers."

changedOutput schema / properties / limiting_browser / properties / version / description

Previous value: -"Release of that browser the feature requires."New value: +"Release of that browser the feature requires, without any ≤ prefix — see version_is_upper_bound."

addedOutput schema / properties / limiting_browser / properties / version_is_upper_bound

Added value: +{
+  "description": "True when the data says support arrived at or before version, not exactly at it. Absent when version is exact.",
+  "type": "boolean"
+}

changedOutput schema / properties / resolved_as / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "baseline_id": {
-        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "bcd_key": {
-        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "input": {
-        "description": "The feature string as the caller sent it, trimmed.",
-        "type": "string"
-      },
-      "resolved_via": {
-        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
-        "enum": [
-          "bcd_key",
-          "web_features_id",
-          "web_features_id_normalized",
-          "redirect",
-          "search"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "input",
-      "bcd_key",
-      "baseline_id",
-      "resolved_via"
-    ],
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "baseline_id": {
+        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "bcd_key": {
+        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key or owns none.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "input": {
+        "description": "The feature string as the caller sent it, trimmed.",
+        "type": "string"
+      },
+      "resolved_via": {
+        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
+        "enum": [
+          "bcd_key",
+          "web_features_id",
+          "web_features_id_normalized",
+          "redirect",
+          "search"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "input",
+      "bcd_key",
+      "baseline_id",
+      "resolved_via"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedOutput schema / properties / support / description

Previous value: -"One row per reported browser. Absent when the id spans more than one browser-compat-data key."New value: +"One row per reported browser, judged at its newest shipped release, with the other statements recorded for that browser in other_statements. Absent when the id spans more than one browser-compat-data key; feature_support covers that case."

addedOutput schema / properties / support / items / properties / other_statements

Added value: +{
+  "description": "Every other support statement browser-compat-data records for this browser, in its declaration order: prefixed, alternative-name, flagged, partial, preview, and removed ranges. A statement the row fields above came from is never repeated here. Absent when there are none.",
+  "items": {
+    "additionalProperties": false,
+    "description": "One other support statement for this browser.",
+    "properties": {
+      "alternative_name": {
+        "description": "Entirely different name the feature is implemented under.",
+        "type": "string"
+      },
+      "flags": {
+        "description": "Flags gating support in this browser.",
+        "items": {
+          "additionalProperties": false,
+          "description": "A flag that must be configured for support.",
+          "properties": {
+            "name": {
+              "description": "Name of the flag or preference to configure.",
+              "type": "string"
+            },
+            "type": {
+              "description": "Whether the gate is a user preference or a runtime flag.",
+              "enum": [
+                "preference",
+                "runtime_flag"
+              ],
+              "type": "string"
+            },
+            "value_to_set": {
+              "description": "Value the flag must be set to.",
+              "type": "string"
+            }
+          },
+          "required": [
+            "name",
+            "type"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "impl_url": {
+        "description": "Links to bugs or issues tracking the implementation, always an array.",
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "notes": {
+        "description": "Notes from browser-compat-data about this support, always an array.",
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "partial": {
+        "description": "True when the implementation does not meet the mandatory specified behavior.",
+        "type": "boolean"
+      },
+      "prefix": {
+        "description": "Vendor prefix the feature ships under.",
+        "type": "string"
+      },
+      "version_added": {
+        "description": "Release that added support under this statement, or preview when it only works in a preview channel.",
+        "type": "string"
+      },
+      "version_added_is_upper_bound": {
+        "description": "True when the data says support arrived at or before version_added, not exactly at it.",
+        "type": "boolean"
+      },
+      "version_last": {
+        "description": "Last release that still supported the feature.",
+        "type": "string"
+      },
+      "version_removed": {
+        "description": "Release that removed support.",
+        "type": "string"
+      }
+    },
+    "type": "object"
+  },
+  "type": "array"
+}

Changedbrowsercompat_search_features3 fields changed

changedInput schema / properties / limit / description

Previous value: -"Maximum results to return, from 1 to 50."New value: +"Maximum results to return, at most 50 per call; a value from 51 to 1000 is served as 50. When matches remain, cap reports the size applied and nextOffset continues."

changedInput schema / properties / limit / maximum
```
Previous value: -50New value: +1000
```

changedOutput schema / properties / cap / description

Previous value: -"The limit that was applied."New value: +"The page size applied: limit, or 50 when limit was above 50."

3 tool updatesSep 30, 2026

Changedbrowsercompat_check_baseline3 fields changed

changedInput schema / properties / resolve / description

Previous value: -"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with its feature-level Baseline and compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct."New value: +"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries (size)\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with its feature-level Baseline and compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct."

changedOutput schema / properties / results / items / properties / limiting_browser / description

Previous value: -"Among the Baseline core browsers, the one requiring the newest release."New value: +"Among the Baseline core browsers, the one requiring the newest release. Present only when every core browser has full, unprefixed, unflagged support at a resolvable added release."

changedOutput schema / properties / results / items / properties / usage_percent_excluded / description

Previous value: -"Share of tracked global traffic that requiring this feature would exclude. Absent when the feature reaches no caniuse id — never zero in that case."New value: +"Feature-level share of tracked traffic excluded. A resolved BCD key receives it only when it is the feature’s sole declared compat key. Absent without caniuse data — never zero in that case."

Changedbrowsercompat_compare_support33 fields changed

changedInput schema / properties / resolve / description

Previous value: -"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key and gets a verdict, several keys of one web-features feature resolve to the feature as verdict ambiguous with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."New value: +"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries (size)\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key and gets a verdict, several keys of one web-features feature resolve to the feature as verdict ambiguous with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."

addedInput schema / properties / target_limit

Added value: +{
+  "default": 10,
+  "description": "How many query targets this page covers, 1 to 10. It bounds every list of target rows in the response and never the evaluation: verdicts, coverage, and totals always describe the whole query.",
+  "maximum": 10,
+  "minimum": 1,
+  "type": "integer"
+}

addedInput schema / properties / target_offset

Added value: +{
+  "default": 0,
+  "description": "Zero-based position in the target list of the query at which this page of target rows starts. Pass the nextOffset of the previous response to continue. An offset at or past the number of targets returns the whole-query verdicts and totals with no target rows.",
+  "maximum": 9007199254740991,
+  "minimum": 0,
+  "type": "integer"
+}

changedOutput schema / anyOf

Previous value: -[
-  {
-    "not": {
-      "required": [
-        "error"
-      ]
-    },
-    "required": [
-      "query_echo",
-      "targets_resolved",
-      "unchecked_targets",
-      "target_coverage_percent",
-      "unchecked_coverage_percent",
-      "results",
-      "all_clear",
-      "data_version",
-      "totalCount",
-      "attribution"
-    ]
-  },
-  {
-    "required": [
-      "error"
-    ]
-  }
-]New value: +[
+  {
+    "not": {
+      "required": [
+        "error"
+      ]
+    },
+    "required": [
+      "query_echo",
+      "comparable_features",
+      "targets_resolved",
+      "targets_resolved_total",
+      "evaluated_targets_total",
+      "unchecked_targets",
+      "unchecked_targets_total",
+      "target_coverage_percent",
+      "unchecked_coverage_percent",
+      "results",
+      "all_clear",
+      "data_version",
+      "totalCount",
+      "shown",
+      "cap",
+      "truncated",
+      "attribution"
+    ]
+  },
+  {
+    "required": [
+      "error"
+    ]
+  }
+]

changedOutput schema / properties / all_clear / description

Previous value: -"True only when every feature clears and unchecked_targets is empty."New value: +"True only when every feature clears, which requires every target in the query to have been evaluated for it."

addedOutput schema / properties / cap

Added value: +{
+  "description": "The target_limit that was applied.",
+  "type": "number"
+}

addedOutput schema / properties / comparable_features

Added value: +{
+  "description": "How many entries in features were compared against the targets. A miss or an ambiguous entry is not comparable; at 0 nothing was evaluated.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

addedOutput schema / properties / evaluated_targets_total

Added value: +{
+  "description": "Query targets evaluated for every compared feature, across every page. evaluated_targets_total plus unchecked_targets_total is the number of targets in the query.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

addedOutput schema / properties / nextOffset

Added value: +{
+  "description": "The target_offset of the next page. Present only while targets remain past this page.",
+  "type": "number"
+}

addedOutput schema / properties / offsetNotice

Added value: +{
+  "description": "Why this page carries no target rows, and the offsets that do.",
+  "type": "string"
+}

changedOutput schema / properties / results / description

Previous value: -"Per-feature verdicts against the resolved targets."New value: +"Per-feature verdicts and totals over the whole query, each with its own target rows for this page."

addedOutput schema / properties / results / items / properties / evaluated_coverage_percent

Added value: +{
+  "description": "Share of tracked global traffic the targets evaluated for this feature cover.",
+  "type": "number"
+}

addedOutput schema / properties / results / items / properties / evaluated_total

Added value: +{
+  "description": "Query targets this feature has compatibility data for, across the whole query.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

changedOutput schema / properties / results / items / properties / failing_targets / description

Previous value: -"Every resolved target that failed, with the verdict that caused it."New value: +"The failing targets among the query targets on this page, with the verdict that caused each. Empty on a page that holds none even when failing_total is above zero."

addedOutput schema / properties / results / items / properties / failing_total

Added value: +{
+  "description": "Failing targets across the whole query. Present when the feature was compared, as are the five fields after it.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

addedOutput schema / properties / results / items / properties / unchecked_coverage_percent

Added value: +{
+  "description": "Share of tracked global traffic the targets not evaluated for this feature cover.",
+  "type": "number"
+}

addedOutput schema / properties / results / items / properties / unchecked_targets

Added value: +{
+  "description": "The targets not evaluated for this feature among the query targets on this page, each with its reason.",
+  "items": {
+    "additionalProperties": false,
+    "description": "A target this feature was not evaluated against.",
+    "properties": {
+      "agent": {
+        "description": "browserslist agent id.",
+        "type": "string"
+      },
+      "reason": {
+        "description": "no_bcd_browser when the agent has no browser-compat-data counterpart, unknown_version when the token maps to no release, no_bcd_data when a compared feature records nothing for that browser, no_comparable_feature when every entry in features was a miss or ambiguous so nothing was compared.",
+        "enum": [
+          "no_bcd_browser",
+          "unknown_version",
+          "no_bcd_data",
+          "no_comparable_feature"
+        ],
+        "type": "string"
+      },
+      "usage_percent": {
+        "description": "Share of tracked global traffic this target covers.",
+        "type": "number"
+      },
+      "version_token": {
+        "description": "Version token browserslist produced for that agent.",
+        "type": "string"
+      }
+    },
+    "required": [
+      "agent",
+      "version_token",
+      "reason",
+      "usage_percent"
+    ],
+    "type": "object"
+  },
+  "type": "array"
+}

addedOutput schema / properties / results / items / properties / unchecked_total

Added value: +{
+  "description": "Query targets not evaluated for this feature, across the whole query. evaluated_total plus unchecked_total is the number of targets in the query.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

changedOutput schema / properties / results / items / properties / verdict / description

Previous value: -"clears only when every resolved target is supported; inconclusive when a target could not be evaluated, including when no target resolved at all; ambiguous when the id spans more than one compat key."New value: +"Judged over the whole query, never over one page. fails when any evaluated target does not support the feature; inconclusive when nothing failed but at least one target in the query was not evaluated for this feature, including when none was; clears only when every target in the query was evaluated and supports it; miss when the entry did not resolve; ambiguous when the id spans more than one compat key or owns none."

addedOutput schema / properties / shown

Added value: +{
+  "description": "Number of query targets this page covers.",
+  "type": "number"
+}

changedOutput schema / properties / target_coverage_percent / description

Previous value: -"Share of tracked global traffic the evaluated targets cover."New value: +"Share of tracked global traffic covered by the targets evaluated for every compared feature; 0 when no feature was comparable."

changedOutput schema / properties / targets_resolved / description

Previous value: -"Every browserslist token that was evaluated."New value: +"The mapping inventory for the query targets on this page: each target that maps onto a browser-compat-data release, and whether it was evaluated. A target with no mapping appears only in unchecked_targets."

addedOutput schema / properties / targets_resolved / items / properties / evaluated

Added value: +{
+  "description": "True when every compared feature has compatibility data for this target. False when at least one compared feature records nothing for its browser, or when no feature in the call was comparable — the target then also appears in unchecked_targets. Mapping onto a release is not evaluation.",
+  "type": "boolean"
+}

changedOutput schema / properties / targets_resolved / items / required

Previous value: -[
-  "agent",
-  "version_token",
-  "bcd_browser",
-  "bcd_version",
-  "bcd_release_index"
-]New value: +[
+  "agent",
+  "version_token",
+  "bcd_browser",
+  "bcd_version",
+  "bcd_release_index",
+  "evaluated"
+]

addedOutput schema / properties / targets_resolved_total

Added value: +{
+  "description": "Query targets that map onto a browser-compat-data release, across every page.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

changedOutput schema / properties / totalCount / description

Previous value: -"Number of feature results returned."New value: +"Number of targets the query resolved to, across every page."

addedOutput schema / properties / truncated

Added value: +{
+  "description": "True when more query targets remain past this page.",
+  "type": "boolean"
+}

changedOutput schema / properties / uncheckedNotice / description

Previous value: -"Names the target agents that were not evaluated and their combined usage share."New value: +"How many of the query targets were not evaluated for every compared feature, the agents they belong to, and their combined usage share."

changedOutput schema / properties / unchecked_coverage_percent / description

Previous value: -"Share of tracked global traffic the unevaluated targets cover."New value: +"Share of tracked global traffic covered by the targets counted in unchecked_targets_total."

changedOutput schema / properties / unchecked_targets / description

Previous value: -"Every target the server declined to claim a verdict for, with the reason."New value: +"The query targets on this page that were not evaluated for every compared feature, each with the reason."

changedOutput schema / properties / unchecked_targets / items / properties / reason / description

Previous value: -"no_bcd_browser when the agent has no counterpart, unknown_version when the token maps to no release, no_bcd_data when a feature records nothing for that browser."New value: +"no_bcd_browser when the agent has no browser-compat-data counterpart, unknown_version when the token maps to no release, no_bcd_data when a compared feature records nothing for that browser, no_comparable_feature when every entry in features was a miss or ambiguous so nothing was compared."

changedOutput schema / properties / unchecked_targets / items / properties / reason / enum

Previous value: -[
-  "no_bcd_browser",
-  "unknown_version",
-  "no_bcd_data"
-]New value: +[
+  "no_bcd_browser",
+  "unknown_version",
+  "no_bcd_data",
+  "no_comparable_feature"
+]

addedOutput schema / properties / unchecked_targets_total

Added value: +{
+  "description": "Query targets not evaluated for every compared feature, across every page.",
+  "maximum": 9007199254740991,
+  "minimum": -9007199254740991,
+  "type": "integer"
+}

Changedbrowsercompat_get_feature5 fields changed

changedInput schema / properties / resolve / description

Previous value: -"When true, a string that is neither a key nor an id falls back to the search index, such as \"Container queries\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."New value: +"When true, a string that is neither a key nor an id falls back to the search index, such as \"Container queries (size)\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."

addedInput schema / properties / subkeys_offset

Added value: +{
+  "default": 0,
+  "description": "Direct child keys to skip, default 0. Each subkeys page contains at most 100 keys; pass its next_offset to continue.",
+  "maximum": 9007199254740991,
+  "minimum": 0,
+  "type": "integer"
+}

addedOutput schema / properties / discouraged

Added value: +{
+  "additionalProperties": false,
+  "description": "Feature-level discouragement, independent of leaf standards status. Also retained in status.discouraged when status exists.",
+  "properties": {
+    "according_to": {
+      "description": "URLs of the bodies that discourage the feature.",
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "reason": {
+      "description": "Why the feature is discouraged, as web-features states it.",
+      "type": "string"
+    }
+  },
+  "required": [
+    "reason",
+    "according_to"
+  ],
+  "type": "object"
+}

changedOutput schema / properties / limiting_browser / description

Previous value: -"Among the Baseline core browsers, the one requiring the newest release. Absent until every core browser has shipped a resolvable version."New value: +"Among the Baseline core browsers, the one requiring the newest release. Present only when every core browser has full, unprefixed, unflagged support at a resolvable added release."

addedOutput schema / properties / subkeys

Added value: +{
+  "additionalProperties": false,
+  "description": "Direct child compat records of the resolved BCD key. Absent for childless keys and resolutions without a single key.",
+  "properties": {
+    "keys": {
+      "description": "At most 100 direct child keys, in BCD traversal order. Call browsercompat_get_feature for one, or browsercompat_check_baseline for up to 20.",
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "next_offset": {
+      "description": "Offset for the next page; absent at or past the end.",
+      "maximum": 9007199254740991,
+      "minimum": -9007199254740991,
+      "type": "integer"
+    },
+    "total": {
+      "description": "Total direct callable child keys, before paging.",
+      "maximum": 9007199254740991,
+      "minimum": -9007199254740991,
+      "type": "integer"
+    },
+    "truncated": {
+      "description": "True when more direct children remain after this page.",
+      "type": "boolean"
+    }
+  },
+  "required": [
+    "total",
+    "keys",
+    "truncated"
+  ],
+  "type": "object"
+}

5 tool updatesSep 22, 2026

Changedbrowsercompat_check_baseline2 fields changed

changedInput schema / properties / resolve / description

Previous value: -"When true, fall back to the search index and accept its single unambiguous top hit for each entry. Off by default so a typo returns a miss you can correct."New value: +"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with its feature-level Baseline and compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct."

changedOutput schema / properties / results / items / properties / resolved_as / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "baseline_id": {
-        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "bcd_key": {
-        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "input": {
-        "description": "The feature string as the caller sent it, trimmed.",
-        "type": "string"
-      },
-      "resolved_via": {
-        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the search index accepted a single unambiguous top hit — treat a search match as a best guess, not a confirmed key.",
-        "enum": [
-          "bcd_key",
-          "web_features_id",
-          "web_features_id_normalized",
-          "redirect",
-          "search"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "input",
-      "bcd_key",
-      "baseline_id",
-      "resolved_via"
-    ],
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "baseline_id": {
+        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "bcd_key": {
+        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "input": {
+        "description": "The feature string as the caller sent it, trimmed.",
+        "type": "string"
+      },
+      "resolved_via": {
+        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
+        "enum": [
+          "bcd_key",
+          "web_features_id",
+          "web_features_id_normalized",
+          "redirect",
+          "search"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "input",
+      "bcd_key",
+      "baseline_id",
+      "resolved_via"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

Changedbrowsercompat_compare_support2 fields changed

changedInput schema / properties / resolve / description

Previous value: -"When true, fall back to the search index and accept its single unambiguous top hit for each entry. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."New value: +"When true, an entry that is neither a key nor an id falls back to the search index, such as \"Container queries\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key and gets a verdict, several keys of one web-features feature resolve to the feature as verdict ambiguous with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."

changedOutput schema / properties / results / items / properties / resolved_as / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "baseline_id": {
-        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "bcd_key": {
-        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "input": {
-        "description": "The feature string as the caller sent it, trimmed.",
-        "type": "string"
-      },
-      "resolved_via": {
-        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the search index accepted a single unambiguous top hit — treat a search match as a best guess, not a confirmed key.",
-        "enum": [
-          "bcd_key",
-          "web_features_id",
-          "web_features_id_normalized",
-          "redirect",
-          "search"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "input",
-      "bcd_key",
-      "baseline_id",
-      "resolved_via"
-    ],
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "baseline_id": {
+        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "bcd_key": {
+        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "input": {
+        "description": "The feature string as the caller sent it, trimmed.",
+        "type": "string"
+      },
+      "resolved_via": {
+        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
+        "enum": [
+          "bcd_key",
+          "web_features_id",
+          "web_features_id_normalized",
+          "redirect",
+          "search"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "input",
+      "bcd_key",
+      "baseline_id",
+      "resolved_via"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

Changedbrowsercompat_get_feature2 fields changed

changedInput schema / properties / resolve / description

Previous value: -"When true, fall back to the search index and accept its single unambiguous top hit. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."New value: +"When true, a string that is neither a key nor an id falls back to the search index, such as \"Container queries\" or \"Element.prototype.animate\". Its best exact matches are accepted only when they name one feature: a single key resolves to that key, several keys of one web-features feature resolve to the feature with compat_keys, and matches spanning two features are a miss. Off by default so a typo returns a miss you can correct rather than a confident answer about the wrong feature."

changedOutput schema / properties / resolved_as / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "baseline_id": {
-        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "bcd_key": {
-        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "input": {
-        "description": "The feature string as the caller sent it, trimmed.",
-        "type": "string"
-      },
-      "resolved_via": {
-        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the search index accepted a single unambiguous top hit — treat a search match as a best guess, not a confirmed key.",
-        "enum": [
-          "bcd_key",
-          "web_features_id",
-          "web_features_id_normalized",
-          "redirect",
-          "search"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "input",
-      "bcd_key",
-      "baseline_id",
-      "resolved_via"
-    ],
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "baseline_id": {
+        "description": "The web-features id this resolved to, or null when no web-features entry covers the key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "bcd_key": {
+        "description": "The single browser-compat-data key this resolved to, or null when the web-features id spans more than one key.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "input": {
+        "description": "The feature string as the caller sent it, trimmed.",
+        "type": "string"
+      },
+      "resolved_via": {
+        "description": "Which step of the resolution order matched: bcd_key or web_features_id for an exact match, web_features_id_normalized when it matched only after lowercasing, redirect when the input pointed to a browser-compat-data entry that has moved or split, or search when resolve was true and the best exact matches in the search index all named one feature or key — treat a search match as a best guess, not a confirmed key.",
+        "enum": [
+          "bcd_key",
+          "web_features_id",
+          "web_features_id_normalized",
+          "redirect",
+          "search"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "input",
+      "bcd_key",
+      "baseline_id",
+      "resolved_via"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

Changedbrowsercompat_list_reference1 field changed

changedInput schema / properties / topic / description

Previous value: -"Which vocabulary to list: bcd_namespaces for the 12 top-level browser-compat-data namespaces, bcd_browsers for the 17 tracked browsers, browserslist_agents for the 19 browserslist ids mapped to browser-compat-data browsers, baseline_states for the 4 Baseline states, groups for the 103 web-features groups, or snapshots for the 11 ECMAScript snapshots."New value: +"Which vocabulary to list: bcd_namespaces for the 12 top-level browser-compat-data namespaces, bcd_browsers for the 17 tracked browsers, browserslist_agents for the 19 browserslist ids mapped to browser-compat-data browsers, baseline_states for the 4 Baseline states, groups for the 104 web-features groups, or snapshots for the 11 ECMAScript snapshots."

Changedbrowsercompat_search_features15 fields changed

addedInput schema / properties / group

Added value: +{
+  "description": "Restrict results to features in one web-features group or any group nested under it, for example \"selectors\" or \"css\". Keys with no web-features mapping never match. Call browsercompat_list_reference with topic groups for valid ids.",
+  "maxLength": 100,
+  "minLength": 1,
+  "type": "string"
+}

addedInput schema / properties / offset

Added value: +{
+  "default": 0,
+  "description": "Number of ranked matches to skip before returning results, for paging past limit. Pass the nextOffset from the previous response.",
+  "maximum": 9007199254740991,
+  "minimum": 0,
+  "type": "integer"
+}

changedInput schema / properties / query / description

Previous value: -"Plain-language name or keyword, for example \"container query\" or \"fromAsync\"."New value: +"Plain-language name, keyword, or code notation, for example \"container query\", \"fromAsync\", \"Array.prototype.at\", \"display: grid\", or \"<dialog>\"."

addedInput schema / properties / snapshot

Added value: +{
+  "description": "Restrict results to features in one ECMAScript snapshot, for example \"ecmascript-2023\". Call browsercompat_list_reference with topic snapshots for valid ids.",
+  "maxLength": 100,
+  "minLength": 1,
+  "type": "string"
+}

addedOutput schema / properties / appliedFilters / properties / group

Added value: +{
+  "description": "web-features group filter the search applied, nested groups included.",
+  "type": "string"
+}

addedOutput schema / properties / appliedFilters / properties / snapshot

Added value: +{
+  "description": "ECMAScript snapshot filter the search applied.",
+  "type": "string"
+}

changedOutput schema / properties / error / properties / data / properties / reason / description

Previous value: -"Machine-readable failure mode. Declared by this tool: `invalid_query`: query is whitespace-only after normalization, or normalizes to zero tokens. Other values are possible when a failure originates below the handler."New value: +"Machine-readable failure mode. Declared by this tool: `invalid_query`: query is whitespace-only after normalization, or normalizes to zero tokens. `unknown_group`: group names no web-features group in the bundled data. `unknown_snapshot`: snapshot names no ECMAScript snapshot in the bundled data. Other values are possible when a failure originates below the handler."

changedOutput schema / properties / error / properties / data / properties / reason / examples

Previous value: -[
-  "invalid_query"
-]New value: +[
+  "invalid_query",
+  "unknown_group",
+  "unknown_snapshot"
+]

addedOutput schema / properties / nextOffset

Added value: +{
+  "description": "The offset of the next page. Present only while matches remain past this page.",
+  "type": "number"
+}

addedOutput schema / properties / offsetNotice

Added value: +{
+  "description": "Why a page came back empty although the search matched.",
+  "type": "string"
+}

changedOutput schema / properties / results / items / properties / matched_on / description

Previous value: -"Which field matched the query, so the ranking can be inspected."New value: +"Which field matched the query, so the ranking can be inspected. path_suffix means the key ends in the dotted or property-value notation the query used, such as Element.animate or display: grid."

changedOutput schema / properties / results / items / properties / matched_on / enum

Previous value: -[
-  "bcd_key",
-  "baseline_id",
-  "name",
-  "caniuse_title",
-  "path_segment",
-  "description",
-  "path_tokens"
-]New value: +[
+  "bcd_key",
+  "baseline_id",
+  "name",
+  "caniuse_title",
+  "path_suffix",
+  "path_segment",
+  "description",
+  "path_tokens"
+]

changedOutput schema / properties / shown / description

Previous value: -"Number of results returned."New value: +"Number of results on this page."

changedOutput schema / properties / totalCount / description

Previous value: -"Matches before the display cap was applied."New value: +"Matches across every page, before offset and limit apply."

changedOutput schema / properties / truncated / description

Previous value: -"True when matches exceeded limit."New value: +"True when more matches remain past this page."

5 tool updatesSep 20, 2026
- First observedbrowsercompat_check_baseline
- First observedbrowsercompat_compare_support
- First observedbrowsercompat_get_feature
- First observedbrowsercompat_list_reference
- First observedbrowsercompat_search_features

Related MCP Connectors

can-i-use A
ai.kaiv
Browser support for web features, live from caniuse. From which version, and is it safe to ship?
Developer Tools Browser Automation Documentation Access
31
https://api.kaiv.ai/api/bridge/mcp/can-i-use-5446c68b
CSS SOTA A
io.github.LuSrodri
What CSS you can actually ship today, from live Baseline data and MDN browser-compat-data.
Developer Tools Code Analysis Documentation Access
61
https://css-sota-mcp.lusrodri.workers.dev/mcp
Dev Facts Check A
app.openkrill
Software end-of-life dates, open-source licenses, browser support for web features and RFC facts.
Developer Tools Documentation Access
81
https://devfacts.openkrill.app/mcp
W3c A
io.github.pipeworx-io
W3C MCP — web-standards lookup over w3c/browser-specs (GitHub, CF-reachable). ~800 current web…
Documentation Access Search
462
https://gateway.pipeworx.io/w3c/mcp

Related MCP Servers

css-sota-mcp
Documentation Access Code Analysis Developer Tools
LuSrodri
A
license
Not graded
quality
C
maintenance
Answers what CSS you can ship today using live Baseline and MDN browser-compat-data, with tools for searching features, checking exact browser support, and auditing stylesheets.
Updated 3 months ago (2026-08-10 22:16 UTC)
MIT
Baseline Checker
Developer Tools Code Analysis
htshongany
A
license
A
quality
D
maintenance
Enables checking web feature compatibility with Baseline standards, analyzing HTML, CSS, and JavaScript code to provide detailed reports on Baseline status, browser support, and recommendations.
Updated a year ago (2025-10-06 12:17 UTC)
2
MIT
mcp-mdn-search
Documentation Access Search
pipeworx-io
A
license
Not graded
quality
B
maintenance
Provides tools to search MDN documentation, get page summaries, and retrieve browser compatibility data.
Updated 3 days ago (2026-10-29 04:45 UTC)
386 npm
MIT
CSS MCP Server
Documentation Access Developer Tools Search
stolinski
A
license
Not graded
quality
D
maintenance
Provides up-to-date CSS documentation and browser compatibility data from MDN through natural language queries. Features intelligent caching and supports all CSS properties, selectors, functions, and concepts with automatic normalization.
Updated a year ago (2025-10-09 23:57 UTC)
68 npm
338
ISC

Try in Browser

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Server Details

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Related MCP Connectors

Related MCP Servers

Glama MCP Gateway

Resources