Product

A load testing tool for full software workflows.

LoadStrike helps teams run load, performance, and stress tests across APIs, queues, services, and browser steps.

Trace-To-Test Autopilot creates a safe starter scenario from captured behavior, then LoadStrike reports the full transaction.

Trace-To-Test Autopilot Transaction-aware scenarios Self-hosted runtime Cross-system visibility Multi-language SDKs

See Trace-To-Test Run Quick Start

Read Report Overview Browse Use Cases Security and Data Handling

Direct answer

What makes LoadStrike different?

LoadStrike is a self-hosted load testing tool that treats APIs, browser journeys, queues, streams, and services as one workflow.

Scenario design, runtime controls, reports, and supported clusters stay aligned across SDKs, so teams can keep one testing model while using the language they already know.

Why teams choose it

Why teams use LoadStrike.

Best when a performance question spans more than one system.

Trace-To-Test Autopilot

Create a safe starter scenario from HARs, traces, recordings, or message pairs.

Cross-system correlation

Track the source action and the downstream result with one shared transaction model.

Self-hosted execution

Run LoadStrike on your own infrastructure in local, CI, or clustered setups.

Protocol coverage

Use one runtime for APIs, Kafka, streams, browser flows, and reports.

Product proof

See the result before you go deeper.

Start with the report, then map it back to the runtime choices.

Trace-first path

Use Autopilot when you have workflow evidence and need a quick first draft.

Implementation path

Use the docs hub for language samples, transport setup, and cluster guidance.

Buying path

Pricing keeps the self-hosted plan model simple and predictable.

Diagram showing summary, scenario tabs, failed rows, thresholds, and grouped correlation in a LoadStrike report. — Reports stay tied to the full transaction, not only the first request timing.

Trace-To-Test Autopilot

A faster path from traffic to a first test.

Autopilot reads workflow evidence, hides secrets, checks replay safety, and returns a starter plan.

Accepts HARs, OpenTelemetry traces, browser recordings, and message pairs.
Requires review before a runnable scenario is built.
Creates a small scenario teams can tune and scale.

Read Autopilot Docs Open Docs Hub

Generate from a captured trace

using LoadStrike;

var result = LoadStrikeAutopilot.Generate(new LoadStrikeAutopilotRequest
{
    Kind = "Har",
    Content = File.ReadAllText("orders.har.json"),
    Options = new LoadStrikeAutopilotOptions
    {
        ScenarioName = "orders-autopilot",
        BaseUrlRewrite = "http://127.0.0.1:5080",
        IncludePreviewReport = true,
        TrackingSelector = "header:x-correlation-id",
        RunnerKey = "rkl_your_local_runner_key",
        SecretBindings =
        [
            new LoadStrikeAutopilotSecretBinding
            {
                Location = "header:Authorization",
                ValueFromEnv = "ORDERS_AUTH_HEADER"
            }
        ]
    }
});

if (result.Readiness != LoadStrikeAutopilotReadiness.Ready)
{
    throw new InvalidOperationException(string.Join("; ", result.Warnings));
}

var scenario = result.BuildScenario();

LoadStrikeRunner.RegisterScenarios(scenario)
    .WithRunnerKey("rkl_your_local_runner_key")
    .Run();

package main

import (
    "fmt"
    "os"
    "strings"

    loadstrike "loadstrike.com/sdk/go"
)

func main() {
    artifact, err := os.ReadFile("orders.har.json")
    if err != nil {
        panic(err)
    }

    result, err := loadstrike.GenerateAutopilot(loadstrike.LoadStrikeAutopilotRequest{
        Kind:    "Har",
        Content: string(artifact),
        Options: loadstrike.LoadStrikeAutopilotOptions{
            ScenarioName:         "orders-autopilot",
            BaseURLRewrite:       "http://127.0.0.1:5080",
            IncludePreviewReport: true,
            TrackingSelector:     "header:x-correlation-id",
            SecretBindings: []loadstrike.LoadStrikeAutopilotSecretBinding{
                {
                    Location:     "header:Authorization",
                    ValueFromEnv: "ORDERS_AUTH_HEADER",
                },
            },
            RunnerKey:            "rkl_your_local_runner_key",
        },
    })
    if err != nil {
        panic(err)
    }
    if result.Readiness != loadstrike.LoadStrikeAutopilotReady {
        panic(fmt.Sprintf("autopilot is not ready: %s %s", result.Readiness, strings.Join(result.Warnings, "; ")))
    }

    scenario := result.BuildScenario()

    loadstrike.RegisterScenarios(scenario).
        WithRunnerKey("rkl_your_local_runner_key").
        Run()
}

import com.loadstrike.runtime.LoadStrikeAutopilot;
import com.loadstrike.runtime.LoadStrikeAutopilot.LoadStrikeAutopilotOptions;
import com.loadstrike.runtime.LoadStrikeAutopilot.LoadStrikeAutopilotReadiness;
import com.loadstrike.runtime.LoadStrikeAutopilot.LoadStrikeAutopilotRequest;
import com.loadstrike.runtime.LoadStrikeAutopilot.LoadStrikeAutopilotSecretBinding;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import java.nio.file.Files;
import java.nio.file.Path;

var result = LoadStrikeAutopilot.generate(
    LoadStrikeAutopilotRequest
        .content("Har", Files.readString(Path.of("orders.har.json")))
        .withOptions(new LoadStrikeAutopilotOptions()
            .withScenarioName("orders-autopilot")
            .withBaseUrlRewrite("http://127.0.0.1:5080")
            .withTrackingSelector("header:x-correlation-id")
            .withRunnerKey("rkl_your_local_runner_key")
            .withSecretBindings(new LoadStrikeAutopilotSecretBinding(
                "header:Authorization",
                "ORDERS_AUTH_HEADER"))
            .includePreviewReport(true)));

if (!LoadStrikeAutopilotReadiness.Ready.equals(result.Readiness)) {
  throw new IllegalStateException(String.join("; ", result.Warnings));
}

var scenario = result.buildScenario();

LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();

from loadstrike_sdk import (
    LoadStrikeAutopilot,
    LoadStrikeAutopilotReadiness,
    LoadStrikeRunner,
)

artifact = """
{
  "log": {
    "entries": [
      {
        "startedDateTime": "2026-04-24T12:00:00Z",
        "time": 42,
        "request": {
          "method": "GET",
          "url": "https://api.example.com/orders/ord-1001",
          "headers": [{"name": "X-Correlation-Id", "value": "trk-1001"}],
          "queryString": []
        },
        "response": {
          "status": 200,
          "headers": [],
          "content": {"mimeType": "application/json", "text": "{}"}
        }
      }
    ]
  }
}
"""

result = LoadStrikeAutopilot.generate({
    "Kind": "Har",
    "Content": artifact,
    "Options": {
        "ScenarioName": "orders-autopilot",
        "BaseUrlRewrite": "http://127.0.0.1:5080",
        "IncludePreviewReport": True,
        "TrackingSelector": "header:x-correlation-id",
        "RunnerKey": "rkl_your_local_runner_key",
        "SecretBindings": [
            {
                "Location": "header:Authorization",
                "ValueFromEnv": "ORDERS_AUTH_HEADER",
            }
        ],
    },
})

if result.Readiness != LoadStrikeAutopilotReadiness.Ready:
    raise RuntimeError("; ".join(result.Warnings))

scenario = result.build_scenario()

LoadStrikeRunner.register_scenarios(scenario) \
    .with_runner_key("rkl_your_local_runner_key") \
    .run()

import fs from "node:fs";
import {
  LoadStrikeAutopilot,
  LoadStrikeAutopilotReadiness,
  LoadStrikeRunner
} from "@loadstrike/loadstrike-sdk";

const result = await LoadStrikeAutopilot.generate({
  Kind: "Har",
  Content: fs.readFileSync("orders.har.json", "utf8"),
  Options: {
    ScenarioName: "orders-autopilot",
    BaseUrlRewrite: "http://127.0.0.1:5080",
    IncludePreviewReport: true,
    TrackingSelector: "header:x-correlation-id",
    RunnerKey: "rkl_your_local_runner_key",
    SecretBindings: [
      {
        Location: "header:Authorization",
        ValueFromEnv: "ORDERS_AUTH_HEADER"
      }
    ]
  }
});

if (result.Readiness !== LoadStrikeAutopilotReadiness.Ready) {
  throw new Error(result.Warnings.join("; "));
}

const scenario = result.buildScenario();

await LoadStrikeRunner
  .registerScenarios(scenario)
  .withRunnerKey("rkl_your_local_runner_key")
  .run();

const fs = require("node:fs");
const {
  LoadStrikeAutopilot,
  LoadStrikeAutopilotReadiness,
  LoadStrikeRunner
} = require("@loadstrike/loadstrike-sdk");

(async () => {
  const result = await LoadStrikeAutopilot.generate({
    Kind: "Har",
    Content: fs.readFileSync("orders.har.json", "utf8"),
    Options: {
      ScenarioName: "orders-autopilot",
      BaseUrlRewrite: "http://127.0.0.1:5080",
      IncludePreviewReport: true,
      TrackingSelector: "header:x-correlation-id",
      RunnerKey: "rkl_your_local_runner_key",
      SecretBindings: [
        {
          Location: "header:Authorization",
          ValueFromEnv: "ORDERS_AUTH_HEADER"
        }
      ]
    }
  });

  if (result.Readiness !== LoadStrikeAutopilotReadiness.Ready) {
    throw new Error(result.Warnings.join("; "));
  }

  const scenario = result.buildScenario();

  await LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();
})();

SDK support

Use the same model across languages.

The scenario, step, tracking, and reporting concepts stay aligned across C#, Go, Java, Python, TypeScript, and JavaScript SDKs.

Teams using AI coding assistants can also start from the LoadStrike AI Agent Skills guide, which explains how to prompt for SDK-specific scenarios without changing the product's licensing or execution model.

Open Docs Hub Install Your SDK

Same transaction across SDKs

using LoadStrike;

var httpClient = new HttpClient
{
    BaseAddress = new Uri("https://api.example.com")
};

var scenario = LoadStrikeScenario.Create("read-order", async context =>
{
    var orderId = $"ord-{context.InvocationNumber}";

    var step = await LoadStrikeStep.Run<string>("GET /orders/{id}", context, async () =>
    {
        using var response = await httpClient.GetAsync($"/orders/{orderId}");

        return response.IsSuccessStatusCode
            ? LoadStrikeResponse.Ok<string>(statusCode: ((int)response.StatusCode).ToString())
            : LoadStrikeResponse.Fail<string>(
                statusCode: ((int)response.StatusCode).ToString(),
                message: "Order lookup failed");
    });

    return step.AsReply();
})
.WithLoadSimulations(
    LoadStrikeSimulation.Inject(10, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(20))
);

LoadStrikeRunner.RegisterScenarios(scenario)
    .WithRunnerKey("rkl_your_local_runner_key")
    .Run();

package main

import (
    "io"
    "net/http"
    "strconv"

    loadstrike "loadstrike.com/sdk/go"
)

func main() {
    scenario := loadstrike.CreateScenario("read-order", func(ctx loadstrike.LoadStrikeScenarioContext) loadstrike.LoadStrikeReply {
        return loadstrike.LoadStrikeStep.Run("GET /orders/{id}", ctx, func(loadstrike.LoadStrikeScenarioContext) loadstrike.LoadStrikeReply {
            request, err := http.NewRequest(http.MethodGet, "https://api.example.com/orders/ord-1001", nil)
            if err != nil {
                return loadstrike.LoadStrikeResponse.Fail("request_build_failed", int64(0), err.Error())
            }

            response, err := http.DefaultClient.Do(request)
            if err != nil {
                return loadstrike.LoadStrikeResponse.Fail("http_request_failed", int64(0), err.Error())
            }
            defer response.Body.Close()

            _, _ = io.Copy(io.Discard, response.Body)

            if response.StatusCode < 400 {
                return loadstrike.LoadStrikeResponse.Ok(strconv.Itoa(response.StatusCode), int64(0), "ok")
            }

            return loadstrike.LoadStrikeResponse.Fail(strconv.Itoa(response.StatusCode), int64(0), "Order lookup failed")
        })
    }).
        WithLoadSimulations(loadstrike.LoadStrikeSimulation.Inject(10, loadstrike.DurationFromSeconds(1), loadstrike.DurationFromSeconds(20)))

    loadstrike.RegisterScenarios(scenario).
        WithRunnerKey("rkl_your_local_runner_key").
        Run()
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeResponse;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeRunner;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeScenario;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeSimulation;
import com.loadstrike.runtime.LoadStrikeRuntime.LoadStrikeStep;

var client = HttpClient.newHttpClient();

var scenario = LoadStrikeScenario
    .create("read-order", context -> LoadStrikeStep.run("GET /orders/{id}", context, () -> {
      String orderId = "ord-" + context.invocationNumber;
      var request = HttpRequest.newBuilder(URI.create("https://api.example.com/orders/" + orderId))
          .GET()
          .build();
      var response = client.sendAsync(request, HttpResponse.BodyHandlers.ofString()).join();
      return response.statusCode() < 400
          ? LoadStrikeResponse.ok(Integer.toString(response.statusCode()))
          : LoadStrikeResponse.fail(Integer.toString(response.statusCode()), "Order lookup failed");
    }).asReply())
    .withLoadSimulations(LoadStrikeSimulation.inject(10, 1d, 20d));

LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();

import requests

from loadstrike_sdk import (
    LoadStrikeResponse,
    LoadStrikeRunner,
    LoadStrikeScenario,
    LoadStrikeSimulation,
    LoadStrikeStep,
)

def read_order(context):
    def run_step():
        order_id = f"ord-{context.invocation_number}"
        response = requests.get(f"https://api.example.com/orders/{order_id}", timeout=15)
        if response.ok:
            return LoadStrikeResponse.ok(str(response.status_code))
        return LoadStrikeResponse.fail(str(response.status_code), "Order lookup failed")

    return LoadStrikeStep.run("GET /orders/{id}", context, run_step).as_reply()

scenario = (
    LoadStrikeScenario.create("read-order", read_order)
    .with_load_simulations(LoadStrikeSimulation.inject(10, 1, 20))
)

LoadStrikeRunner.register_scenarios(scenario) \
    .with_runner_key("rkl_your_local_runner_key") \
    .run()

import {
  LoadStrikeResponse,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  LoadStrikeStep
} from "@loadstrike/loadstrike-sdk";

const scenario = LoadStrikeScenario
  .create("read-order", async (context) => {
    return LoadStrikeStep.run("GET /orders/{id}", context, async () => {
      const orderId = `ord-${context.invocationNumber}`;
      const response = await fetch(`https://api.example.com/orders/${orderId}`);

      return response.ok
        ? LoadStrikeResponse.ok(String(response.status))
        : LoadStrikeResponse.fail(String(response.status), "Order lookup failed");
    });
  })
  .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

await LoadStrikeRunner
  .registerScenarios(scenario)
  .withRunnerKey("rkl_your_local_runner_key")
  .run();

const {
  LoadStrikeResponse,
  LoadStrikeRunner,
  LoadStrikeScenario,
  LoadStrikeSimulation,
  LoadStrikeStep
} = require("@loadstrike/loadstrike-sdk");

(async () => {
  const scenario = LoadStrikeScenario
    .create("read-order", async (context) => {
      return LoadStrikeStep.run("GET /orders/{id}", context, async () => {
        const orderId = `ord-${context.invocationNumber}`;
        const response = await fetch(`https://api.example.com/orders/${orderId}`);

        return response.ok
          ? LoadStrikeResponse.ok(String(response.status))
          : LoadStrikeResponse.fail(String(response.status), "Order lookup failed");
      });
    })
    .withLoadSimulations(LoadStrikeSimulation.inject(10, 1, 20));

  await LoadStrikeRunner
    .registerScenarios(scenario)
    .withRunnerKey("rkl_your_local_runner_key")
    .run();
})();

Common questions

Product questions engineering teams ask first

Short answers on fit, rollout shape, pricing, and implementation.

Why is Trace-To-Test Autopilot a product differentiator?

It helps teams move from observed behavior to a reviewed first draft faster than starting from a blank file, while still keeping engineers in control of the final test.

How does LoadStrike correlate a transaction across systems?

It tracks a shared identifier across workflow stages and reports success, timeout, duplicates, and latency for the full path, not only the first service that received traffic.

Is LoadStrike self-hosted or managed?

LoadStrike is self-hosted. Teams run SDKs, reports, and supported cluster patterns in their own environment, which helps keep execution close to the systems being tested.

What does one runtime surface mean for engineering teams?

It means the same scenario, step, threshold, reporting, and correlation ideas appear across supported SDKs, so teams do not need separate test models for each language.

Can LoadStrike fit into existing reporting and observability workflows?

Yes. Local reports are built in for every run, and Enterprise adds portal reports plus supported reporting sinks for teams that already use observability platforms.

Put it to work

Start with one transaction, then expand.

Review a report, pick a plan, or open the guide for your stack.

Run Quick Start View Pricing