Browser Feature Detector
Inspect, test, and audit supported HTML5 specifications, CSS media parameters, and modern Web APIs locally inside your current environment.
Feature presence is audited programmatically in real time via standard client global scope interfaces.
Unknown Browser
OS: Unknown OS • Language: en-US • Connection: Online
Capability Audit Matrix
Explore browser-supported interfaces categorized by functional capabilities.
Storage & Databases
Cookie Support
Enables websites to store key-value data directly inside HTTP session-scoped or persistent cookies.
Essential for standard server authentication and session persistence.
Local Storage
Allows synchronous client-side data persistence across browser tabs with no expiration date.
Capacities generally capped at 5MB per origin.
Session Storage
Maintains temporary, tab-scoped data storage that clears automatically when the browser tab closes.
Data is isolated to the specific open browser tab.
IndexedDB database
A robust transactional NoSQL database capable of persisting massive volumes of structured binary blobs.
Recommended for sophisticated offline applications.
Workers & Core APIs
WebAssembly (Wasm)
Executes compiled, high-performance binary code natively inside browser sandboxes alongside JavaScript.
Excellent for fast media manipulation and canvas engines.
Web Workers
Enables background thread execution, shifting intensive computational logic away from the primary UI thread.
Workers cannot access the global DOM tree directly.
Service Workers
Powers offline-first Progressive Web Apps (PWAs) by running background tasks and proxying asset fetch requests.
Requires a secure origin (HTTPS/Localhost).
WebRTC Communication
Enables peer-to-peer real-time audio, video, and data streaming links without middleman routing.
Crucial for web-based calling and chat systems.
Geolocation API
Retrieves GPS coordinate precision or IP-based approximation of the user's geographical region.
Explicitly requests permission before releasing coordinates.
Notifications API
Sends persistent system or mobile-level banners to the user outside of the active tab view.
Fails silently if the tab does not have active consent.
Clipboard API
Provides programmatic read-write access to the system clipboard for robust copy-paste operations.
Writing to clipboard is permitted; reading requires explicit permission.
Web Share API
Fires the device's native sharing sheet to transfer URLs, texts, or files directly into messaging applications.
Principally supported on mobile operating systems.
Graphics & Media
HTML5 Canvas (2D)
Renders rapid, dynamically-generated vector and raster graphics using standard coordinate grids.
Used extensively for local image cropping and filtering.
WebGL Graphics (3D)
Enables high-performance hardware-accelerated 3D and 2D canvas graphics via GPU pipelines.
Relies on device-specific hardware drivers.
WebGL 2.0 Graphics
Features newer GLSL shaders and expanded API compatibility matching modern OpenGL ES parameters.
Supported by most modern desktop and mobile browsers.
HTML5 File APIs
Loads and reads local binary and text files directly inside browser processes using standard blob interfaces.
Essential for bulk client-side file conversions and analysis.
Interactions & Media Queries
Drag and Drop API
Allows the browser to intercept system drag events to import files or move elements.
Simplifies bulk file uploads.
Touch Interactions
Identifies whether the host display handles multi-point physical gestures or stylus triggers.
Changes tap sizes and hover interactions.
Dark Mode Preference
Detects if the user has requested dark interfaces within their parent OS configuration.
Mapped automatically using the prefers-color-scheme query.
Reduced Motion Preference
Advises applications to disable non-essential slide or scale animations to protect accessibility.
Mapped via prefers-reduced-motion queries.
In-Browser Capability Inspection & Compatibility Auditing
The Browser Feature Detector is a zero-telemetry capability inspector designed to audit active web browser environments. By checking for the presence of modern HTML5 interfaces, WebAssembly runtime modules, hardware-accelerated canvas pipelines, and CSS media queries directly, this utility provides engineers and developers with instant confirmation of which features are ready to use.
Every check executes strictly client-side inside local browser memory. Programmatic detection utilizes progressive disclosure logic to confirm whether advanced Web APIs (such as Geolocation, Service Workers, IndexedDB, or WebRTC) are exposed in the current execution scope. This allows you to plan robust fallback architectures before shipping advanced capabilities to production users.
The workspace features visual capability summary tags, searchable API indices, and categorized result grids. It allows teams to evaluate storage capacities, graphic contexts (WebGL and WebGL2), and interaction paradigms (touch displays or prefers-reduced-motion queries) under secure origin boundaries with zero telemetry.
Core Tool Capabilities
- HTML5 Storage Analysis: Inspects availability and access boundaries for HTTP Cookies, Local Storage, Session Storage, and transactional IndexedDB schemas.
- Modern Web API Scopes: Verifies execution runtimes for WebAssembly (Wasm), background Web Workers, Service Workers, WebRTC, and the Clipboard API.
- Graphics & Rendering Engines: Detects hardware-accelerated WebGL 1.0/2.0 graphic contexts, HTML5 2D Canvas capabilities, and File system blob interfaces.
- Interaction & Accessibility: Tests active display touch gesture support, OS dark theme preferences, and prefers-reduced-motion accessibility configurations.
- Device Environment Metrics: Monitors live client connection changes, device pixel ratios, languages, and viewport pixel dimensions.
- Searchable API Indexing: Filter and isolate specific audited APIs and specifications instantly with reactive search queries.
Local Browser Privacy
Your files are processed locally on your device. Files are not uploaded, transmitted, or stored on remote servers.
Once the page has loaded, you can disconnect your network connection and continue using this tool offline.
Target Use Cases
- • Progressive Web App Debugging
- • Canvas & WebGL Verification
- • Responsive Layout Diagnostics
- • Corporate Compliance Checks
Technical Specifications & Platform Limits
Client-side structured and unstructured state systems.
Hardware and software graphic rendering engines.
High-performance processing outside the UI thread.
User input paradigms and file transfer handlers.
OS-level design and accessibility preference detection.
Responsive layout and screen coordinate matrices.
Runs without contacting external databases or metrics tools.
Step-by-Step Workflow
Load the Interactive Detector
Open the tool page in your target browser and device to trigger automated local audits instantly on load.
Review Environment Summary
Inspect the primary header card to view browser identifiers, online connections, and active viewport coordinate boxes.
Filter and Search APIs
Use the capability query bar to isolate specific features (e.g. 'wasm' or 'webgl') across categories.
Verify Fallback Specifications
Identify disabled, unsupported, or permission-gated APIs to implement fallback strategies.
Practical Real-World Use Cases
Progressive Web App Debugging
Confirm that service workers, file APIs, and offline storages are fully accessible in target mobile wrapper environments.
Canvas & WebGL Verification
Verify that graphics contexts and WebAssembly runtimes are exposed on user displays before initializing large graphics apps.
Responsive Layout Diagnostics
Diagnose media query breakpoints, high-DPI scaling, and viewport rendering coordinates across test mobile handsets.
Corporate Compliance Checks
Audit secure origins and storage constraints on client devices to make sure apps conform to data compliance standards.
Frequently Asked Questions
- Does this detector send any browser data to external servers?
- No. The Browser Feature Detector is entirely client-side. The evaluation of user-agent, viewport pixels, local storage write capabilities, and GL rendering contexts occurs solely within your local session with no network telemetry.
- Does a green checkmark guarantee that Geolocation or Notifications are active?
- No. The checkmark confirms that the browser supports and exposes the programmatic API. Real-world capability triggers may still depend on secure origins (HTTPS) or require the user to explicitly grant system permissions.
- What is WebAssembly and is it widely supported?
- WebAssembly (Wasm) is a binary instruction format for a stack-based virtual machine, enabling compiled C++/Rust/Go code to run at near-native speeds on the web. It is supported by all major desktop and mobile browsers.
- Why is WebGL support listed as supported but fails inside some iframes?
- Some embedded sandboxes or iframe security layers block hardware-accelerated canvas contexts. If WebGL is listed as unsupported despite running on a modern GPU, try opening the application directly in a new tab.
- How does the tool detect Touch Support?
- The tool tests the presence of standard ontouchstart event listeners on the window prototype object, combined with navigator.maxTouchPoints checks to accurately identify responsive hybrid touch screens.
Share this tool
Help others discover this utility. No login or registration required.
Master this tool with Guides & Articles
Learn the workflows, common mistakes, and advanced techniques behind Browser Feature Detector - Check API Support Quickly with our deep-dive educational content.
Building a Custom Developer Toolbox with Browser Utilities
A practical guide to assembling browser-native developer workflows for formatting, validation, URL checks, payload preparation, security review, and deployment preflight.
Identifying CSS Bloat in Modern UI Components
A frontend workflow guide to finding CSS bloat, reducing unused styles, controlling Tailwind utility growth, and keeping component systems maintainable.
Cleaning Messy JSON for API Performance and Reliability
A developer workflow guide to JSON cleanup, validation, schema alignment, payload size, and debugging API data before production handoff.