Ultimate Web Server Benchmark: Apache, NGINX, LiteSpeed, OpenLiteSpeed, Caddy & Lighttpd Compared

Choosing the right web server can make or break your website’s performance. With so many options available Apache, NGINX, LiteSpeed, OpenLiteSpeed, Caddy, and Lighttpd how do you know which one is the fastest, most efficient, and best suited for your needs?

To find out, we conducted a comprehensive benchmark, testing these six popular web servers under different conditions, including static file handling, high concurrency, large file downloads, and sustained traffic simulations. Our goal? To identify the best-performing server in terms of speed, resource usage, and reliability.

In this article, we’ll walk you through:

• The benchmarking setup (hardware, configuration, and test methodology).
• Detailed performance comparisons across multiple test scenarios.
• Latency trends under different load conditions.
• Final recommendations on which web server is best for different use cases.

So, which web server came out on top? Let’s dive into the results!

Quick Results Summary

To provide an immediate overview of the benchmark results, the following charts summarize the normalized performance and latency trends for all tested web servers.

Each test measured a different aspect of server performance, including static file handling, large file transfers, high concurrency, and mixed workloads. The best-performing server in each test is set to 100%, with others ranked relative to the best result.

Overall Web Server Performance

The chart above highlights the top-performing web servers across all tests. NGINX and OpenLiteSpeed consistently delivered the best results, followed closely by LiteSpeed, Lighttpd, and Caddy. Apache had the lowest performance, especially in high-concurrency and sustained load tests.

Latency Comparison

While throughput is important, low latency ensures fast response times for users. Lighttpd had the lowest latency, making it the fastest in delivering web content. NGINX and OpenLiteSpeed also performed well, while Apache had the highest latency, reinforcing its struggles with high concurrency.

What’s Next?

Now that we have a high-level overview of the results, let’s dive into each test in detail, analyzing how these web servers performed under specific conditions and workloads.

Benchmarking Environment Setup

To ensure fair and repeatable results, we set up a controlled test environment using Proxmox and a single Debian 12 snapshot as the baseline for all web servers. This method eliminated inconsistencies and ensured each server ran in an identical environment.

Hardware & Virtual Machine Configuration

We deployed all web servers in identical virtual machines with the following specifications:

• Hypervisor: Proxmox
• Operating System: Debian 12
• CPU: 4 sockets, 1 core total
• RAM: 2048MB (Limited due to LiteSpeed free trial restrictions)
• Storage: Standard virtual disk with sufficient space for testing
• Network: Bridged network for direct access to VMs

Each web server was installed fresh from the same Debian 12 snapshot, ensuring a clean and consistent setup for all tests.

Web Server Installation and Testing Methodology

To ensure a fair comparison, each web server was installed separately on its own dedicated virtual machine, cloned from a single Debian 12 snapshot. All servers were configured with their default settings, without any manual optimizations or performance tuning. Identical test pages were served across all installations to maintain consistency. The web servers included in this benchmark were Apache, NGINX, LiteSpeed , OpenLiteSpeed, Caddy, and Lighttpd. All servers except LiteSpeed (commercial free trial version) were installed using a standard Debian repository.

Performance was evaluated using three widely used benchmarking tools: Apache Benchmark (ab) for synthetic load testing, wrk for multi-threaded real-world load simulation, and siege for sustained browsing pattern analysis. Each server was tested under multiple conditions, including static file handling using a simple HTML page, large file transfers with a 10MB test file, high concurrency stress tests simulating 1000 simultaneous users, and sustained traffic simulations lasting five minutes. This standardized testing framework provided a direct and reliable comparison of the performance characteristics of each web server.

Test 1: Static File Handling

Purpose of the Test

Static file handling is a fundamental task for any web server. This test measures how efficiently each server serves a simple HTML page under concurrent requests. A web server optimized for static content should deliver high requests per second (RPS) with minimal latency and resource usage. This test is crucial for scenarios where websites serve mostly cached, pre-generated pages, such as blogs, documentation sites, and content delivery networks (CDNs).

Benchmarking Command & Explanation

The test was conducted using Apache Benchmark (ab) with the following command:

$ ab -n 10000 -c 100 http://server-ip/

• -n 10000 → Total number of requests (10,000)
• -c 100 → Number of concurrent users (100)
• http://server-ip/ → URL of the static test page

This command simulates 100 users making repeated requests to a simple HTML file to evaluate the server’s request-handling speed and efficiency.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of requests per second.

Results Interpretation

Lighttpd achieved the highest request rate at 8645 RPS, making it the fastest server in this static content test. LiteSpeed and OpenLiteSpeed followed closely, showing excellent static file performance, while NGINX and Caddy performed similarly. Apache, while still capable, handled significantly fewer requests per second compared to the top performers.

Best Use Cases & Recommendations

• Lighttpd is ideal for serving static content with minimal resource usage, making it well-suited for embedded systems, lightweight web services, and static-heavy sites.
• LiteSpeed and OpenLiteSpeed offer high-speed static content delivery while maintaining compatibility with dynamic features, making them excellent choices for high-performance websites.
• NGINX remains a strong contender, particularly for setups where static and dynamic content need to be balanced efficiently.
• Apache, while not the fastest, may still be a good option for environments where .htaccess or compatibility with existing configurations is required.

Test 2: Large File Transfers

Purpose of the Test

Serving large files efficiently is critical for websites that deliver downloads, streaming media, or large assets such as high-resolution images or software packages. This test evaluates how well each web server handles the transfer of a 10MB file under concurrent requests. A well-optimized server should maintain high transfer rates while keeping CPU and memory usage minimal.

Benchmarking Command & Explanation

The test was conducted using Apache Benchmark (ab) with the following command:

$ ab -n 500 -c 10 http://server-ip/testfile10M.bin

• -n 500 → Total number of requests (500)
• -c 10 → Number of concurrent users (10)
• http://server-ip/testfile10M.bin → URL of the 10MB test file

This command simulates 10 concurrent users downloading a large file repeatedly, providing insights into the throughput and efficiency of each web server in handling large payloads.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of transfer rate.

Results Interpretation

NGINX demonstrated the highest throughput at 123.26 MB/sec, making it the best choice for serving large files efficiently. OpenLiteSpeed performed nearly as well, with only a slight difference in transfer speed. Lighttpd also showed strong results, indicating its ability to handle large payloads effectively. Apache had the lowest transfer rate, which, combined with its higher latency, suggests that it is not as optimized for serving large files compared to the other servers.

Best Use Cases & Recommendations

• NGINX is the best option for delivering large files, making it ideal for video streaming, file hosting, and software distribution services.
• OpenLiteSpeed and LiteSpeed provide competitive performance with added caching and optimization features, making them strong choices for high-traffic media-rich websites.
• Lighttpd remains a viable alternative for lightweight deployments where efficiency is crucial.
• Caddy offers good performance while simplifying HTTPS setup, which is useful for secure file delivery.
• Apache lags behind in this test, so it may not be the best choice for sites that frequently serve large files unless additional tuning is applied.

Test 3: High Concurrency Performance

Purpose of the Test

Web servers must efficiently handle high traffic volumes, especially during peak loads. This test measures how well each server performs when faced with 1,000 simultaneous users making requests to a simple HTML page. A well-optimized server should maintain a high request rate with minimal latency and avoid excessive CPU and memory consumption. This test is crucial for sites experiencing traffic spikes, such as e-commerce platforms, news websites, and online services.

Benchmarking Command & Explanation

The test was conducted using Apache Benchmark (ab) with the following command:

$ ab -n 20000 -c 1000 http://server-ip/

• -n 20000 → Total number of requests (20,000)
• -c 1000 → Number of concurrent users (1,000)
• http://server-ip/ → URL of the test page

This command simulates a heavy traffic load by sending 1,000 concurrent requests to the test page. The goal is to measure the number of requests the server can handle per second while monitoring latency and potential failures.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of requests per second.

Results Interpretation

Lighttpd handled high concurrency best, achieving 7936 requests per second with the lowest latency. LiteSpeed and OpenLiteSpeed followed closely, demonstrating strong concurrency handling. NGINX and Caddy also performed well but showed slightly higher latency. Apache, once again, trailed behind with the lowest request rate and the highest latency, making it the least efficient option under extreme load.

Best Use Cases & Recommendations

• Lighttpd is the best choice for handling a large number of simultaneous users with minimal resource usage, making it suitable for high-traffic APIs and web applications.
• LiteSpeed and OpenLiteSpeed perform well in high-concurrency scenarios, making them ideal for busy websites, forums, and WooCommerce stores.
• NGINX remains a strong performer, particularly when handling both static and dynamic content under load.
• Caddy offers decent concurrency handling, though it falls slightly behind NGINX and LiteSpeed.
• Apache struggles with high concurrency, making it less ideal for high-traffic environments unless extensively optimized.

Test 4: wrk Benchmark (100 Users)

Purpose of the Test

The wrk benchmarking tool provides a more realistic simulation of user traffic compared to Apache Benchmark. It uses multiple threads and open connections to simulate high-load conditions more effectively. This test evaluates how each web server handles 100 concurrent users sending requests to a simple HTML page for 30 seconds. The goal is to measure request throughput, average latency, and the server’s ability to sustain high traffic loads over time.

Benchmarking Command & Explanation

The test was conducted using wrk with the following command:

$ wrk -t4 -c100 -d30s http://server-ip/

• -t4 → Number of threads (4)
• -c100 → Number of concurrent connections (100)
• -d30s → Duration of the test (30 seconds)
• http://server-ip/ → URL of the test page

This test simulates 100 users making repeated requests for 30 seconds, providing insights into sustained performance and response times under consistent load.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of requests per second.

Results Interpretation

Lighttpd outperformed all other web servers in sustained request handling, processing 28,867 requests per second with the lowest latency. OpenLiteSpeed followed closely, maintaining high performance. LiteSpeed, NGINX, and Caddy were relatively similar, though they performed 10-15% worse than Lighttpd. Apache lagged behind once again, showing lower request throughput and higher latency than its competitors.

Best Use Cases & Recommendations

• Lighttpd is the best choice for sustained high-load scenarios, making it ideal for API servers, static file hosting, and embedded systems.
• OpenLiteSpeed and LiteSpeed perform well in long-duration benchmarks, making them suitable for high-traffic WordPress and WooCommerce sites.
• NGINX remains a strong choice, particularly for mixed workloads that require both static and dynamic content processing.
• Caddy is a solid option but does not offer the same performance benefits as LiteSpeed or NGINX.
• Apache falls behind in sustained load performance, making it less suitable for handling continuous high-traffic environments.

Test 5: wrk Benchmark (500 Users)

Purpose of the Test

This test evaluates how well each web server handles a much higher number of concurrent users over a sustained period. By increasing the concurrency level to 500 users, this benchmark measures the maximum throughput and stability of each server under heavy load. This test is particularly useful for websites and applications that experience high peak traffic, such as e-commerce stores, news sites, and large-scale APIs.

Benchmarking Command & Explanation

The test was conducted using wrk with the following command:

$ wrk -t8 -c500 -d60s http://server-ip/

• -t8 → Number of threads (8)
• -c500 → Number of concurrent connections (500)
• -d60s → Duration of the test (60 seconds)
• http://server-ip/ → URL of the test page

This command simulates 500 users making continuous requests for one minute, providing insights into the long-term stability and throughput of each server under extreme conditions.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of requests per second.

Results Interpretation

Lighttpd once again took the top spot, achieving 28,308 requests per second with the lowest latency, making it the most efficient server under high concurrency. OpenLiteSpeed followed closely, demonstrating strong performance. LiteSpeed and NGINX performed well, but with slightly higher latency. Apache fell far behind, struggling with 30% fewer requests per second compared to the top performer, further confirming its limitations in handling heavy sustained traffic.

Best Use Cases & Recommendations

• Lighttpd is the best choice for handling extremely high concurrency with minimal resource usage, making it ideal for large-scale APIs, high-traffic static sites, and embedded systems.
• OpenLiteSpeed and LiteSpeed perform exceptionally well under heavy load, making them great choices for busy WordPress/WooCommerce sites and high-traffic applications.
• NGINX remains a strong contender, balancing performance and flexibility for general web hosting.
• Caddy is a reasonable choice but does not match the performance of LiteSpeed or NGINX under extreme load.
• Apache continues to struggle in high-concurrency scenarios, making it a suboptimal choice for high-traffic production environments unless heavily optimized.

Test 6: wrk Benchmark (Large File, 50 Users)

Purpose of the Test

Handling large file transfers efficiently is crucial for web servers hosting media files, software downloads, and high-resolution images. This test evaluates how well each server delivers a 10MB file under a moderate concurrent load of 50 users. The goal is to measure sustained throughput and response time, ensuring that servers can handle large file transfers without excessive delays or bottlenecks.

Benchmarking Command & Explanation

The test was conducted using wrk with the following command:

$ wrk -t4 -c50 -d30s --latency http://server-ip/testfile10M.bin

• -t4 → Number of threads (4)
• -c50 → Number of concurrent connections (50)
• -d30s → Duration of the test (30 seconds)
• --latency → Enables detailed latency reporting
• http://server-ip/testfile10M.bin → URL of the 10MB test file

This test simulates 50 concurrent users continuously downloading a 10MB file for 30 seconds. It measures the server’s ability to sustain high transfer speeds while keeping latency minimal.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of transfer rate.

Results Interpretation

Lighttpd delivered the best performance with a 136.01 MB/sec transfer rate, making it the most efficient option for large file downloads. OpenLiteSpeed, LiteSpeed, and NGINX performed similarly well, with only a 3-7% difference. Caddy and Apache lagged behind, with Apache being the slowest server in this test, struggling to maintain a high transfer rate with significantly higher latency.

Best Use Cases & Recommendations

• Lighttpd is the best choice for hosting large downloadable files, video streaming, and high-speed content delivery.
• NGINX and LiteSpeed are excellent alternatives, providing high performance with additional caching and optimization features.
• OpenLiteSpeed offers competitive performance, making it ideal for high-traffic applications serving large media files.
• Caddy is an option for simple deployments but does not match the efficiency of Lighttpd, LiteSpeed, or NGINX.
• Apache falls short for large file transfers, making it a poor choice for high-volume file hosting unless extensive optimizations are applied.

Test 7: Siege Benchmark (50 Users – Burst Traffic)

Purpose of the Test

Web servers must handle sudden spikes in traffic, such as flash sales, breaking news, or social media-driven surges. This test simulates a burst of 50 users making rapid requests over a short period. Unlike wrk and ab, which send requests continuously, siege introduces random delays between requests to better mimic real-world browsing behavior.

Benchmarking Command & Explanation

The test was conducted using siege with the following command:

$ siege -c50 -t2M -d1 http://server-ip/

• -c50 → Simulates 50 concurrent users
• -t2M → Runs the test for 2 minutes
• -d1 → Each user waits randomly up to 1 second between requests
• http://server-ip/ → URL of the static test page

This test evaluates how well each web server performs when handling sporadic high bursts of user traffic, measuring throughput, response times, and failure rates.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of requests per second.

Results Interpretation

NGINX handled burst traffic best, achieving 202.19 RPS with the lowest latency, making it the most efficient at handling sudden spikes in traffic. LiteSpeed, Lighttpd, and Caddy performed nearly as well, with only a 1-2% difference in throughput. Apache followed closely behind, showing improved efficiency compared to previous tests. OpenLiteSpeed had a slight drop in performance but still remained competitive.

Best Use Cases & Recommendations

• NGINX is the best choice for handling sudden traffic surges, making it ideal for high-traffic blogs, news websites, and social media-driven content.
• LiteSpeed and OpenLiteSpeed offer nearly equal performance, with additional built-in caching and optimization features.
• Lighttpd is an efficient alternative, providing strong burst traffic performance with minimal resource consumption.
• Caddy is a viable choice for simple deployments, but its performance is slightly behind the top performers.
• Apache performed surprisingly well in this test, making it a reasonable option for sites experiencing intermittent spikes in traffic.

Test 8: Siege Benchmark (200 Users – Sustained Load)

Purpose of the Test

This test was designed to evaluate how well each web server handles sustained high traffic with 200 concurrent users over a period of 5 minutes. Unlike the previous tests, which focused on short bursts or moderate concurrency, this test simulates extended, high-volume traffic, similar to what an e-commerce site experiences during peak hours or a streaming service during prime time.

Benchmarking Command & Explanation

The test was conducted using siege with the following command:

$ siege -c200 -b -t5M http://server-ip/

• -c200 → Simulates 200 concurrent users
• -b → Runs in benchmark mode, meaning no random delays between requests
• -t5M → Runs for 5 minutes
• http://server-ip/ → URL of the static test page

This test stresses the server by forcing it to handle a continuous high load with no pauses, exposing any weaknesses in request handling, resource allocation, and connection management.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of requests per second.

Results Interpretation

During this test, Apache, LiteSpeed (Commercial), Caddy, and Lighttpd all failed to complete the benchmark, as the tests either hung indefinitely or became unresponsive. This suggests that these servers, in their default configurations, struggled to handle sustained high concurrency over an extended period. Rather than investigating and tuning each server individually, we chose to focus only on the default configurations, as modifying settings to troubleshoot failures would dilute the results and introduce inconsistencies across the comparisons.

Among the servers that completed the test, NGINX performed best, successfully handling 100 requests per second with the lowest latency. OpenLiteSpeed also completed the test, with a slightly lower throughput of 98.4 RPS and a higher latency.

Best Use Cases & Recommendations

• NGINX is the best choice for handling long-duration high concurrency traffic, making it ideal for large-scale websites, APIs, and streaming services.
• OpenLiteSpeed is a viable alternative, providing good sustained performance with slightly higher latency than NGINX.
• Apache, LiteSpeed, Caddy, and Lighttpd struggled under sustained load, and would likely require tuning to avoid failures in high-concurrency scenarios.

Test 9: Siege Benchmark (100 Users – Mixed Pages)

Purpose of the Test

Web servers must efficiently serve a mix of static pages, large files, and dynamic requests in real-world applications. This test simulates 100 concurrent users requesting different types of content to assess how each server manages diverse workloads. This is particularly useful for websites that serve HTML pages, images, and large files simultaneously.

Benchmarking Command & Explanation

The test was conducted using siege with the following command:

$ siege -c100 -t3M -f urls.txt

• -c100 → Simulates 100 concurrent users
• -t3M → Runs for 3 minutes
• -f urls.txt → Uses a file containing multiple URLs for testing

The urls.txt file contained a mix of different content types:

http://server-ip/
http://server-ip/contact.html
http://server-ip/testfile10M.bin

This ensured that the benchmark tested how each web server handled small static pages, standard HTML files, and large file downloads at the same time.

Results Table

Note: The last column normalizes the results, with 100% representing the best-performing server in terms of requests per second.

Results Interpretation

OpenLiteSpeed performed the best in this test, achieving 181.05 requests per second, closely followed by NGINX and LiteSpeed, both of which performed within a 2% margin of OpenLiteSpeed. Caddy and Lighttpd also handled mixed workloads well, while Apache had the lowest performance, processing about 9% fewer requests than the top performer. This suggests that OpenLiteSpeed and NGINX are better suited for handling mixed workloads effectively.

Best Use Cases & Recommendations

• OpenLiteSpeed is the best choice for websites with varied content, such as WordPress, WooCommerce, and dynamic applications.
• NGINX is a strong alternative, offering excellent performance for mixed workloads, making it ideal for general-purpose hosting.
• LiteSpeed and Caddy perform well, with LiteSpeed benefiting from built-in caching and Caddy excelling in automatic HTTPS handling.
• Lighttpd is still a solid option, though slightly behind the top contenders in mixed-content handling.
• Apache, while functional, underperforms when handling diverse workloads compared to the other servers.

Global Comparisons & Performance Analysis

After conducting extensive benchmarks on six different web servers, we can now compare their overall performance across multiple test scenarios. This section will analyze their strengths and weaknesses in handling static files, large file transfers, high concurrency, and mixed workloads.

Overall Performance Rankings

The table below ranks the web servers based on their average performance across all tests, considering request throughput, latency, and reliability

Key Observations:

• NGINX emerged as the most well-rounded server, delivering strong performance in every test, especially in handling large file transfers and high concurrency.
• OpenLiteSpeed was nearly identical to NGINX, excelling in mixed-content handling and static file performance.
• LiteSpeed (commercial version) was optimized for high performance, particularly in caching-heavy workloads like WordPress/WooCommerce sites.
• Lighttpd consumed the least resources while performing well, making it ideal for lightweight, embedded, or resource-constrained systems.
• Caddy had respectable performance, but its real strength lies in ease of use and automatic HTTPS configuration rather than raw speed.
• Apache struggled the most, particularly in high concurrency and large file tests, making it a suboptimal choice unless manual tuning is applied.

Resource Usage: CPU & RAM Efficiency

Key Takeaways:

• Lighttpd was the most efficient, consuming least CPU and RAM, making it ideal for low-power environments or embedded systems.
• NGINX and OpenLiteSpeed were nearly identical, striking a good balance between performance and resource efficiency.
• Apache had the highest CPU and RAM usage, further explaining its lower performance under high concurrency.

Latency & Response Time Trends

Key Takeaways:

• Lighttpd had the lowest latency in all scenarios, making it the fastest in response time.
• NGINX and OpenLiteSpeed performed consistently well, with response times slightly higher than Lighttpd.
• Apache had the highest latency, confirming its struggles in handling large traffic loads efficiently.

Final Recommendations: Which Web Server Should You Choose?

Key Takeaways:

• If you need a well-rounded, high-performance web server, NGINX or OpenLiteSpeed are the best choices.
• For low-resource environments, Lighttpd is the most efficient while still delivering strong performance.
• If you run WordPress/WooCommerce, LiteSpeed (Commercial) is the best optimized option.
• If you want automatic HTTPS with a simple setup, Caddy is a great choice.
• Apache is not recommended for high-performance use cases unless fine-tuned extensively.

Final Conclusion and Summary

Choosing the right web server is critical for optimizing performance, resource efficiency, and scalability. After conducting extensive benchmarks across Apache, NGINX, LiteSpeed (Commercial), OpenLiteSpeed, Caddy, and Lighttpd, we have identified clear winners for different use cases.

Key Findings

1. NGINX and OpenLiteSpeed delivered the best overall performance, excelling in high concurrency, large file handling, and mixed workloads.
2. Lighttpd proved to be the most resource-efficient, making it an excellent choice for low-power or embedded environments while maintaining strong performance.
3. LiteSpeed (Commercial) was optimized for WordPress/WooCommerce, offering excellent speed and built-in caching.
4. Caddy provided a simple and secure web server setup, but it did not match the raw performance of the top contenders.
5. Apache struggled in high-concurrency scenarios, using more CPU and RAM than other servers, making it a less ideal choice without extensive optimization.

Which Web Server Should You Choose?

Final Thoughts

• If you need the best balance of performance, scalability, and efficiency, NGINX or OpenLiteSpeed are the top choices.
• If you run a WooCommerce or WordPress site, LiteSpeed (Commercial) provides superior optimization and caching.
• If you require a lightweight, efficient web server, Lighttpd is the most resource-friendly option.
• If ease of use and automatic HTTPS are your priority, Caddy is a great alternative.
• Apache, while widely used, is not the best performer in modern workloads unless carefully optimized.

By sticking to default configurations, these benchmarks highlight out-of-the-box performance for each server. However, real-world performance can be improved by applying custom tuning and optimization based on specific needs.