Meet parallelHTTP — A Simple Tool to Stress-Test Your APIs

Source: Dev.to

What is ParallelHTTP

ParallelHTTP is a minimalistic but functional tool that lets you:

• Send multiple HTTP requests in parallel.
• Configure method (GET, POST, etc.), endpoint URL, request body, and timeouts.
• Track response times and status codes.
• Get an aggregated summary: success/error counts, average latency, latency percentiles.
• Export responses to CSV for later inspection.

It ships with multiple interfaces, depending on how you want to use it:

• Web UI – interactive testing via browser.
• CLI mode – quick testing from terminal, ideal for automation, scripts, or CI.
• Docker image – containerized usage, easier integration with other tooling.
• REST API endpoint – programmatically trigger loads or integrate with other systems.

Why Parallel HTTP Requests — And How parallelHTTP Fits In

Making many HTTP requests in parallel is a common approach when you want to stress test, benchmark, or load‑test APIs or web services. Parallel requests simulate concurrent clients, which is often closer to real‑world usage, especially under load.

There are many ways to implement parallelism (threading, asynchronous programming, language‑specific libraries). For example, in Python you might use threads or async libraries to parallelize HTTP calls.

parallelHTTP bundles everything together – UI, CLI, REST API – so you don’t need to write custom scripts or glue code. For developers or QA engineers who just want to spin up a quick load test, it provides an “out‑of‑the‑box” solution.

How to Install parallelHTTP

You can use ParallelHTTP via binary, Docker, Web UI, or CLI.

1. Install Using Binaries (CLI mode)

Run:

./parallelhttp --help

Available flags:

-duration duration
      Max duration for all calls. Example: 0->no limit, 1ms, 1s, 10m
-endpoint string
      Request endpoint to be called.
-format string
      Response format. One of: text, yaml, json. Default json. (default "json")
-method string
      Request Method. Default GET. (default "GET")
-parallel int
      Number of parallel calls. Default 1. (default 1)
-timeout duration
      Request timeout. Default 10s

Usage example

./parallelhttp \
  --endpoint=http://localhost:8080/test \
  --parallel=5 \
  --method=GET \
  --timeout=2s \
  --duration=10s \
  --format=json

Sample output (JSON):

{
  "requests": [
    {
      "response": {
        "status_code": 200,
        "time": "2025-12-02T04:39:26.450811405+01:00",
        "duration": 176680135,
        "duration_h": "176.680135ms"
      },
      "error": null,
      "error_message": null
    },
    {
      "response": {
        "status_code": 200,
        "time": "2025-12-02T04:39:26.450838753+01:00",
        "duration": 177105875,
        "duration_h": "177.105875ms"
      },
      "error": null,
      "error_message": null
    },
    {
      "response": {
        "status_code": 200,
        "time": "2025-12-02T04:39:26.450989804+01:00",
        "duration": 176999320,
        "duration_h": "176.99932ms"
      },
      "error": null,
      "error_message": null
    },
    {
      "response": {
        "status_code": 200,
        "time": "2025-12-02T04:39:26.450761076+01:00",
        "duration": 177158817,
        "duration_h": "177.158817ms"
      },
      "error": null,
      "error_message": null
    },
    {
      "response": {
        "status_code": 200,
        "time": "2025-12-02T04:39:26.450879196+01:00",
        "duration": 179940733,
        "duration_h": "179.940733ms"
      },
      "error": null,
      "error_message": null
    }
  ],
  "stats": {
    "start_time": "2025-12-02T04:39:26.450727731+01:00",
    "end_time": "2025-12-02T04:39:26.630824982+01:00",
    "duration": "180.097251ms",
    "latency": {
      "p50": "177.105875ms",
      "p90": "179.940733ms",
      "p99": "179.940733ms"
    }
  }
}

2. Web UI (Docker)

docker run --rm -p 8080:8080 -it nicumicle/parallelhttp

Open http://localhost:8080 in a browser. You will see a UI where you can select an endpoint, configure parameters, and run the test. Results are displayed directly in the browser.

Use Cases — When parallelHTTP Shines

• API performance testing – simulate 100, 1 000, or 10 000 concurrent requests and observe latency, errors, and timeouts.
• Benchmarking new server versions – compare latency or error rates between releases.
• Stress/load testing before production – validate stability before a feature launch or traffic spike.
• Regression testing under load – integrate into CI/CD pipelines to automatically run load tests after changes.
• Exporting detailed metrics – CSV export lets you feed results into spreadsheets or visualization tools for deeper analysis.

Final Thoughts

parallelHTTP provides a straightforward way to send parallel HTTP requests, measure latency and status codes, and export results. It’s a handy addition to the toolbox for developers, QA engineers, or anyone needing quick API stress‑tests.

Explore the repository and give it a try with your own APIs.