NBomber

Load test any system
with a distributed cluster

Modern and flexible .NET load testing framework for Pull and Push scenarios, designed to test any system regardless a protocol (HTTP/WebSockets/AMQP etc) or a semantic model (Pull/Push).

Technology agnostic


A fundamental feature of NBomber is that you can test any system from database to web server or message broker. Define and run your tests without any dependency on a protocol (HTTP/WebSockets/AMQP etc) or a semantic model (Pull/Push).

        var httpClient = new HttpClient();

        var scenario = Scenario.Create("http_scenario", async context =>
        {
            var request =
                Http.CreateRequest("GET", "https://nbomber.com")
                    .WithHeader("Accept", "text/html")
                    .WithBody(new StringContent("{ some JSON }"));

            var response = await Http.Send(httpClient, request);
            
            return response;
        })
        .WithLoadSimulations(
            Simulation.Inject(rate: 100,
                              interval: TimeSpan.FromSeconds(1),
                              during: TimeSpan.FromMinutes(3))
        );

        NBomberRunner
            .RegisterScenarios(scenario)
            .Run();
          
      var scenario = Scenario.Create("ping_pong_websockets", async ctx =>
      {
          using var websocket = new WebSocket(new WebSocketConfig());

          var connect = await Step.Run("connect", ctx, async () =>
          {
              await websocket.Connect("ws://localhost:5233/ws");
              return Response.Ok();
          });

          var ping = await Step.Run("ping", ctx, async () =>
          {
              await websocket.Send(payload);
              return Response.Ok(sizeBytes: payload.Length);
          });

          var pong = await Step.Run("pong", ctx, async () =>
          {
              using var response = await websocket.Receive();
              return Response.Ok(sizeBytes: response.Data.Length);
          });

          var disconnect = await Step.Run("disconnect", ctx, async () =>
          {
              await websocket.Close();
              return Response.Ok();
          });

          return Response.Ok();
       });
var scenario = Scenario.Create("mqtt_scenario", async ctx =>
{
    using var client = new MqttClient(new MqttFactory().CreateMqttClient());    
  
    var topic = "/clients/" + ctx.ScenarioInfo.InstanceId;

    var connect = await Step.Run("connect", ctx, async () =>
    {
        var clientOptions = new MqttClientOptionsBuilder()
            .WithTcpServer("localhost")             
            .WithClientId(ctx.ScenarioInfo.InstanceId)
            .Build();

        var response = await client.Connect(clientOptions);
        return response;
    });

    var subscribe = await Step.Run("subscribe", ctx, () => client.Subscribe(topic));

    var publish = await Step.Run("publish", ctx, async () =>
    {
        var msg = new MqttApplicationMessageBuilder()
            .WithTopic(topic)
            .WithPayload(payload)
            .Build();

        var response = await client.Publish(msg);
        return response;
    });

    var receive = await Step.Run("receive", ctx, async () =>
    {
        var response = await client.Receive();
        return response;
    });

    var disconnect = await Step.Run("disconnect", ctx, () => client.Disconnect());

    return Response.Ok();
});
        var redis = ConnectionMultiplexer.Connect("redis0:6380");
        var db = redis.GetDatabase();
        var random = new Random();

        var scenario = Scenario.Create("redis_scenario", async context =>
        {
            var userId = random.Next(1_000);

            byte[] data = await db.StringGetAsync($"user-{userId}");

            return Response.Ok(statusCode: "ok", sizeBytes: data.Length);
        })
        .WithLoadSimulations(
            Simulation.Inject(rate: 100,
                              interval: TimeSpan.FromSeconds(1),
                              during: TimeSpan.FromMinutes(3))
        );

        NBomberRunner
            .RegisterScenarios(scenario)
            .Run();
      

Deploy anywhere


NBomber works across almost all OS environments – including major Linux distributions, Windows, Mac OS. It can also be deployed in containers such as Docker, Kubernetes and Swarm.

Continuous integration


Easy integration with your CI/CD pipeline to run your tests automatically, check assertions and catch any performance degradation.

Distributed cluster


Simulate millions of concurrent users by running your tests from the test agents cluster.

Controllability and flexibility


Simulate any real workload to cover complex cases with mixing Pull/Push scenarios, protocols (HTTP/WebSockets) and formats (XML/JSON/Protobuf).

Real time reports


Take a look at a test in real time and perform detailed results analysis to understand trends.

Pluggable integrations


Take advantage of the pluggable architecture and use integrations with test runners (Nunit/Xunit), container orchestrators (Kubernetes), data storage and visualisation (InfluxDb + Grafana).

NBomber Cloud

Basic

$99/mo

Coming Soon
Essential

$199/mo

Coming Soon
Premium

$499/mo

Coming Soon
Maximum simulated users   10,000 users 50,000 users > 500,000 users
Max run time 10 minutes 30 minutes 12 hours
Test per month Unlimited Unlimited Unlimited
Regions: All available All available All available
Data retention 1 month 2 month 3 month

NBomber (self-hosted)

Free
(only for personal use)

$0

Download
Business
(price for company)

$99/MO

Enterprise
(price for company)

$199/MO

30-day money back guarantee
Single license can be shared for the whole company
NBomber Cluster
Unlimited number of clusters
Unlimited number of nodes per cluster
Slack chat with NBomber team
Data Feed
CI/CD integration
Report formats: [HTML, CSV, TXT, MD]
Realtime reporting
Grafana Dashboard
InfluxDB Reporting Sink
ElasticSearch logger
.NET Runtime Metrics
Metrics API

Frequently asked questions

How many instances can be installed with one NBomber business license?

- Unlimited


Can multiple teams use the same license within one organization?

- Yes, a single license can be shared for the whole organization


How many executions can be run in parallel?

- Unlimited


How many users can use the license in parallel?

- Unlimited