Core Web Vitals: a beginner's guide
CrUX metrics with server-side performance analysis
Core Web Vitals: Google's three-number page experience score
Core Web Vitals are three specific metrics, defined by Google, that together measure how a real user experiences a web page. Google announced them in 2020, baked them into search rankings in June 2021, and has been tightening the thresholds ever since. They are the closest thing the SEO world has to a universal grading system for "is this page fast enough?" — and unlike most SEO metrics, they are officially part of how Google ranks search results.
You should care because Core Web Vitals are a confirmed Google ranking signal and because they correlate strongly with the metrics that actually matter to your business: bounce rate, session length, conversion rate. A page that fails Core Web Vitals is a page that real visitors are quietly bouncing from before they ever read the content. Improving them is one of the few SEO investments where the technical work and the user-experience work are exactly the same work.
The three Core Web Vitals, in plain English:
Largest Contentful Paint (LCP) — measures loading speed. Specifically, the time from when a visitor clicks the link until the largest visible element (usually a hero image or a big headline) actually appears on screen. Good: under 2.5 seconds. Poor: over 4 seconds.
Interaction to Next Paint (INP) — measures responsiveness. How long the page takes to visually respond after a user interacts with it (taps, clicks, types). INP replaced an older metric called First Input Delay (FID) in March 2024 because INP captures the full lifetime of interactions, not just the first one. Good: under 200 milliseconds. Poor: over 500 milliseconds.
Cumulative Layout Shift (CLS) — measures visual stability. How much the page jumps around as it loads. The classic example: you go to tap a button and an ad banner pops in, pushing the button down, and you tap the wrong thing. That is a layout shift, and CLS measures how often it happens. Good: under 0.1. Poor: over 0.25.
Google's official rule is that for a website to count as "passing" Core Web Vitals, at least 75% of page views must hit the "good" threshold for all three metrics, measured on real users in the field. The data Google uses for ranking comes from the Chrome User Experience Report, which collects anonymized performance data from real Chrome users worldwide.
Three questions a Core Web Vitals check answers:
Is my page passing the official Google ranking thresholds, or am I quietly failing one of them?
Which of the three metrics is my weakest link, so I know where to focus engineering effort?
Am I losing search visibility specifically because of page experience signals, as opposed to content or backlinks?
The cost of failing Core Web Vitals is rarely a single dramatic ranking drop; it is a slow drift downward over months as Google quietly favors faster competitors. Fixing them is a one-time investment that pays compounding dividends in both rankings and conversion rates. The first step is measuring what you actually have, in the field, the way Google does — which is exactly what a Core Web Vitals check gives you.
The Core Web Vitals endpoint, in plain language
In one sentence: CrUX metrics with server-side performance analysis
Combines real-world Chrome UX Report (CrUX) field data with server-side performance analysis. Returns LCP, INP, CLS, TTFB, and FCP metrics with p75 values and histogram distributions, plus server-measured TTFB, render-blocking resource detection, CLS risk factors, INP risk factors, a composite score with grade, and actionable recommendations.
Don't worry if some of the words above are still unfamiliar — there's a plain-language glossary at the bottom of this page, and most of the terms link to their own beginner guides if you want to learn more.
What is actually happening when you call it
Here's what's actually happening behind the scenes when you call this endpoint:
Queries the CrUX API (Application Programming Interface) for real-world performance data (p75 values for LCP, INP, CLS, TTFB, FCP with histogram distributions) and simultaneously performs server-side analysis: measures TTFB directly, scans HTML (HyperText Markup Language) for render-blocking resources, images without dimensions (CLS risk), missing preload/preconnect hints (LCP risk), synchronous scripts and third-party script domains (INP risk), and resource hint usage. Produces a composite score (0-100) combining field data (60%) and server-side analysis (40%), with a letter grade and prioritized recommendations. Even when CrUX data is unavailable (smaller sites), the server-side analysis still provides actionable diagnostics.
If you're using an AI assistant through MCP, you don't need to understand any of the technical details — the assistant calls the tool and translates the result for you.
Why this specific tool matters
Let's skip the marketing fluff and answer the only question that actually matters: why should you, a real human with a real to-do list, care about the Core Web Vitals tool? Here's the plain-English version, written the way you'd hear it from a friend who happens to do this for a living.
Core Web Vitals (Google Core Web Vitals) are a confirmed Google ranking factor. This endpoint goes beyond raw CrUX data by identifying specific optimization opportunities in your HTML (HyperText Markup Language) — render-blocking resources slowing LCP, missing image dimensions causing CLS, and excessive third-party scripts affecting INP. Provides value even for sites without CrUX data by analyzing server response time and HTML structure.
Picture this in real life. Imagine an SEO manager. Here's the situation they're walking into: Monitor real-world Core Web Vitals (Google Core Web Vitals) and get specific recommendations to maintain Google ranking thresholds. Without the right tool, that person would be stuck copy-pasting between five browser tabs, reading documentation written for engineers, and crossing their fingers that the answer they cobble together is correct. With the Core Web Vitals tool, the same person gets a clear answer in seconds — no spreadsheets, no guessing, no waiting for someone on the infrastructure team to free up.
Three questions this tool answers in plain English. If any of these have ever crossed your mind, the Core Web Vitals tool is built for you:
Are search engines actually able to crawl, understand, and recommend my pages?
What is the single biggest fix I could make today to climb in Google?
How does my site compare against the technical SEO checklist that the top results all pass?
You can either click the tool and get the answer yourself, or ask your AI assistant — connected through MCP (Model Context Protocol) — to ask the question for you and translate the answer into something you can paste into Slack.
Who gets the most out of this. Marketers, content writers, freelancers running client sites, founders trying to grow without paying for ads, and SEO specialists running monthly health checks. If you see yourself in that list, this is one of the EdgeDNS tools you should bookmark today.
What happens if you skip this entirely. Skip it and search engines quietly stop sending you traffic and you don't find out until the next quarterly review. That's why running this check — even once a month — is one of the cheapest forms of insurance you can give your domain.
Available on the developer plan. The technical details: `GET /v1/domain/web-vitals`.
When would I actually use this?
If you're still on the fence about whether the Core Web Vitals tool belongs in your toolbox, this section is for you. Below you'll meet three real people — an SEO manager, a performance engineer, a product manager, and a developer — facing three real situations where this tool turns a stressful afternoon into a five-minute task. Read whichever story sounds closest to your week.
Story 1: Ranking Factor Monitoring
Imagine you're an SEO manager. Monitor real-world Core Web Vitals (Google Core Web Vitals) and get specific recommendations to maintain Google ranking thresholds.
Why it matters: Actionable insights tied directly to ranking signals.
Story 2: Performance Optimization
Imagine you're a performance engineer. Identify render-blocking resources, missing preload hints, and CLS risk factors alongside real-user metrics.
Why it matters: Pinpoint exact optimization targets instead of guessing.
Story 3: Competitive CWV Comparison
Imagine you're a product manager. Compare Core Web Vitals (Google Core Web Vitals) scores and server-side diagnostics against competitors.
Why it matters: Quantify UX advantages and identify specific areas where competitors excel.
Story 4: Small Site Diagnostics
Imagine you're a developer. Analyze CWV risk factors for sites without enough traffic for CrUX data.
Why it matters: Get performance diagnostics even without real-user measurement data.
Common situations across teams. Beyond the three stories above, here are the everyday workplace moments when people across the company reach for the Core Web Vitals tool — or one of the tools right next to it in this category. If any of these are on your calendar this month, that's your sign:
Before launching a new page, site, or campaign — to catch the dumb mistakes.
During a quarterly SEO health check.
When organic traffic suddenly drops and you need to find out why.
When pitching a new client and you need an audit deck in under an hour.
If you can see yourself in even one of those bullets, the Core Web Vitals tool will pay for itself the first time you use it.
Still not sure? Here's the easiest test in the world. Open Claude, ChatGPT, Gemini, or any other AI assistant connected to the EdgeDNS MCP server and ask, in your own words: "Is the Core Web Vitals tool useful for my job?" The assistant will look at the tool, ask you a couple of follow-up questions about what you're trying to accomplish, and give you a straight answer in plain English. No commitment, no signup forms, no jargon.
The easiest way: just ask your AI assistant
If you've connected the EdgeDNS MCP server to Claude, ChatGPT, Gemini, Cursor, or any other AI assistant, you don't need to write any code. Just ask in plain English:
"Use the Core Web Vitals tool to check example.com and explain anything that looks wrong in plain language."
The AI will figure out which tool to call, fill in the right parameters, run it, and then explain the result back to you. No copy-pasting between tabs. No reading raw JSON. No memorizing endpoint names.
MCP (Model Context Protocol) access is free on every plan, including the free tier. One API key works for both REST and AI — you do not have to choose.
The technical way: call it from code
If you're a developer and want to call the endpoint from a script or your own application, here's the simplest possible example. Replace the placeholder API key with the real one from your dashboard.
# Replace edns_live_YOUR_KEY with your real API key from the dashboard
curl -H "Authorization: Bearer edns_live_YOUR_KEY" \
"https://api.edgedns.dev/v1/domain/web-vitals?domain=example.com"What you need to provide
You need to provide 2 pieces of information when you call this tool. The table below lays them out side by side, with a real example for each one so you can see exactly what to send.
| Field | Type | Required? | What it means | Example |
|---|---|---|---|---|
domain | string | Yes | The domain to get Core Web Vitals (Google Core Web Vitals) for | example.com |
formFactor | string | Optional | Device type: PHONE, DESKTOP, TABLET, or ALL_FORM_FACTORS (default) Allowed values: PHONE, DESKTOP, TABLET, ALL_FORM_FACTORS | ALL_FORM_FACTORS |
What you get back
When you call this tool, you'll get back a JSON object with the fields below. If you're talking to it through an AI assistant, the assistant reads these for you and explains them in plain language — you don't need to memorize them.
| Field | Type | What you'll see in it |
|---|---|---|
domain | string | The queried domain |
formFactor | string | The form factor queried |
dataAvailable | boolean | Whether CrUX field data is available for this domain |
metrics | object | CrUX metrics (lcp, inp, cls, ttfb, fcp) each with p75, histogram percentages, rating, and thresholds |
collectionPeriod | object | CrUX data collection period (firstDate, lastDate) |
lcpSubParts | object | LCP timing breakdown (when available): imageTimeToFirstByte, imageResourceLoadDelay, imageResourceLoadDuration, imageElementRenderDelay (p75 ms) |
overallAssessment | string | Overall CrUX assessment: good, needs-improvement, or poor |
passesAllThresholds | boolean | Whether all Core Web Vitals (Google Core Web Vitals) pass Google thresholds |
serverAnalysis | object | Server-side analysis: measured TTFB, LCP optimization factors, CLS risk factors, INP risk factors, and resource hints |
serverAnalysis.ttfb | object | Directly measured Time to First Byte with value (ms) and rating |
serverAnalysis.lcpAnalysis | object | LCP risk factors: render-blocking stylesheets/scripts, preconnect/preload/fetchpriority usage |
serverAnalysis.clsAnalysis | object | CLS risk factors: images without dimensions, font-display strategy, viewport meta |
serverAnalysis.inpAnalysis | object | INP risk factors: third-party script domains, synchronous scripts in head, total script count |
serverAnalysis.resourceHints | object | Resource hints found: preconnect, preload, DNS-prefetch, prefetch origins |
score | number | Composite score (0-100) combining CrUX field data and server-side analysis |
grade | string | Letter grade: A+, A, B, C, D, or F |
issues | array | Detected performance issues from server-side analysis |
recommendations | array | Prioritized recommendations combining CrUX insights and server-side findings |
Words you might be wondering about
If any words on this page felt like jargon, here's a plain-language version. Click any linked term to read a full beginner-friendly guide.
API (Application Programming Interface) — A way for one program to ask another program for something — like a waiter taking your order to the kitchen.
HTML (HyperText Markup Language) — The basic language web pages are written in. The tags you see in the source code (<h1>, <p>, <a>) are HTML.
Core Web Vitals (Google Core Web Vitals) — Google's official measurements of how fast and smooth your web pages feel — how quickly content appears, how long the page takes to become interactive, and how stable the layout is. Used as a search ranking signal.
Need Programmatic Access?
Automate domain intelligence with 100+ API endpoints and a free MCP server for AI integration.