# Evaluat

> Evaluat is a real-browser performance testing platform that runs each virtual user in an isolated browser instance, capturing Core Web Vitals and Navigation Timing metrics under load — with full session video, network logs, and console logs for every user.

## AI and agent resources

Evaluat is agent-ready: AI agents can run a real-browser website speed test over the Model Context Protocol and read the results back as structured data.

- [MCP endpoint](https://www.evaluat.com/api/mcp): Model Context Protocol server (Streamable HTTP, JSON-RPC 2.0, no API key, rate limited). The tool run_website_speed_test loads a public URL in a real Chrome browser and returns Core Web Vitals (LCP, FCP, CLS, TTFB), an A to F grade, and a shareable video report.
- [MCP server card](https://www.evaluat.com/.well-known/mcp.json): Machine-readable description of the MCP server and its tool.
- [OpenAPI 3.1 specification](https://www.evaluat.com/openapi.json): The public Website Speed Test API.
- [API catalog](https://www.evaluat.com/.well-known/api-catalog): RFC 9727 service catalog.
- [AI plugin manifest](https://www.evaluat.com/.well-known/ai-plugin.json): Plugin manifest pointing at the OpenAPI spec.
- [Developer and agent reference](https://www.evaluat.com/developers): How to connect an AI agent and call the speed test.
- [Extended index](https://www.evaluat.com/llms-full.txt): The full machine-readable index.

## Product

- [Performance Testing](https://www.evaluat.com/product/performance-testing): Real-browser performance testing with Core Web Vitals capture per virtual user.
- [Testing Suite](https://www.evaluat.com/product/testing-suite): Smoke testing with the same real-browser scenarios (coming soon).
- [Monitoring](https://www.evaluat.com/product/monitoring): Continuous real-browser performance monitoring (coming soon).
- [How It Works](https://www.evaluat.com/how-it-works): Architecture, methodology, and what each test produces.
- [Changelog](https://www.evaluat.com/changelog): Dated product, tooling, and platform updates, newest first.

## Free tools

- [Website Speed Test (Evaluat Pulse)](https://www.evaluat.com/tools/website-speed-test): Free website speed test that loads a page once in a real Chrome browser and returns Core Web Vitals (LCP, FCP, CLS, TTFB), an A to F performance grade, and a video replay of the load on a shareable report link. No signup; runs from London or Frankfurt; reports are kept for 30 days.

## Comparisons

- [Evaluat vs k6](https://www.evaluat.com/vs/k6): Real-browser testing for every user vs k6's scriptable protocol load and its resource-heavy browser module.
- [Evaluat vs AppLoader](https://www.evaluat.com/vs/apploader): Real-browser Core Web Vitals vs AppLoader's GUI and protocol load testing.
- [Evaluat vs Cavisson NetStorm](https://www.evaluat.com/vs/cavisson): Real-browser performance testing vs Cavisson NetStorm's enterprise multi-protocol load.
- [Evaluat vs JMeter](https://www.evaluat.com/vs/jmeter): Real-browser testing for every user vs JMeter's protocol load and small-scale WebDriver Sampler.
- [Evaluat vs Loadero](https://www.evaluat.com/vs/loadero): Real-browser Core Web Vitals and an Executive Summary vs Loadero's real-browser WebRTC and load testing.
- [Evaluat vs LoadForge](https://www.evaluat.com/vs/loadforge): Real-browser Core Web Vitals vs LoadForge's Locust-based cloud load testing.
- [Evaluat vs Loadium](https://www.evaluat.com/vs/loadium): Real-browser performance testing vs Loadium's cloud runner for JMeter, Gatling, and Selenium.
- [Evaluat vs LoadView](https://www.evaluat.com/vs/loadview): Real-browser Core Web Vitals per user vs LoadView's real-browser load from Dotcom-Monitor.
- [Evaluat vs Locust](https://www.evaluat.com/vs/locust): Real-browser testing with no code vs Locust's open-source Python protocol load.
- [Evaluat vs OctoPerf](https://www.evaluat.com/vs/octoperf): Real-browser Core Web Vitals vs OctoPerf's JMeter-based protocol load at scale.
- [Evaluat vs Web Performance Load Tester](https://www.evaluat.com/vs/web-performance): Real-browser testing for every user vs Web Performance's self-hosted load tool.

## Blog

- [Performance testing: the complete guide](https://www.evaluat.com/blog/performance-testing-guide): The whole discipline in one place: what it is, the types, the metrics (server-side and Core Web Vitals), the process, and how to choose between protocol-level and real-browser tools.
- [What is performance testing?](https://www.evaluat.com/blog/what-is-performance-testing): A beginner's guide for QA engineers to performance testing under real traffic: what it is, its types, the metrics that matter, and why server response time is not the same as user experience.
- [Load vs stress vs performance testing](https://www.evaluat.com/blog/load-vs-stress-vs-performance-testing): How the three actually differ, when to run each, and which one your team needs first, with the real-browser and Core Web Vitals angle most comparisons miss.
- [Smoke testing vs performance testing](https://www.evaluat.com/blog/smoke-testing-vs-performance-testing): Why a quick smoke test that checks a build is not broken is not a performance test, the two meanings of the term, and when a quick pre-release check is enough.
- [Functional testing vs performance testing](https://www.evaluat.com/blog/functional-testing-vs-performance-testing): The two questions every release must answer, does it do the right thing and does it hold up under load, how the disciplines differ, when each runs, and the real-browser gap neither catches alone.
- [Stress testing a website](https://www.evaluat.com/blog/stress-testing-a-website): A step-by-step guide to finding the breaking point: set a baseline, ramp past peak, read the failure signals, measure recovery, and fix the bottleneck.
- [What is spike testing?](https://www.evaluat.com/blog/what-is-spike-testing): What a sudden traffic surge does that a gradual ramp does not, how spike testing differs from load and stress testing, why reactive autoscaling lags a flash-sale spike, and how to measure survival and recovery in real browsers.
- [What is soak testing?](https://www.evaluat.com/blog/soak-testing): How a soak (endurance) test holds a steady, realistic load for hours or days to expose memory leaks, resource exhaustion, and slow degradation that short tests miss, how long to run one, and the front-end half a protocol test never sees.
- [Real-browser load testing](https://www.evaluat.com/blog/real-browser-load-testing): How real-browser load testing differs from HTTP-script and shared-browser models, and when each is the right call.
- [Playwright for performance testing](https://www.evaluat.com/blog/playwright-performance-testing): Whether a browser automation tool can drive virtual users, why a real browser costs far more than a protocol virtual user, and the hybrid that pairs Playwright with a load tool.
- [API vs browser performance testing](https://www.evaluat.com/blog/api-vs-browser-performance-testing): What API performance testing and browser performance testing each measure, what each misses, and why a fast backend is not a fast page, with a strategy that sequences both.
- [8 metrics every performance test report should include](https://www.evaluat.com/blog/performance-test-report-metrics): The eight metrics a complete report needs, read in three passes (did it keep up, how slow was it really, what did users feel) plus a per-URL breakdown for where it broke, each with the benchmark that signals it is healthy.
- [Why average response time misleads you: reading p95 and p99](https://www.evaluat.com/blog/p95-p99-response-time): Why the average buries your slowest requests, how to read p95 and p99, why tail latency compounds when one page fans out to many backends, which percentile to target, and the coordinated-omission trap that makes a load test understate the very tail it was run to find.
- [What is an Apdex score?](https://www.evaluat.com/blog/what-is-an-apdex-score): How Apdex turns response times into one user-satisfaction score from 0 to 1: the formula, the satisfied/tolerating/frustrated buckets, how to set the target T, what counts as a good score, and what a single number hides.
- [Core Web Vitals at load](https://www.evaluat.com/blog/core-web-vitals-load-testing): Why Core Web Vitals shift under load (LCP rises as the server slows, INP degrades at peak, CLS least) and how to measure them at concurrency in real browsers.
- [Core Web Vitals: lab vs field data](https://www.evaluat.com/blog/core-web-vitals-lab-vs-field): Why a lab score (Lighthouse, one synthetic run) differs from real-user field data (CrUX): single sample vs distribution, a fixed device and network, no interactions, and the traffic load a lab never simulates.
- [Performance regression testing in CI/CD](https://www.evaluat.com/blog/performance-regression-testing): How to gate releases on Core Web Vitals: baseline your main branch, set budgets, fail the build when a change regresses, and catch the slowdowns that only appear under load.
- [Where does performance testing fit in an agile release cycle?](https://www.evaluat.com/blog/performance-testing-agile-release-cycle): A stage-by-stage map of which performance test runs where in an agile cycle, at what cadence, owned by whom, and how to put it in the Definition of Done.
- [Largest Contentful Paint (LCP) explained](https://www.evaluat.com/blog/largest-contentful-paint): What counts as the LCP element, the four phases LCP breaks into (and why load delay is usually the bloat), lab vs field, and how to measure LCP under load.
- [Interaction to Next Paint (INP) explained](https://www.evaluat.com/blog/interaction-to-next-paint): What INP measures, why it replaced First Input Delay, and how to test it under load.
- [Why Magento checkout dies first under load](https://www.evaluat.com/blog/magento-checkout-slow-under-load): Why full page cache cannot protect cart and checkout, how a sale multiplies origin load faster than traffic grows, the four bottlenecks inside checkout, and how to load test the journey that takes the money.
- [Why your Shopify store slows down under load](https://www.evaluat.com/blog/shopify-store-slow-under-load): Why Shopify's cached storefront scales but the theme, app, and third-party JavaScript a merchant adds run in each shopper's browser, why that only shows under load, and why an HTTP load test never sees it.
- [WooCommerce performance testing guide](https://www.evaluat.com/blog/woocommerce-performance-testing): Why WooCommerce's cached catalog scales but the uncacheable cart, checkout, and admin-ajax calls run PHP and MySQL on every request, why a small PHP worker pool sets the ceiling under load, and how to load test a staging copy safely, since it is self-hosted and you own the whole stack.

## Reference

- [Pricing](https://www.evaluat.com/pricing)
- [FAQ](https://www.evaluat.com/faq)
- [About](https://www.evaluat.com/about)
- [Ahmad Farzan, founder and author](https://www.evaluat.com/authors/ahmad-farzan): Founder of Evaluat and author of the blog, with a background building and load-testing Adobe Commerce and Magento storefronts.
- [Agency Partner Program](https://www.evaluat.com/partners)
- [Book a Demo](https://www.evaluat.com/demo)
- [Contact](https://www.evaluat.com/contact)

## Legal

- [Privacy](https://www.evaluat.com/privacy)
- [Terms](https://www.evaluat.com/terms)
- [Data Processing Agreement](https://www.evaluat.com/dpa)
- [Sub-processors](https://www.evaluat.com/sub-processors)