The response is just the beginning.
Follow the request into the downstream event that proves the work actually finished.
Transaction testingCreate code-first scenarios, track completion across systems, and bring the results together in one correlated report.
POST /checkoutorders.createdConfirmation visibleIllustrative workflow · animation is a demo, not live traffic.
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.
Build tests around the outcome that matters. Keep the source action and downstream result in the same measured path.
Follow the request into the downstream event that proves the work actually finished.
Transaction testingConnect a shared tracking value across APIs, queues, and services to measure completion.
Event-driven systemsConnect a browser action to the backend outcome, alongside the steps a user sees.
Browser journeysInspect latency, failed rows, and threshold outcomes together. Follow the trace through to completion.
From trigger to observed outcome
Start with the SDK you already use.
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();checkout_013timeout2.01sIllustrative report with simulated telemetry. Results depend on your workload, configuration, SDK, and plan.
Bring a HAR, OpenTelemetry trace, browser recording, or message sample. Trace-To-Test Autopilot creates a starter scenario for you to review before replay.
Explore Trace-To-TestLoadStrike 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.
Best when a performance question spans more than one system.
Create a safe starter scenario from HARs, traces, recordings, or message pairs.
Track the source action and the downstream result with one shared transaction model.
Run LoadStrike on your own infrastructure in local, CI, or clustered setups.
Use one runtime for APIs, Kafka, streams, browser flows, and reports.
Start with the report, then map it back to the runtime choices.
Use Autopilot when you have workflow evidence and need a quick first draft.
Use the docs hub for language samples, transport setup, and cluster guidance.
Pricing keeps the self-hosted plan model simple and predictable.
Autopilot reads workflow evidence, hides secrets, checks replay safety, and returns a starter plan.
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();
})();
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.
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();
})();
Short answers on fit, rollout shape, pricing, and implementation.
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.
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.
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.
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.
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.
Review a report, pick a plan, or open the guide for your stack.
Define the trigger. Track the outcome. See the full path.