How to use oha: run HTTP load tests from your terminal

Install oha on your system

The simplest route depends on your operating system. The README lists package-manager installs for Arch Linux, macOS with Homebrew and Windows with winget, and a Cargo install that works on any platform with Rust.

• Arch Linux: pacman -S oha
• macOS (Homebrew): brew install oha
• Windows (winget): winget install hatoo.oha
• Any platform with Rust: cargo install oha

Build from source with Cargo

To install via Cargo, the README says you need stable Rust, plus make and cmake. The project also documents optional build features: native-tls instead of the default rustls, VSOCK support, and experimental HTTP/3 support through the vsock and http3 features.

If you want the Docker route, the README shows a local build with docker build and a run command that uses --network=host.

Run your first load test

The basic form is oha followed by the target URL. Without other options, oha sends 200 requests using 50 concurrent connections, since those are the documented defaults. The live display updates while the test runs.

To control the size of the test, use -n for the number of requests and -c for concurrent connections. The -n option accepts suffixes, so 10k means 10,000 and 1m means 1,000,000. The README notes that you may need to raise your open-file limit for larger -c values.

• -n sets the number of requests (default 200)
• -c sets concurrent connections (default 50)
• Use --no-tui if you prefer plain output

Test for a fixed duration or a set rate

Use -z to run for a time window, such as 10s or 3m. On HTTP/1, requests still in progress when the deadline hits are aborted and counted as aborted due to deadline, unless you add -w to wait for them. On HTTP/2, ongoing requests are waited for and -w is ignored.

To cap the load, use -q for a rate limit in queries per second. The README points out that -q is an overall rate across all workers, unlike hey, where it applies per worker. Add --latency-correction when you use -q or --burst-delay to correct for coordinated omission.

• -z 30s runs for 30 seconds
• -q 200 limits the total to 200 queries per second
• --latency-correction is ignored unless -q or --burst-delay is set

Send POST requests, headers and HTTP/2 traffic

oha can set the HTTP method, add custom headers, send a request body, and choose the HTTP version. The README lists -m for the method, -H for headers, -d for an inline body, -D for a body read from a file, and --http2 as shorthand for HTTP/2.

For HTTP/2, -p sets parallel requests per connection. The README says oha runs c * p concurrent workers in total.

• -m POST sets the method
• -H "name: value" adds a header
• -d or -D sets the body; -D reads it from a file
• --http2 selects HTTP/2; -p sets parallel requests on HTTP/2

Read the results and avoid common mistakes

oha is meant for load you have permission to generate. The README's own options include a request timeout (-t), a connect timeout that defaults to 5s, and a redirect limit (-r) that defaults to 0, so redirects are not followed unless you raise it.

Heavy load can cause outages, so run tests against staging or systems you own, and start with small numbers before scaling up.

• Use -t to set a per-request timeout; the default is infinite
• Use --no-color if your terminal output is hard to read or you pipe output
• Use --disable-keepalive to stop reusing TCP connections (not supported on HTTP/2)