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.

Step 1: Create a project

After signing up, head to your dashboard and click New Project. Give it a name that matches your game — this becomes the project slug used in API URLs. Once created, you'll land on the Integrate tab where you can grab your API key and Game ID. Keep both handy; you'll need them for the SDK.

Step 2: Install the SDK

Choose the SDK for your engine and drop it into your project. Each SDK is a single file, under 3KB, with zero external dependencies and no measurable performance overhead.

• 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

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.

// 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();

# Godot — add BugnetSDK.gd as an Autoload named "Bugnet"

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

# Show the bug report widget
func _input(event):
  if event.is_action_pressed("report_bug"):
    Bugnet.show_widget()

// 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")
);

// 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:

curl -X POST https://api.bugnet.io/api/bugs \
  -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 activate your account. If you don't see the email within a few minutes, check your spam folder or request a new verification email from the login page.

Complete the onboarding flow

Once verified, you'll be guided through a quick onboarding flow to personalize your experience:

1. Choose your role — Select the role that best describes you: developer, designer, QA, producer, community manager, or player. This helps Bugnet tailor the dashboard to your workflow.
2. Select your team size — Let us know how many people are on your team. This determines your default plan recommendation (solo developers get the Free tier automatically).
3. Choose your game platforms — Tell us where your game runs (Windows, Mac, Linux, iOS, Android, Web, consoles). This helps configure platform-specific crash analytics.

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 (e.g., "My Cool Game" becomes my-cool-game). You can customize the slug before confirming.

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

Rotating keys

If you suspect your API key has been compromised, you can rotate it from the Integrate tab. Click Rotate Key and confirm. The old key is immediately invalidated, and a new one is generated. Make sure to update the key in your game build and any CI/CD pipelines before shipping.

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.

POST /api/bugs 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 Bugnet dashboard is your command center for managing bug reports, monitoring game health, and collaborating with your team. Here's a tour of every tab and what you'll find in each.

Bugs

The Bugs tab is where you view and manage all bug reports submitted by players and team members. Reports are listed in a sortable, filterable table with columns for title, status, priority, reporter, and date. Click any bug to see its full details, screenshots, crash logs, device info, and comment thread.

• Filter by status (open, in progress, resolved, closed, won't fix)
• Filter by priority (critical, high, medium, low)
• Search by title, description, or reporter
• Bulk actions: assign, change status, add labels, or delete

Game Health

The Game Health tab gives you a bird's-eye view of your game's stability. It combines crash analytics, release health, and performance metrics into a single dashboard.

• Crash-free rate — Percentage of sessions that completed without a crash (target: 99.5%+)
• Daily trend — 30-day chart showing crash-free rate over time
• Platform breakdown — See which platforms crash most
• Version comparison — Compare crash rates across game versions to catch regressions
• Top crash signatures — Most frequent crashes grouped by fingerprint

Integrate

The Integrate tab is your hub for connecting Bugnet to everything. Here you'll find:

• Your API key and Game ID
• SDK download links for every supported engine
• Webhook configuration
• Third-party integrations (Discord, GitHub, GitLab, Steam)

Roadmap

The Roadmap tab lets you configure a public-facing roadmap for your game. Players can see what you're working on, what's planned, and what's been shipped. Link bug reports to roadmap items to show players their feedback is being heard.

Team

The Team tab is where you manage team members and invitations. Invite collaborators by email, assign roles (owner, admin, member, viewer), and control who can triage bugs, manage integrations, or access billing.

Billing

The Billing tab shows your current subscription plan, usage, and payment history. Upgrade or downgrade plans, update your payment method, and download invoices.

Settings

The Settings tab contains project-level configuration: project name and slug, default bug priority, notification preferences, email forwarding rules, and danger zone options like archiving or deleting the project.

Quick stats

At the top of the dashboard, you'll see a row of quick stats summarizing your project's health at a glance:

• Open bugs — Total number of unresolved bug reports
• In progress — Bugs currently being worked on
• Resolved this week — Bugs closed in the last 7 days
• Crash-free rate — Current session crash-free percentage
• Recent activity — A feed of the latest comments, status changes, and new reports