Goku

Goku is a high-performance, scalable HTTP load-testing tool designed for benchmarking and performance analysis of web services. Inspired by tools like Drill and Vegeta, Goku offers modern features and simplicity for engineers to simulate and analyze traffic efficiently.

Features

• Fast and scalable HTTP load testing
• Real-time live stats during long tests
• Rate limiting (--rps) for constant-rate load profiles
• Multi-step sequential scenarios (multiple endpoints per test)
• Variable templating in URLs and bodies ({{uuid}}, {{seq}}, {{random_int}}, …)
• Built-in authentication (Bearer token, Basic auth)
• ASCII latency histogram in text output
• compare subcommand to diff two benchmark runs
• Output to file (--output-file) and per-request log (--results-log)
• HTTP/1.1, HTTP/2 support
• Multiple output formats: text, json, csv
• MCP (Model Context Protocol) server for LLM/agent integration
• Send results to Observability Insight to keep a history of runs and compare them

Install CLI

Automatic download (Linux, OSX, WSL)

curl -sSL https://raw.githubusercontent.com/jcaromiq/goku/v3.0.0/scripts/install.sh | sh

Using Cargo

cargo install goku-bench
goku --version

Manual download

Go to the Goku's GitHub Releases page and download the latest .tar.gz for your system:

• Linux (x86_64, arm64)
• macOS (x86_64)
• Windows (x86_64)

From source

cargo build --release

Observability Insight integration

Goku can send the final results of every run to a project in Observability Insight, where you get the history of your performance tests and can compare runs to spot regressions. Enable the Goku connector in your project first.

Log in (local machine)

goku login

Goku opens the browser, you log in and choose the project, and a token for that project's Goku connector is stored in ~/.config/goku/credentials.json (permissions 0600; on macOS/Windows the OS config directory is used). Use --no-browser to only print the URL, and --portal-url to point to another portal.

Send results

goku -c 50 -d 30 --target https://api.example.com/users --report --report-name "users list" --report-tag nightly

Only the final summary (throughput, latency percentiles, status codes and the test configuration) is sent. Query strings and credentials in target URLs are stripped before sending. If the report cannot be sent, Goku exits with a non-zero status.

CI

Browsers are not available in CI: create a token in the project's Goku connector settings and expose it as GOKU_OI_TOKEN (optionally GOKU_OI_URL for another portal). Environment variables take precedence over the credentials file. Commit and branch are detected on GitHub Actions and GitLab CI.

- run: goku -c 20 -d 60 --target https://staging.example.com --report --report-name "staging smoke"
  env:
    GOKU_OI_TOKEN: ${{ secrets.GOKU_OI_TOKEN }}

Status and logout

goku status   # project, connector and token in use
goku logout   # removes the local credentials file

goku logout only deletes the local file: revoke the token from the Goku connector settings in the portal to invalidate it.

MCP (Model Context Protocol) Support

Goku integrates with the Model Context Protocol (MCP) — use Goku programmatically from any LLM agent or MCP-aware client.

What this enables

• Use Goku from an LLM or AI agent — no manual CLI usage required.
• Combine load testing with automated workflows: trigger a test, gather metrics, and analyze results from within an agent or script.
• Seamless integration into broader toolchains and agentic pipelines.

Example usage with an LLM

Once Goku is registered as an MCP tool, you can ask your LLM:

"Run a load test on https://api.example.com/users with 50 concurrent clients for 30 seconds using HTTP/2, and give me the p95 and p99 latency."

The LLM will call the run_benchmark MCP tool and return the full structured report.

Install MCP server

# Automatic download
curl -sSL https://raw.githubusercontent.com/jcaromiq/goku/v3.0.0/scripts/install_mcp.sh | sh

# Or via Cargo
cargo install goku-mcp

MCP tool: run_benchmark

The MCP server exposes a single unified tool with the following parameters:

Returns a full JSON report with all latency percentiles, throughput, and status code breakdown.

Versioning

CLI is versioned with SemVer v2.0.0.

Contributing

See CONTRIBUTING.md.

Usage manual

Usage: goku [OPTIONS] --target <TARGET>
       goku compare <BASELINE> <CANDIDATE>
       goku login | logout | status

Options:
  -v, --verbose                        Runs in verbose mode
  -t, --target <TARGET>                URL to request. Format: [METHOD] <url>  [default: GET]
                                       Example: "POST http://localhost:3000/api"
  -r, --request-body <REQUEST_BODY>    Path to file to use as request body
  -c, --clients <CLIENTS>              Number of concurrent workers [default: 1]
  -i, --iterations <ITERATIONS>        Total number of requests [default: 1]
  -d, --duration <DURATION>            Duration of the test in seconds (alternative to --iterations)
      --headers <HEADERS>              Headers in "Name:Value" format (repeatable)
      --scenario <SCENARIO>            Path to a YAML scenario file
      --timeout <timeout_ms>           Request timeout in ms [default: 30000]
      --http2                          Enable HTTP/2 prior knowledge
      --ramp-up <seconds>              Seconds to spread the start of workers
      --rps <RPS>                      Max requests per second across all clients
      --output <text|json|csv>         Output format [default: text]
      --output-file <PATH>             Write results to file instead of stdout
      --results-log <PATH>             Write per-request CSV log (timestamp, status, latency)
      --live-stats <seconds>           Print live stats every N seconds during the test
      --insecure                       Accept invalid/self-signed TLS certificates
      --auth-bearer <TOKEN>            Set Authorization: Bearer <TOKEN> header
      --auth-basic <USER:PASS>         Set Authorization: Basic <base64> header
      --pool-idle-timeout <seconds>    Connection pool idle timeout [default: 90]
      --disable-keepalive              Disable HTTP keep-alive / connection reuse
      --report                         Send the final results to Observability Insight
      --report-name <NAME>             Name of the run in Observability Insight (requires --report)
      --report-tag <TAG>               Tag for the run in Observability Insight (repeatable, requires --report)
  -h, --help                           Print help
  -V, --version                        Print version

Subcommands:
  compare <BASELINE> <CANDIDATE>       Compare two JSON result files and show a diff table
  login [--portal-url URL] [--no-browser]  Link this machine to an Observability Insight project
  logout                               Remove the stored Observability Insight credentials
  status                               Show the project this machine reports to

Flag reference

--target -t

Specifies the HTTP method and URL. Defaults to GET if no method is provided.

goku --target "GET http://localhost:3000/"
goku --target "POST http://localhost:3000/api"
goku --target http://localhost:3000          # implicit GET

--request-body -r Optional

Path to a file whose contents will be sent as the request body.

--clients -c

Number of concurrent workers. Defaults to 1.

--iterations -i

Total number of requests to perform across all workers. Defaults to 1. Cannot be used together with --duration.

--duration -d

Run the test for a fixed number of seconds instead of a fixed request count.

--headers Optional

Add one or more request headers. Repeatable. Format: Name:Value.

goku --headers Content-Type:application/json --headers X-Api-Key:secret ...

--http2 Optional

Force HTTP/2 prior knowledge (skips HTTP/1.1 upgrade negotiation).

--ramp-up Optional

Spread the start of workers over N seconds to simulate a gradual traffic spike.

--rps Optional

Limit the total requests per second across all clients. Useful for constant-rate load profiles (similar to Vegeta).

goku -c 10 -i 10000 --rps 200 --target http://localhost:3000

--output Optional

Output format. Val