Website Response Time Checker

Measure how fast a website responds by testing fetch timing from your browser. This tool shows Time to First Byte (TTFB), total load time, and whether the request succeeded. All measurements are taken from your current network connection.

Enter URL to Test

Figure 1 — Website Response Time Checker

What Is Website Response Time?

Website response time is the total duration from when a user's browser sends a request to when it receives the first byte of data back from the server. This metric, commonly called Time to First Byte (TTFB), is one of the most important indicators of server-side performance and directly impacts user experience and Core Web Vitals scores.

Response time is affected by multiple factors: DNS resolution speed, TCP connection time, TLS handshake duration, server processing time, and network latency. A slow response time can indicate server overload, poor hosting, unoptimized code, or network issues between the user and server.

Understanding Performance Metrics

Website performance involves multiple timing components. Understanding each one helps you pinpoint where bottlenecks occur:

Metric	What It Measures	Good	Needs Work	Poor
DNS Lookup	Time to resolve domain to IP	< 20 ms	20-100 ms	> 100 ms
TCP Connection	Time to establish TCP handshake	< 50 ms	50-200 ms	> 200 ms
TLS Handshake	Time for SSL/TLS negotiation	< 100 ms	100-300 ms	> 300 ms
TTFB	Time to receive first byte	< 200 ms	200-600 ms	> 600 ms
Content Download	Time to transfer full response	< 500 ms	500-2000 ms	> 2000 ms
Total Load Time	Full page render complete	< 2.5s	2.5-4s	> 4s

Pro Tip: TTFB under 200ms is the target for a good user experience. If your TTFB is consistently above 600ms, the issue is almost certainly server-side — either slow database queries, insufficient server resources, or the server is too far from the user. Use a CDN to serve content from edge locations closer to your visitors, and verify your DNS configuration is optimized with low TTL records.

Factors Affecting Response Time

Multiple factors contribute to how quickly a website responds to requests:

Factor	Impact	How to Optimize
Server location	Physical distance adds latency	Use CDN or choose server near users
DNS resolution	Slow DNS adds 50-200ms	Use fast DNS (Cloudflare, Google)
Server resources	CPU/RAM limits slow processing	Scale hosting, optimize code
Database queries	Unoptimized queries block response	Add indexes, cache results
TLS version	Older TLS adds round trips	Use TLS 1.3 with 0-RTT
Network congestion	Shared bandwidth slows delivery	Upgrade connection, use CDN
Keep-alive connections	New connections add overhead	Enable HTTP keep-alive

How to Measure Response Time

There are several ways to measure website response time beyond this tool:

Browser DevTools

// Open DevTools (F12) → Network tab → click any request
// Look for "Waiting (TTFB)" in the Timing section

Command Line (cURL)

curl -o /dev/null -s -w "DNS: %{time_namelookup}s\nConnect: %{time_connect}s\nTTFB: %{time_starttransfer}s\nTotal: %{time_total}s\n" https://example.com

JavaScript (Navigation Timing API)

var timing = performance.getEntriesByType('navigation')[0];
console.log('DNS:', timing.domainLookupEnd - timing.domainLookupStart, 'ms');
console.log('TCP:', timing.connectEnd - timing.connectStart, 'ms');
console.log('TTFB:', timing.responseStart - timing.requestStart, 'ms');

For measuring your overall connection speed, try our Speed Test or Ping Test. To check if specific ports are accessible, use the Port Checker.

Note: This tool measures response time from your browser, which means results reflect your current network conditions, location, and ISP performance. Different users in different locations will see different results for the same URL. For a more comprehensive analysis, test from multiple locations and times of day. CORS restrictions may limit the detail available for cross-origin requests. Check your current IP to understand where the test is being run from.

Improving Website Response Time

If your response time is slow, here are the most effective optimizations ordered by impact:

Use a CDN — Content Delivery Networks cache your content on edge servers worldwide, dramatically reducing latency for distant users.
Enable caching — Browser caching (Cache-Control headers) and server-side caching (Redis, Memcached) reduce repeated work.
Optimize DNS — Switch to a fast DNS provider and minimize CNAME chains. Verify with our DNS Lookup.
Upgrade hosting — Move from shared hosting to VPS or dedicated servers if CPU/RAM is the bottleneck.
Compress responses — Enable gzip or Brotli compression to reduce transfer size.
Optimize databases — Add indexes, use connection pooling, and cache frequent queries.
Use HTTP/2 or HTTP/3 — Modern protocols multiplex requests and reduce overhead.
Enable TLS 1.3 — Faster handshake reduces initial connection time. Verify with our SSL Certificate Checker.

Response Time Benchmarks by Industry

Industry	Average TTFB	Target TTFB	Impact of 1s Delay
E-commerce	300-800 ms	< 200 ms	7% conversion loss
Media/News	200-500 ms	< 150 ms	11% fewer page views
SaaS/Web Apps	100-400 ms	< 100 ms	Increased churn
Corporate/Branding	300-1000 ms	< 300 ms	Poor brand perception
Government	500-2000 ms	< 500 ms	Accessibility issues

Understanding CORS and Response Testing

When testing third-party websites from your browser, CORS (Cross-Origin Resource Sharing) restrictions may limit the information available. Modern browsers enforce same-origin policy, which means:

Detailed timing information (DNS, TCP, TLS breakdown) may not be available for cross-origin requests.
Response headers and body content cannot be read without the server's CORS permission.
The overall timing (TTFB and total time) can still be measured regardless of CORS.

For testing your own websites, you'll get the most detailed data since CORS isn't a factor. For your home network devices like 192.168.1.1, you can measure response time to verify your router's admin panel is responsive.

Key Takeaways

TTFB (Time to First Byte) under 200ms is the target for good performance.
Response time includes DNS lookup, TCP connection, TLS handshake, and server processing.
Use a CDN to reduce latency for users far from your server.
Server-side caching and database optimization have the biggest impact on TTFB.
Test from multiple locations and times to get an accurate picture of performance.
Check DNS configuration and SSL certificates as part of performance optimization.

Video: Website Performance Optimization

Related Tools and Guides

Frequently Asked Questions

What is a good website response time?

A good Time to First Byte (TTFB) is under 200 milliseconds, and total page load should be under 2.5 seconds. Google considers TTFB under 800ms acceptable for Core Web Vitals, but faster is always better for user experience and SEO rankings.

Why is my website slow?

Common causes include: distant server location (use a CDN), slow DNS resolution (switch to faster DNS), insufficient server resources (upgrade hosting), unoptimized database queries, large uncompressed files, and too many HTTP requests. Start by measuring TTFB to determine if the bottleneck is server-side or network-related.

Does response time affect SEO?

Yes. Google uses page speed as a ranking factor, and TTFB is a component of the Largest Contentful Paint (LCP) Core Web Vital. Slow websites also have higher bounce rates, which indirectly affects SEO. Google recommends a total LCP under 2.5 seconds for a good user experience.

What is TTFB and why does it matter?

TTFB (Time to First Byte) measures how long it takes from sending the request to receiving the first byte of the response. It reflects server processing speed, network latency, and connection overhead. A high TTFB indicates server-side issues, while a low TTFB with slow total load indicates front-end optimization needs.

How can I reduce my website's TTFB?

The most effective methods are: implement server-side caching (Redis, Memcached), optimize database queries and add indexes, use a CDN for static assets, upgrade to faster hosting, enable HTTP/2 multiplexing, and use TLS 1.3 for faster handshakes.

Why do results vary between tests?

Response time varies due to server load, network congestion, DNS caching, geographic routing changes, and your own connection quality. Run multiple tests at different times for a more accurate average. First requests are typically slower due to DNS lookup and cold caches.

About Tommy N.

Tommy is the founder of RouterHax and a network engineer with 10+ years of experience in home and enterprise networking. He specializes in router configuration, WiFi optimization, and network security. When not writing guides, he's testing the latest mesh WiFi systems and helping readers troubleshoot their home networks.