Caniuse Browser Compatibility Checker

Check browser support for any CSS, HTML, or JavaScript feature — instantly. Get a full compatibility matrix across Chrome, Firefox, Safari, Edge, mobile browsers, and global coverage statistics, powered by the caniuse database.

What does Caniuse Browser Compatibility Checker do?

Caniuse Browser Compatibility Checker looks up any web feature (CSS properties, HTML APIs, JavaScript syntax, browser capabilities) in the official caniuse database and returns a detailed compatibility report for every major browser. You get the current support status, the version when support was first added, and an estimated global user coverage percentage — all from a single API call.

Unlike visiting caniuse.com manually, this actor lets you check dozens of features in one run, export results as structured JSON or CSV, and integrate compatibility checks into CI/CD pipelines, design systems, or automated quality workflows.

It uses the caniuse-lite npm package directly — no web scraping, no network latency, instant results.

Who is Caniuse Browser Compatibility Checker for?

Frontend developers auditing legacy browser support

• You're building a site that must support IE11 or older Safari and need to know which features are safe to use.
• You can batch-check your entire CSS feature list and export the results as a spreadsheet.
• Save hours compared to manually checking each feature on caniuse.com.

DevOps and CI/CD engineers

• Automate compatibility checks as part of your build pipeline.
• Fail a build if a required feature isn't supported in your target browser set.
• Keep a versioned JSON record of feature support across releases.

Design system maintainers

• Validate that all CSS features in your design token library are broadly supported.
• Generate compatibility tables for your documentation automatically.
• Track when new CSS features reach sufficient browser coverage to adopt.

Technical writers and developer advocates

• Generate accurate, up-to-date browser support tables for documentation and blog posts.
• The caniuse database updates regularly — running the actor gives you fresh data every time.

QA engineers and accessibility auditors

• Check that interactive features (fetch, WebRTC, WebSockets, service workers) are available before writing tests.
• Verify CSS features used in accessibility components have adequate support.

Why use Caniuse Browser Compatibility Checker?

• 🚀 Instant results — pure data lookup, no proxy, no browser, finishes in under 5 seconds
• 📦 583 features — covers the full caniuse database: CSS, HTML, JavaScript APIs, media formats
• 🌍 Global coverage % — see what percentage of worldwide users can use each feature natively
• 🔍 Discovery mode — don't know the exact feature slug? Use searchQuery to find matching features
• 📊 Structured output — JSON and CSV export, Apify datasets, ready for spreadsheets or pipelines
• 🖥️ 19 browsers — Chrome, Firefox, Safari, Edge, Opera, iOS Safari, Android Chrome, Samsung Internet, IE, and more
• 📜 Version history — optionally include the full per-version support history for deep audits
• ✅ No API key needed — data comes from the bundled npm package, no external calls
• 🔄 Batch checking — check 100+ features in a single run, no rate limits

What data can you extract?

Field	Description	Example
featureSlug	Caniuse feature identifier	css-grid
title	Full feature name	CSS Grid Layout (level 1)
status	W3C/WHATWG status code	cr
statusLabel	Human-readable status	Candidate Recommendation
globalUsagePct	% of global users with native support	96.37
browsers.chrome.supportStatus	Current support: full/partial/prefixed/none	full
browsers.chrome.versionAdded	First version with native support	57
browsers.chrome.currentVersion	Latest tracked stable version	150
chrome	Flat summary for table view	full (since 57)
firefox	Flat summary for Firefox	full (since 52)
safari	Flat summary for Safari	full (since 11)
edge	Flat summary for Edge	full (since 16)
ios_saf	Flat summary for iOS Safari	full (since 10.3)
and_chr	Flat summary for Android Chrome	full (since 147)
samsung	Flat summary for Samsung Internet	full (since 4)
error	Error message if feature slug not found	null

When includeLegacyVersions: true, each browser object also includes:

• versionHistory — complete map of version → support flag for every tracked version

How much does it cost to check browser compatibility?

This actor uses Pay-Per-Event (PPE) pricing — you only pay for what you use.

Event	FREE tier	Standard pricing
Run start	$0.001	$0.001
Per feature checked	$0.00035	$0.00035

Real-world cost examples:

Use case	Features	Cost
Quick check — 5 features	5	~$0.003
Standard audit — 20 features	20	~$0.008
Full site audit — 100 features	100	~$0.036
Complete caniuse database — 583 features	583	~$0.205

💡 Free plan estimate: Apify gives new users $5 in free credits. At these prices, you can check roughly 14,000 features for free — more than 24 full-database checks.

Volume discounts apply automatically for higher Apify subscription tiers (BRONZE through DIAMOND get up to 75% off per-feature pricing).

How to check browser compatibility for web features

1. Go to apify.com/automation-lab/caniuse-browser-compatibility-checker
2. Click Try for free
3. Enter feature slugs in the Features to check field (e.g., css-grid, flexbox, webp, fetch)
4. Optionally customize which browsers to include
5. Click Start and wait for results (typically 2–5 seconds)
6. Download results as JSON, CSV, or Excel from the dataset tab

💡 Don't know the exact feature slug? Use the Search features field with a keyword like "grid" or "worker" to discover matching slugs, then rerun with the correct values.

Example input for checking common CSS features:

{
    "features": ["css-grid", "flexbox", "css-variables", "css-subgrid", "css-nesting"],
    "browsers": ["chrome", "firefox", "safari", "edge", "ios_saf"],
    "includeLegacyVersions": false,
    "includeUsageStats": true
}

Example input for JavaScript API audit:

{
    "features": ["fetch", "promises", "arrow-functions", "es6-module", "serviceworkers"],
    "browsers": ["chrome", "firefox", "safari", "edge", "ie"],
    "includeUsageStats": true
}

Example input for discovery mode (find feature slugs):

{
    "searchQuery": "animation"
}

Input parameters

Parameter	Type	Required	Default	Description
features	string[]	No*	—	List of caniuse feature slugs to check. Required unless searchQuery is set.
searchQuery	string	No	—	Search keyword to find matching feature slugs (discovery mode). Overrides features.
browsers	string[]	No	All major browsers	Browser IDs to include: chrome, firefox, safari, edge, opera, ios_saf, and_chr, samsung, ie
includeLegacyVersions	boolean	No	false	Include full per-version support history in output
includeUsageStats	boolean	No	true	Include estimated global user coverage percentage

*Either features or searchQuery must be provided.

Available browser IDs:

ID	Browser
chrome	Google Chrome
firefox	Mozilla Firefox
safari	Apple Safari
edge	Microsoft Edge
opera	Opera
ios_saf	Safari on iOS
and_chr	Chrome for Android
samsung	Samsung Internet
ie	Internet Explorer
op_mini	Opera Mini
and_ff	Firefox for Android
baidu	Baidu Browser

Output examples

Standard compatibility check output (one item per feature):

{
    "featureSlug": "css-grid",
    "title": "CSS Grid Layout (level 1)",
    "status": "cr",
    "statusLabel": "Candidate Recommendation",
    "globalUsagePct": 96.37,
    "browsers": {
        "chrome": {
            "browserName": "Chrome",
            "supportStatus": "full",
            "versionAdded": "57",
            "currentVersion": "150",
            "notes": null
        },
        "firefox": {
            "browserName": "Firefox",
            "supportStatus": "full",
            "versionAdded": "52",
            "currentVersion": "152",
            "notes": null
        },
        "safari": {
            "browserName": "Safari",
            "supportStatus": "full",
            "versionAdded": "11",
            "currentVersion": "TP",
            "notes": null
        },
        "edge": {
            "browserName": "Edge",
            "supportStatus": "full",
            "versionAdded": "16",
            "currentVersion": "146",
            "notes": null
        },
        "ie": {
            "browserName": "Internet Explorer",
            "supportStatus": "none",
            "versionAdded": null,
            "currentVersion": "11",
            "notes": null
        }
    },
    "chrome": "full (since 57)",
    "firefox": "full (since 52)",
    "safari": "full (since 11)",
    "edge": "full (since 16)",
    "ie": "none",
    "error": null
}

Discovery mode output (when searchQuery is set):

{
    "searchQuery": "animation",
    "results": [
        { "slug": "css-animation", "title": "CSS Animations", "status": "cr", "statusLabel": "Candidate Recommendation" },
        { "slug": "css-grid-animation", "title": "CSS Grid animations", "status": "wd", "statusLabel": "Working Draft" },
        { "slug": "web-animation", "title": "Web Animations API", "status": "cr", "statusLabel": "Candidate Recommendation" }
    ],
    "message": "Found 3 features. Use the \"slug\" values in the \"features\" input field to check browser compatibility."
}

Support status values:

• full — native support, no prefix or workarounds needed
• partial — partial/limited support (some properties/methods missing)
• prefixed — requires vendor prefix (e.g., -webkit-)
• none — not supported
• unknown — status unknown

Tips for best results

• 🔍 Use discovery mode first — if you're unsure of a feature slug, set searchQuery to a keyword. Slug matching is exact (case-sensitive, hyphens matter): css-grid not CSS Grid.
• 📋 Batch all features in one run — there's no rate limit and each additional feature costs only $0.00035. Don't run one-by-one.
• 💾 Export to CSV for spreadsheets — use the dataset CSV export for compatibility matrices in Google Sheets or Excel.
• 🕐 Schedule weekly runs — browser versions update frequently. Schedule a weekly run to keep your compatibility data current.
• ⚠️ Partial support matters — a partial status means the feature works but with limitations. Always check MDN for what's missing before shipping.
• 🌍 Check globalUsagePct — features above 95% global coverage are generally safe to use without polyfills.
• 📜 Use includeLegacyVersions: true for polyfill research — see exactly which versions need polyfills and from when.
• 🔎 W3C status reference: ls=Living Standard, cr=Candidate Recommendation, wd=Working Draft, rec=W3C Recommendation, unoff=Unofficial

Integrations

Caniuse Browser Compatibility Checker → Google Sheets Connect via the Apify integration or export CSV directly. Build a living compatibility matrix that updates automatically each week via scheduled runs. Perfect for design system documentation.

Caniuse Browser Compatibility Checker → Slack alerts Use Apify webhooks to notify your frontend team on Slack when a newly supported browser version crosses the 95% global coverage threshold — your signal to drop a polyfill.

Caniuse Browser Compatibility Checker → Make (Integromat) / Zapier Trigger a compatibility audit every time a PR is merged. If any feature drops below your target coverage, create a JIRA ticket automatically.

Scheduled monitoring Set up a weekly cron run on Apify to track when features you care about gain support in new browser versions. The database updates in sync with npm (caniuse-lite is updated with each new browser release).

CI/CD pipeline integration Use the Apify API (see below) to run compatibility checks as part of your build pipeline. Fail the build if a required feature has < 90% global coverage or lacks support in a target browser.

Using the Apify API

Node.js

const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/caniuse-browser-compatibility-checker').call({
    features: ['css-grid', 'flexbox', 'webp', 'fetch', 'es6-module'],
    browsers: ['chrome', 'firefox', 'safari', 'edge', 'ios_saf'],
    includeUsageStats: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log('Results:', items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/caniuse-browser-compatibility-checker').call(run_input={
    'features': ['css-grid', 'flexbox', 'webp', 'fetch', 'es6-module'],
    'browsers': ['chrome', 'firefox', 'safari', 'edge', 'ios_saf'],
    'includeUsageStats': True,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['featureSlug'], item['chrome'], item['globalUsagePct'])

cURL

# Start the actor run
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~caniuse-browser-compatibility-checker/runs' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -d '{
    "features": ["css-grid", "flexbox", "webp"],
    "browsers": ["chrome", "firefox", "safari", "edge"],
    "includeUsageStats": true
  }'

# Fetch results (replace DATASET_ID from the run response)
curl 'https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN'

Use with AI agents via MCP

Caniuse Browser Compatibility Checker is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com"

Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

Example prompts

Once connected, try asking your AI assistant:

• "Use automation-lab/caniuse-browser-compatibility-checker to check if css-grid, flexbox, and css-variables are supported in Safari 15"
• "Check which CSS and JavaScript features from this list have less than 90% global browser coverage"
• "Find all caniuse features related to 'worker' and tell me which ones are supported in IE11"

Learn more in the Apify MCP documentation.

Is it legal to use this data?

Yes. The caniuse data is from the caniuse npm package, which is licensed under CC BY 4.0 (Creative Commons Attribution 4.0). The data is publicly available and widely used in open-source tools like Autoprefixer, Browserslist, and babel-preset-env.

This actor queries the locally bundled npm package — it does not scrape the caniuse.com website.

FAQ

How accurate is the browser support data? The data comes directly from caniuse-lite, which is updated with each new browser release and is the same dataset used by tools like Autoprefixer, postcss-preset-env, and Babel. It's the industry standard for browser compatibility data.

What does "partial" support mean? Partial support (a in the raw caniuse flags) means the browser implements the feature but with limitations — some properties, methods, or behaviors may be missing or buggy. Always check MDN Web Docs or the caniuse notes for the specific limitations before shipping code that relies on partial support.

Can I check support for a specific browser version? The default output shows whether the current stable version supports a feature, plus the first version where support was added. To see the full per-version breakdown, set includeLegacyVersions: true — you'll get a complete version map for every tracked release.

Why is my feature returning "not found"? Caniuse feature slugs are exact and case-sensitive. css-grid works; CSS Grid or css_grid don't. Use searchQuery with a keyword to discover the correct slug (e.g., searchQuery: "grid" returns all grid-related features).

How do I get the list of all 583 available features? Run the actor with searchQuery: "" (empty string) — this returns all features sorted alphabetically. Or check the caniuse GitHub repository directly.

Why is the global usage percentage different from what I see on caniuse.com? The percentage is computed from the usage_global data in the caniuse-lite package. This data is sourced from StatCounter and is the same data shown on caniuse.com. Small differences may appear due to different update timing of the npm package vs the website.

The actor ran but returned no output. What went wrong? If neither features nor searchQuery is provided, or if features is an empty array, the actor exits with an error log. Check the actor logs in the Apify console. Make sure the features array contains at least one non-empty string.

Other web development tools

• Color Contrast Checker (WCAG) — Check color pairs against WCAG 2.1 AA and AAA contrast standards
• JSON Schema Generator — Generate JSON Schema from sample data automatically