Ecosystem GripAi · GameAi · GameGrip
LIVE
Incidents Tracked
Active Hotspots
Games Monitored
15Live Services
Powered by JaffaAi

Developer FAQ

Everything you need to plug jaffaAi into your game — from first API call to full SDK integration.

⚡ Quick Start — 3 Steps

Get crash intelligence in your game in under 5 minutes.

1

Get Your API Key

Head to the Grip Protocol portal and generate a free key. The Indie tier gives you 50 reports/month — no credit card needed.

2

Send a Bug Report

POST to /Jaffa/report with your game title and error. jaffaAi analyses it, searches for fixes, and returns actionable intelligence.

3

Get Fixes Back

The response includes severity, category, AI-suggested fixes with confidence scores, and links to community solutions. Show them in-game or on your dashboard.

🔧 Your First API Call

cURL
curl -X POST https://jaffaai.cc/Jaffa/report \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_API_KEY" \
  -d '{
    "gameTitle": "Elden Ring",
    "errorText": "Crash to desktop during boss transition",
    "platform": "PC",
    "engine": "Unreal Engine"
  }'
JavaScript / Node.js
const response = await fetch('https://jaffaai.cc/Jaffa/report', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-API-Key': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    gameTitle: 'Elden Ring',
    errorText: 'Crash to desktop during boss transition',
    platform: 'PC',
    engine: 'Unreal Engine'
  })
});

const data = await response.json();
console.log(data.incident);  // severity, category, AI analysis
console.log(data.fixes);     // ranked fixes with confidence scores
C# / Unity
using UnityEngine.Networking;
using System.Text;

var json = JsonUtility.ToJson(new BugReport {
    gameTitle = "My Game",
    errorText = "NullReferenceException in PlayerController",
    platform  = "PC",
    engine    = "Unity"
});

var request = new UnityWebRequest("https://jaffaai.cc/Jaffa/report", "POST");
request.uploadHandler   = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));
request.downloadHandler = new DownloadHandlerBuffer();
request.SetRequestHeader("Content-Type", "application/json");
request.SetRequestHeader("X-API-Key", "YOUR_API_KEY");

yield return request.SendWebRequest();
Debug.Log(request.downloadHandler.text);

📡 API Endpoints

Base URL: https://jaffaai.cc  |  Auth: X-API-Key header

MethodEndpointDescription
POST /Jaffa/report Submit a bug report — returns AI analysis + fixes synchronously
POST /Jaffa/report/async Fire-and-forget — queues for background processing
GET /Jaffa/incidents List incidents — filter by ?gameTitle=, ?status=, ?limit=
GET /Jaffa/incident/:id Full incident details including timeline and AI payload
GET /Jaffa/fix/:incidentId Get ranked fixes for an incident, sorted by confidence
GET /Jaffa/hotspots Aggregated issue patterns — see what's breaking the most
GET /Jaffa/analytics/dashboard Full dashboard stats: incidents, fixes, severity breakdown
POST /Jaffa/webhooks/register Register a webhook to receive incident alerts
POST /Jaffa/search Manual web search for game fixes
GET /health Service health check (no auth required)

SDK Endpoints

Base URL: https://jaffaai.cc/api/sdk  |  Auth: X-SDK-Key header

MethodEndpointDescription
POST /api/sdk/logs Send telemetry event batches from your game client
POST /api/sdk/crash Report a crash with stack trace — auto-creates incident
POST /api/sdk/session Start/end a play session for analytics
GET /api/sdk/health SDK service health (no auth required)

Frequently Asked Questions

Getting Started
What is jaffaAi?
jaffaAi is an AI-powered gaming incident intelligence platform. It tracks bugs, crashes, and performance issues across 500+ games in real time — then uses AI to analyse, categorise, and suggest fixes. Think of it as a smart error-tracking layer for your game that already knows what's broken across the industry.
How do I get an API key?
Head to the Grip Protocol portal and generate your key from the "Get API Key" section. The Indie tier is free — 50 reports/month, no credit card required. You'll get your key instantly.
What games does jaffaAi track?
Our crawler actively monitors 500+ games — from AAA titles like Elden Ring, Apex Legends, Counter-Strike 2, and Fortnite, to indie hits. We pull from Steam, GitHub, and community sources. See what's being tracked right now on the Live Intel page. You can also submit reports for any game via the API — it doesn't need to be in our crawler list.
Is jaffaAi just for my game, or the whole industry?
Both! When you send a bug report, jaffaAi checks its intelligence across all tracked games. If a similar crash pattern was seen in another title and a fix was found, you get that fix suggested automatically. Your game benefits from the collective intelligence of the entire ecosystem.
Integration
How do I integrate jaffaAi into my game?
You've got two options:
  • REST API — Call /Jaffa/report from any language. Send a bug report, get AI analysis + fixes back. Works with any engine, any platform.
  • Unity SDK — Drop the GameGrip C# SDK into your Unity project. It auto-captures crashes, logs, and session data — zero code needed for basic crash tracking.
Both methods use your API key for auth. See the code examples above for a quick start.
Can I use jaffaAi with Unity?
Yes! The GameGrip Unity SDK (C#, Unity 2021.3+) handles everything automatically:
  • Auto-captures crashes and unhandled exceptions
  • Logs performance events (FPS drops, memory spikes)
  • Tracks play sessions for analytics
  • Built-in privacy sanitisation — no player PII is sent
  • Batches events to minimise network calls
Just import the SDK package, set your SDK key, and you're live.
Can I use jaffaAi with Unreal Engine, Godot, or other engines?
Absolutely. The REST API works with any engine or language — Unreal (C++/Blueprint via HTTP), Godot (GDScript), custom engines, or even server-side code. If your engine can make an HTTP POST request, you can use jaffaAi. The Unity SDK just adds convenience wrappers; the core API is engine-agnostic.
What data do I need to send in a report?
Only two fields are required:
  • gameTitle — your game's name
  • errorText — description of the bug/crash
Optional fields that improve analysis:
  • platform — PC, PS5, Xbox, Switch, Mobile
  • engine — Unity, Unreal, Godot, etc.
  • stackTrace — for crash reports
  • metadata — any extra context (game version, OS, GPU)
The more context you send, the better the AI analysis.
Can I receive alerts when new issues are detected?
Yes — use webhooks. Register your endpoint at /Jaffa/webhooks/register and you'll receive HMAC-signed POST requests whenever new incidents match your game. Great for hooking into Discord, Slack, or your own monitoring dashboard. Available on Studio and Enterprise tiers.
API & Technical
What's the difference between /report and /report/async?
  • /Jaffa/reportSynchronous. Processes the report immediately and returns the full AI analysis + fixes in the response. Typical response time: 1-3 seconds. Best when you want to show fixes to the player right away.
  • /Jaffa/report/asyncFire-and-forget. Queues the report for background processing and returns immediately (202 Accepted). Best for bulk/automated reporting where you don't need instant results. Retrieve results later via /Jaffa/incident/:id.
What does a response look like?
A typical /Jaffa/report response includes:
  • incident — ID, severity (critical/high/medium/low), category (crash, performance, rendering, etc.), AI summary
  • fixes — Array of suggested fixes, each with a confidence score (0-1), source, and step-by-step instructions
  • related — Similar incidents found across other games
  • metadata — Processing time, pipeline version
Are there rate limits?
Rate limits depend on your tier:
  • Indie (free) — 50 reports/month, 1 API key
  • Studio (£29/mo) — 500 reports/month, 5 API keys
  • Enterprise (£149/mo) — Unlimited reports, unlimited keys, SLA
The API returns 429 Too Many Requests if you exceed your limit. The response includes a Retry-After header.
How does authentication work?
Two methods, both work everywhere:
  • API Key — Pass your key in the X-API-Key header. Best for server-to-server and backend calls.
  • Bearer Token (SSO) — Sign in via GameGrip Auth, then use the JWT token as Authorization: Bearer <token>. Best for frontend dashboards and browser-based tools.
SDK endpoints use X-SDK-Key instead. The /health endpoint requires no auth.
Pricing & Plans
What plans are available?
Indie
£0 / month
  • 50 reports / month
  • Basic severity analysis
  • 1 API key
  • Community support
Enterprise
£149 / month
  • Unlimited reports
  • Grip Protocol bridge
  • Team management
  • Unlimited API keys
  • SLA guarantee
Can I upgrade or downgrade at any time?
Yes — plans are managed through the jaffaAi Dashboard. Upgrades take effect immediately, downgrades at the end of your billing period. No contracts, cancel anytime.
Data & Privacy
Is player data safe?
Yes. jaffaAi processes technical data only — error messages, stack traces, platform info. We never collect player names, emails, IP addresses, or gameplay data. The Unity SDK includes built-in privacy sanitisation that strips any PII before sending. Your players' data stays with you.
Where is data stored?
All data is processed and stored on secured servers. Incident data is retained for your active subscription period. The crawl intelligence (public game data from Steam, GitHub, etc.) feeds the broader ecosystem — your private bug reports are never shared with other developers.
The GameGrip Ecosystem
What's the difference between jaffaAi, Grip Protocol, and GameGrip?
  • jaffaAi — The AI engine. Processes bug reports, runs intelligence pipelines, serves the API. This is what you integrate with.
  • Grip Protocol — The data layer. Aggregates, indexes, and distributes intelligence across the ecosystem. Manages API keys and developer portal.
  • GameGrip — The consumer-facing platform. Blog posts, game health guides, and community resources powered by the intelligence pipeline.
  • Sandbox — Public intelligence feed. Browse crawl findings, fix guides, and trending issues across all tracked games.
As a developer, you mainly interact with jaffaAi (API) and Grip Protocol (API keys + docs).
What's the Live Intel page?
The Live Intel page is a real-time dashboard showing what GameGrip's crawlers are finding. It tracks issues, patches, and trends across 500+ games — updated every 5 minutes. Great for seeing what's happening across the gaming landscape or checking if your game's issues are being tracked.

Ready to integrate?

Get your free API key and start tracking bugs in under 5 minutes.

🔑 Get Your Free API Key