Docs›Getting Started

Quickstart

Get Bugnet running in your game in under five minutes. No backend setup, no DevOps, no build pipelines — just copy a few lines of code and start catching bugs from your players.

💡

Before you start: You'll need a free Bugnet account. Sign up here — it takes 30 seconds.

Step 1: Create a project

After signing up, head to your dashboard and click New Project. Give it a name that matches your game — Bugnet derives the project slug used in API URLs from it. Then open the Integrate tab and copy your project’s API key; it’s the only credential the SDK needs.

Step 2: Install the SDK

Choose the SDK for your engine and drop it into your project. Each SDK is dependency-free source you add to your project, and does its network work in the background so it never blocks your game loop.

  • Unity — Download BugnetSDK.cs into your Assets/Scripts/ folder
  • Godot — Download BugnetSDK.gd and add it as an Autoload
  • Unreal Engine — Copy BugnetSDK.h and BugnetSDK.cpp into your Source/ folder
  • Web / HTML5 — Include bugnet-sdk.js via a script tag
  • Construct 3 — Install the bugnet.c3addon addon
  • GameMaker — Add BugnetSDK.gml as a script
  • Pygame — pip install bugnet-sdk, or drop bugnet_sdk.py next to your game

See the SDKs documentation for full installation instructions per engine.

Step 3: Initialize

Call the init function with your API key and server URL. That's it — Bugnet is now listening for bug reports from your players.

C#
// Unity — attach BugnetSDK to a persistent GameObject

void Start() {
  BugnetSDK.Instance.Init(
    "YOUR_API_KEY",
    "https://api.bugnet.io"
  );
}

// Show the bug report widget on a keybind
if (Input.GetKeyDown(KeyCode.F1))
  BugnetSDK.Instance.ShowWidget();
GDScript
# bugnet_controller.gd — add BugnetSDK.gd as an Autoload named "Bugnet"
extends Node

var _bugnet_widget_open: bool = false

func _ready() -> void:
  Bugnet.bugnet_init(
    "YOUR_API_KEY",
    "https://api.bugnet.io"
  )

  Bugnet.bug_reported.connect(_on_bug_reported)

func _on_bug_reported(title: String) -> void:
  print("Bug reported: ", title)

# F1 toggles the widget, ESC closes it
func _input(event) -> void:
  if event is InputEventKey and event.pressed and event.keycode == KEY_F1:
    if _bugnet_widget_open:
      Bugnet.hide_widget()
      _bugnet_widget_open = false
    else:
      Bugnet.show_widget()
      _bugnet_widget_open = true
    return

  if event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE:
    if _bugnet_widget_open:
      Bugnet.hide_widget()
      _bugnet_widget_open = false
    return
C++
// Unreal — access via GameInstance subsystem

UBugnetSDK* Bugnet = GetGameInstance()
  ->GetSubsystem<UBugnetSDK>();

Bugnet->Initialize(
  TEXT("YOUR_API_KEY"),
  TEXT("https://api.bugnet.io")
);

// Report a bug
Bugnet->ReportBug(
  TEXT("Bug title"),
  TEXT("Bug description")
);
JavaScript
// Web / HTML5 — include via script tag

Bugnet.init({
  apiKey:    'YOUR_API_KEY',
  serverUrl: 'https://api.bugnet.io',
  gameVersion: '1.0.0'
});

// Show the bug report widget
Bugnet.showWidget();

Step 4: Submit a test bug

Run your game and trigger the bug report widget (press F1 if you used the keybind above). Fill in a title and description, then hit Submit. Alternatively, you can submit a test bug directly via the API:

Bash
curl -X POST https://api.bugnet.io/api/bugs/submit \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Test bug from quickstart",
    "description": "If you can see this, Bugnet is working!",
    "priority": "low"
  }'

Step 5: Check your dashboard

Open your project in the Bugnet dashboard and click the Bugs tab. You should see your test report listed with its title, priority, and timestamp. From here you can assign it, change the status, add comments, or delete it.

That's it — you're up and running. Your players can now submit bugs directly from inside your game, and you'll see them all in one place.

Create Account

Setting up your Bugnet account takes less than a minute. Here's everything you need to know.

Sign up

Visit /app/login and sign up using your email address. You can also sign up with a Google or GitHub account for one-click access.

Verify your email

After signing up with email, check your inbox for a verification link. Click it to confirm your address. You can start using Bugnet right away while you wait for it. If you don't see the email within a few minutes, check your spam folder or request a new one.

Complete the onboarding flow

After signing up, a two-step onboarding flow sets things up for you:

  1. Select your team size — How many people work on your game.
  2. Choose your engine — Unity, Godot, Unreal, Web and the other supported engines. Bugnet uses this to show the right SDK setup instructions first.

Create your first project

After onboarding, you'll be prompted to create your first project. Enter your game's name — Bugnet will generate a URL-friendly slug automatically from the name, or you can type your own. Bugnet adds a short prefix to keep slugs unique across accounts (e.g., "My Cool Game" becomes something like a1b2c3-my-cool-game); the final slug is shown on the project.

Once created, you'll land on the project dashboard with your API key ready to copy. Head to the Quickstart section above to integrate the SDK.

API Keys

API keys authenticate your game's SDK with the Bugnet servers. Every project has its own unique key, and all bug reports submitted through the SDK are associated with the project that key belongs to.

Where to find your API key

Navigate to your project and open the Integrate tab. Your API key is displayed at the top of the page with a one-click copy button. Each project has a single live key that starts with sk_live_.

Key scoping

API keys are scoped per-project. Each game or application gets its own key, which means:

  • Bug reports are automatically routed to the correct project
  • Revoking one key doesn't affect your other projects
  • Team members with access to one project can't use its key to access another
⚠️

The API key ships inside your game, so treat it as public. It can only file reports and telemetry into its own project; it can’t read your bugs or change settings. If someone starts abusing it (for example spamming reports), rotate it. Never put a session token in a game build.

Rotating keys

If your API key is being abused, rotate it from the Integrate tab: click Rotate Key and confirm. The old key stops working immediately, so builds already in players’ hands stop reporting until they update — ship a build with the new key as soon as you rotate.

Using the X-API-Key header

For SDK and public API endpoints, include your API key in the X-API-Key request header. This is the preferred authentication method for game clients and server-to-server integrations.

HTTP
POST /api/bugs/submit HTTP/1.1
Host: api.bugnet.io
X-API-Key: sk_live_abc123def456
Content-Type: application/json

{
  "title": "Player fell through the floor",
  "description": "Happened on level 3 near the bridge.",
  "priority": "high"
}

Dashboard Overview

The dashboard is where you triage reports, watch your game’s health, and manage your team. The sidebar has these sections:

Dashboard

The home page summarizes every project you can see: open, in-progress and resolved bug counts, your projects, and recent reports.

Projects

Create projects and manage each one’s settings from its card: name, website, logo, public visibility, and the SDK capture toggles (screenshot capture, session capture, auto-filing of errors, editor errors, warnings, bug grouping).

Bug Reports

View and manage every report from players and teammates. Click a report to see its details, screenshot, stack trace and logs, device info, stacked occurrences, attachments and comments.

  • Filter by status (open, in progress, resolved, closed, won’t fix), priority, category, assignee, label and source
  • Full-text search across titles and descriptions
  • Bulk actions: change status, priority, category or assignee, or delete

Players

Players seen through sessions and reports, with their sessions, reports and your notes.

Game Health

Your game’s stability in one place:

  • Crash-free rate — Share of sessions that ended without a crash, with a 30-day trend
  • Crashes by platform and top crash signatures
  • Release health — Health score and crash-free rate per game version
  • Regressions — Resolved bugs that appear to have come back
  • Report trends — Volume, categories, platforms, response time by priority, top reporters and satisfaction ratings

Analytics

Custom event dashboards and the Live Logs feed (Studio and up). See Event Tracking.

Integrate

  • Your project’s API key (with copy and rotate)
  • Setup instructions and downloads for every supported engine
  • Webhooks, Discord, GitHub/GitLab and Steam

Widget Builder

Theme the in-game bug report widget to match your game (Studio and up).

Public Roadmap

Publish a public roadmap and bug tracker so players can see what you’re working on and upvote what matters to them. See Public Pages.

Team

Invite collaborators by email, set roles (owner, admin, member), and customize individual permissions. See Team & Roles.

Billing

Your plan, usage against its limits, payment methods and invoices. See Billing.

Settings

Your personal settings: profile, email notifications, password, appearance (light or dark), active sessions, a support share code, and data export. Project tools such as API keys, webhooks, bug templates, custom fields, SLA rules and the activity log are also reachable here, along with the danger zone for deleting your account.