# Caniuse Browser Compatibility Checker (`automation-lab/caniuse-browser-compatibility-checker`) Actor

Check browser support for CSS, HTML, and JavaScript features using the caniuse database. Returns a compatibility matrix across Chrome, Firefox, Safari, Edge, mobile browsers, and global coverage stats.

- **URL**: https://apify.com/automation-lab/caniuse-browser-compatibility-checker.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 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](https://caniuse.com/) 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](https://caniuse.com/) 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](https://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:**

```json
{
    "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:**

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

**Example input for discovery mode (find feature slugs):**

```json
{
    "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):**

```json
{
    "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):**

```json
{
    "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

```javascript
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

```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

```bash
## 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)](https://docs.apify.com/platform/integrations/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

```bash
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:

```json
{
    "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](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to use this data?

Yes. The caniuse data is from the [caniuse npm package](https://www.npmjs.com/package/caniuse-lite), 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](https://github.com/nicolo-ribaudo/caniuse-lite) 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)](https://apify.com/automation-lab/color-contrast-checker) — Check color pairs against WCAG 2.1 AA and AAA contrast standards
- [JSON Schema Generator](https://apify.com/automation-lab/json-schema-generator) — Generate JSON Schema from sample data automatically

# Actor input Schema

## `features` (type: `array`):

List of caniuse feature slugs to check. Use exact slugs from <a href='https://caniuse.com/' target='_blank'>caniuse.com</a> (e.g. <code>css-grid</code>, <code>flexbox</code>, <code>webp</code>, <code>fetch</code>, <code>es6-module</code>, <code>css-variables</code>). You can also use the <code>searchQuery</code> field to discover feature slugs.

## `searchQuery` (type: `string`):

Optional. Enter a keyword to search for matching feature slugs (e.g. "grid", "animation", "worker"). Returns a list of matching slugs and titles — useful for discovering the right slug before running a full check. When set, this overrides the <code>features</code> list.

## `browsers` (type: `array`):

Which browsers to include in the compatibility matrix. Leave empty to include all major browsers (Chrome, Firefox, Safari, Edge, Opera, iOS Safari, Chrome for Android, Samsung Internet). Available: <code>chrome</code>, <code>firefox</code>, <code>safari</code>, <code>edge</code>, <code>opera</code>, <code>ios\_saf</code>, <code>and\_chr</code>, <code>samsung</code>, <code>ie</code>.

## `includeLegacyVersions` (type: `boolean`):

Include full version-by-version support history in the output. When false (default), only shows: current support status, the version when support was added, and notes.

## `includeUsageStats` (type: `boolean`):

Include estimated global user coverage percentage (from caniuse usage data) in the output.

## Actor input object example

```json
{
  "features": [
    "css-grid",
    "flexbox",
    "webp",
    "fetch",
    "es6-module"
  ],
  "browsers": [
    "chrome",
    "firefox",
    "safari",
    "edge",
    "opera",
    "ios_saf",
    "and_chr",
    "samsung"
  ],
  "includeLegacyVersions": false,
  "includeUsageStats": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "features": [
        "css-grid",
        "flexbox",
        "webp",
        "fetch",
        "es6-module"
    ],
    "browsers": [
        "chrome",
        "firefox",
        "safari",
        "edge",
        "opera",
        "ios_saf",
        "and_chr",
        "samsung"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/caniuse-browser-compatibility-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "features": [
        "css-grid",
        "flexbox",
        "webp",
        "fetch",
        "es6-module",
    ],
    "browsers": [
        "chrome",
        "firefox",
        "safari",
        "edge",
        "opera",
        "ios_saf",
        "and_chr",
        "samsung",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/caniuse-browser-compatibility-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "features": [
    "css-grid",
    "flexbox",
    "webp",
    "fetch",
    "es6-module"
  ],
  "browsers": [
    "chrome",
    "firefox",
    "safari",
    "edge",
    "opera",
    "ios_saf",
    "and_chr",
    "samsung"
  ]
}' |
apify call automation-lab/caniuse-browser-compatibility-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/caniuse-browser-compatibility-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Caniuse Browser Compatibility Checker",
        "description": "Check browser support for CSS, HTML, and JavaScript features using the caniuse database. Returns a compatibility matrix across Chrome, Firefox, Safari, Edge, mobile browsers, and global coverage stats.",
        "version": "0.1",
        "x-build-id": "5VLWGRlQok6hpQ6Bg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~caniuse-browser-compatibility-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-caniuse-browser-compatibility-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~caniuse-browser-compatibility-checker/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-caniuse-browser-compatibility-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~caniuse-browser-compatibility-checker/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-caniuse-browser-compatibility-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "features": {
                        "title": "🌐 Features to check",
                        "type": "array",
                        "description": "List of caniuse feature slugs to check. Use exact slugs from <a href='https://caniuse.com/' target='_blank'>caniuse.com</a> (e.g. <code>css-grid</code>, <code>flexbox</code>, <code>webp</code>, <code>fetch</code>, <code>es6-module</code>, <code>css-variables</code>). You can also use the <code>searchQuery</code> field to discover feature slugs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "🔍 Search features (discovery mode)",
                        "type": "string",
                        "description": "Optional. Enter a keyword to search for matching feature slugs (e.g. \"grid\", \"animation\", \"worker\"). Returns a list of matching slugs and titles — useful for discovering the right slug before running a full check. When set, this overrides the <code>features</code> list."
                    },
                    "browsers": {
                        "title": "🖥️ Browsers to include",
                        "type": "array",
                        "description": "Which browsers to include in the compatibility matrix. Leave empty to include all major browsers (Chrome, Firefox, Safari, Edge, Opera, iOS Safari, Chrome for Android, Samsung Internet). Available: <code>chrome</code>, <code>firefox</code>, <code>safari</code>, <code>edge</code>, <code>opera</code>, <code>ios_saf</code>, <code>and_chr</code>, <code>samsung</code>, <code>ie</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeLegacyVersions": {
                        "title": "📜 Include version history",
                        "type": "boolean",
                        "description": "Include full version-by-version support history in the output. When false (default), only shows: current support status, the version when support was added, and notes.",
                        "default": false
                    },
                    "includeUsageStats": {
                        "title": "📊 Include global usage stats",
                        "type": "boolean",
                        "description": "Include estimated global user coverage percentage (from caniuse usage data) in the output.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```