# hey — HTTP Load Generator for Benchmarking Web Servers

> Lightweight HTTP load generator written in Go, designed as a modern replacement for ApacheBench with better concurrency handling.

## Install

Save as a script file and run:

# hey — HTTP Load Generator for Benchmarking Web Servers

## Quick Use
```bash
# Install via Go
go install github.com/rakyll/hey@latest

# Send 1000 requests with 50 concurrent workers
hey -n 1000 -c 50 http://localhost:8080/

# POST with custom headers and body
hey -m POST -H "Content-Type: application/json" -d '{"key":"value"}' -n 500 http://api.example.com/data
```

## Introduction
hey is a tiny HTTP load generator written in Go that sends a configurable number of requests to a target URL and reports latency histograms, status code distribution, and throughput. It was created as a modern, cross-platform replacement for ApacheBench (ab) that handles HTTP/1.1 keep-alive, concurrent workers, and custom payloads. A single binary with zero dependencies makes it easy to drop into any CI pipeline or developer workstation.

## What hey Does
- Sends a fixed number of HTTP requests with configurable concurrency
- Reports detailed latency percentiles (p10 through p99) and averages
- Supports custom HTTP methods, headers, request bodies, and basic auth
- Distributes requests across a pool of concurrent Go goroutines
- Outputs results as a latency histogram, status code summary, and throughput number

## Architecture Overview
hey uses Go's goroutine-based concurrency to maintain a pool of workers that share a channel of work items. Each worker opens a persistent HTTP connection and fires requests sequentially, while the coordinator counts completions and collects timing data. After all requests finish, hey aggregates latency samples into percentile buckets and prints a summary. The entire tool compiles to a single static binary with no runtime dependencies.

## Self-Hosting & Configuration
- Install with `go install github.com/rakyll/hey@latest` or download a prebuilt binary from GitHub Releases
- On macOS also available via `brew install hey`
- Use `-n` for total requests and `-c` for concurrency level
- Set `-q` to cap requests per second (rate limiting)
- Pipe output to a file or parse the text summary in CI scripts

## Key Features
- Single static binary — no runtime, no config files, no dependencies
- Accurate latency histograms with ten percentile buckets
- HTTP/1.1 keep-alive and connection reuse by default
- Rate limiting via `-q` to simulate steady-state traffic patterns
- Cross-platform: runs on Linux, macOS, and Windows without changes

## Comparison with Similar Tools
- **wrk** — higher raw throughput via C and epoll, but requires Unix and Lua for customization
- **ApacheBench (ab)** — classic but single-threaded, no keep-alive by default, limited output
- **oha** — Rust-based with a real-time TUI dashboard; hey is simpler and text-only
- **bombardier** — similar Go tool with a progress bar; hey predates it and has wider adoption
- **Vegeta** — constant-rate attack model with reporting; hey uses a fixed-request-count model

## FAQ
**Q: How do I limit the request rate with hey?**
A: Use `-q 100` to cap throughput at 100 requests per second per worker. Total rate equals `-q` multiplied by `-c`.

**Q: Does hey support HTTP/2?**
A: Yes. Pass `-h2` to enable HTTP/2 connections to servers that support it.

**Q: Can I use hey in a CI pipeline?**
A: Yes. Run hey with fixed `-n` and `-c` values and check the exit code or parse stdout for pass/fail thresholds.

**Q: What is the difference between hey and ab?**
A: hey supports keep-alive by default, handles concurrent connections via goroutines, and provides richer latency percentile output than ab.

## Sources
- https://github.com/rakyll/hey
- https://github.com/rakyll/hey/blob/master/README.md

---
Source: https://tokrepo.com/en/workflows/0f9ec1d9-41af-11f1-9bc6-00163e2b0d79
Author: Script Depot