HTTP(S) benchmark tools, testing/debugging, & restAPI (RESTful)

Located in alphabetical order (not prefer)

HTTP(S) Benchmark Tools

• ab – slow in single-threaded can be made more efficient by taskset, written in C
• ali – Generate HTTP load and plot the results in real-time, written in Go (golang)
• apib – most of the features of ApacheBench (ab), also designed as a more modern replacement, written in C
• autocannon – fast HTTP/1.1 benchmarking tool written in Node.js
• baloo – Expressive end-to-end HTTP API testing made easy, written in Go (golang)
• baton – HTTP load testing, written in Go (golang)
• Bencher - A suite of continuous benchmarking tools designed to catch performance regressions in CI
• bombardier – Fast crossplatform HTTP benchmarking tool, written in Go (golang)
• cassowary – is a modern HTTP(S), intuitive & cross-platform load testing tool, written in Go (golang)
• cryload – Cross-platform HTTP load testing CLI, ab/wrk alternative with JSON/CSV output for CI/CD, written in Crystal
• curl-loader – performance loading of various application services and traffic generation, written in C
• ddosify – High-performance load testing tool, written in Go (golang)
• drill – Drill is a HTTP load testing application inspired by Ansible syntax, written in Rust
• fasthttploader – benchmark (kinda ab) with autoadjustment and charts based on fasthttp library, written in Go (golang)
• fbender – A load-testing command line tool for generic network protocols (HTTP, DNS, DHCP, …), written in Go (golang)
• fortio – load testing library and command line tool and web UI. Allows to specify a set query-per-second load and record latency histograms and other useful stats, written in Go (golang)
• gatling – High performance load testing framework based on Scala, Akka and Netty, written in Scala
• go-wrk – a HTTP benchmarking tool based in spirit on the excellent wrk tool (wg/wrk), written in Go (golang)
• goad – Goad is an AWS Lambda powered, highly distributed, load testing tool, written in Go (golang)
• gobench – HTTP/HTTPS load testing and benchmarking tool, written in Go (golang)
• gohttpbench – ab-like benchmark tool run on multi-core cpu, written in Go (golang)
• goloris – Slowloris for NGINX DoS attack, written in Go (golang)
• goose - A modern, high-performance and flexible distributed HTTP(S) load testing tool, written in Rust
• h2load - benchmarking tool for HTTP/2 and HTTP/1.1. It supports SSL/TLS and clear text for all supported protocols, written in C/C++
• hey – HTTP(S) load generator, ApacheBench (ab) replacement, formerly known as rakyll/boom, written in Go (golang)
• htstress – multithreading high-load bechmarking services (>5K rps), written in C/Linux
• httperf – difficult configuration, slow and single threaded, written in C
• httping - Ping with HTTP requests, see http://www.vanheusden.com/httping/, written in C
• httpit - A rapid http(s) benchmark tool, written in golang
• inundator – A simple and high-throughput HTTP flood program, written in C/Linux
• jmeter – Apache JMeter™, pure application designed to load test performance both on static and dynamic resources, written in Java
• k6 - A modern load testing tool scriptable in ES6 JS with support for HTTP/1.1, HTTP/2.0 and WebSocket, written in Go (golang)
• locust – easy-to-use, distributed load testing tool with real-time web UI. Simulates a swarm of concurrent users, the behavior of each of them is defined by your python code. Written in Python
• lor-axe – A multi-threaded, low-bandwidth HTTP Slowloris DoS tool that handles connections and sockets in parallel, written in Rust
• mgun – A modern tool for load testing HTTP servers, written in Go (golang)
• molotov - A simple Python 3.7+ tool to write load tests
• NBomber – Modern and flexible load testing framework for Pull and Push scenarios, designed to test any system regardless a protocol (HTTP/WebSockets/AMQP etc) or a semantic model (Pull/Push), written in F# (F Sharp)
• Netling – Netling is a load tester client for easy web testing., written in C# (C Sharp)
• oha – HTTP load generator, inspired by rakyll/hey with tui animation, written in Rust
• pewpew - Flexible HTTP command line stress testing tool for websites and web services, written in Go (golang)
• plow – A high-performance HTTP benchmarking tool with real-time web UI and terminal displaying, written in Go (golang)
• pounce – event-driven with a similar interface as wrk but with the ambition to potentially achieve lower latency and higher throughout, written in C
• pywrkr – ab/wrk-inspired benchmarking CLI with latency percentiles, virtual-user simulation, rate limiting, traffic profiles, HAR import, and SLO/threshold checks for CI, written in Python
• RapidAPI (Paw) - for Mac is a full-featured HTTP client that lets you test and describe the APIs you build or consume.
• rewrk – A more modern http framework benchmarker supporting HTTP/1 and HTTP/2 benchmarks, written in Rust.
• reqstress – a benchmarking&stressing tool that can send raw HTTP requests, written in Go (golang).
• salvo - A simple HTTP(S) load testing tool like boom, but based on molotov. Python
• siege – multithreaded concurrent connections and slow single-user, written in C
• slapper – Simple load testing tool with real-time updated histogram of request timings, written in Go (golang)
• slow_cooker – A load tester focused on lifecycle issues and long-running tests, service with a predictable load and concurrency level for a long period of time, written in Go (golang)
• slowhttptest – Application Layer DoS attack simulator, written in C++
• sniper – powerful & high-performance http load tester, written in Go (golang)
• thrash – HTTP Micro Benchmarker, written in Go (golang)
• tquic_client – A high-performance HTTP/3 benchmarking tool, written in Rust
• tsung – Simulate stress users in order to test the scalability and performance of IP based client/server applications HTTP, WebDAV, SOAP, PostgreSQL, MySQL, LDAP and Jabber/XMPP servers, written in Erlang
• vegeta – HTTP load testing tool and library, written in Go (golang)
• weighttp – multithreaded, but slower than htstress without keepalive, written in C
• welle – ab (Apache Benchmark) like tool, written in Rust
• wrk – multithreaded, but doesn't offer concurrent connections and a keepalive switch, written in C/Lua
• wrk2 – constant throughput, correct latency recording variant of wrk, written in C/Lua Concurrent connections are enabled with: -c, --connections Connections to keep open And keepalive (which is default) can be disabled using: -H "Connection: close"
• yandex-tank – Load and performance benchmark tool, written in Python/C|C++|Asm (phantom)
• zrk - A constant-throughput load generator in Zig ⚡
• seq 0 10000 | xargs -P 100 -I {} curl http://localhost:8080/ - Benchmarking in restricted environments, using GNU toolchain

Toolkit for testing/debugging HTTP(S) and restAPI (RESTful)

• agent-qa – Self-improving QA agent for natural-language web and mobile regression tests, written in TypeScript
• bat – Go implement CLI, cURL-like tool for humans, written in Go (golang)
• Bruno – is a Fast and Git-Friendly Opensource API client
• curl – Powerful features command-line tool for transferring data specified with URL syntax, written in C
  • Online curl command line builde
• curlconverter – convert curl commands to python, javascript, php
• hoppscotch - API request builder
• DeepfakeHTTP – is a web server that uses HTTP dumps as a source for responses, written in Java
• httpie – client, user-friendly curl replacement with intuitive UI, JSON support, syntax highlighting, wget-like downloads, extensions, written in Python
• HTTPie Desktop – HTTPie Desktop is a cross-platform API testing client for humans. Use it to test REST, GraphQL, and HTTP APIs painlessly.
• HttpMaster - Professional desktop tool for HTTP testing and debugging.
• curlie – If you like the interface of HTTPie but miss the features of curl, curlie is what you are searching for. Curlie is a drop-in replacement for httpie that use curl to perform operations, written in Go (golang)
• xh – Yet another HTTPie clone, written in Rust
• httpstat - It's like curl -v, with colours
• hurl - Hurl is a command line tool that runs HTTP requests defined in a simple plain text format
• insomnia - simple, beautiful, and free Desktop REST API client (Mac, Windows, and Linux)
• jaggr – JSON Aggregation CLI, Jaggr can be used to integrate vegeta with jplot, written in Go (golang)
• jq – is a lightweight and flexible command-line JSON processor, written in C
• Keploy - Open source ai testing platform that records user traffic as test cases and mocks (infrastructure virtualisation along withDBs) and uses AI to expand the API, schema and code coverage of the backend regression test suite. It also auto-generates tests with assertions and is used for contract testing, functional and performance testing using AI.
• Proxyman - Capture HTTP(s) in a few clicks. Best-in-class native macOS app to capture, decrypt, and mock your HTTP(s) requests/ responses with powerful debugging tools.
• Webhook Debugger, Logger & API Mocking Suite – Enterprise-grade tool for testing, debugging, and logging incoming webhooks in real-time, written in Node.js.
• Yaak – API client for modern developers, Call REST, GraphQL, SSE, and gRPC APIs from a simple and intuitive app.
• https://github.com/marmelab/awesome-rest
• https://github.com/stepci/awesome-api-clients
• https://github.com/mrmykey/awesome-http-clients

SaaS/PaaS

• BlazeMeter – offers a cross-enterprise test automation framework for the entire technical team (developers, devops, ops and QA) throughout the product development lifecycle. Run continuous or 'on demand' testing for APIs, mobile apps and websites. Run from the cloud, on-premise or as a hybrid solution. Use with JMeter & Selenium WebDriver & integrate with your existing CI, CD & APM tools.
• NewRelic – software analytics tool suite used by developers, ops, and software companies to understand how your applications are performing in development and production
• GetPageSpeed Amplify – Visually identify performance bottlenecks, overloaded servers, or potential DDoS attacks. Improve and optimize NGINX performance with intelligent advice and recommendations. Get alerts when something is wrong with the delivery of your application. Plan capacity and performance for web applications. Keep track of systems running NGINX. (NGINX Amplify was retired on January 31, 2026. GetPageSpeed Amplify is a compatible replacement.)
• k6.io - Open source load testing tool and SaaS for engineering teams. Powerful scripting and lots of CI/CD integration.
• RedLine13 - Cloud Based Load Testing to run JMeter, Gatling, or custom code load test plans at scale using low cost instance pricing.
• tracetest – Use OpenTelemetry for testing and synthetic monitoring. Write your tests using YAML

Additional tools and inspiration collection

• https://github.com/aliesbelik/load-testing-toolkit