Gaming-API-Plattform

Marketing-APIs für Spiele-Entwickler

Integrieren Sie Player-Engagement, Push-Benachrichtigungen und Analytics in Stunden, nicht Wochen. RESTful APIs, native SDKs für Unity und Unreal, umfassende Dokumentation. Entwickelt für Teams, die schnell liefern.

Marketing-APIs für Spiele-Entwickler

Was Entwickler erhalten

API-first Marketing-Automatisierung für Spielestudios. Push-Benachrichtigungen senden, Events tracken, Spieler segmentieren und Performance messen — über einfache, leistungsstarke APIs. SDKs für Unity, Unreal, iOS, Android und Cross-Platform-Stacks, bereit zur Integration.

Schnelle Integration

2–10 Tage von der SDK-Installation bis zur Produktion. Fertige SDKs für Unity, Unreal, iOS, Android, React Native, Flutter. Push-Benachrichtigungen noch am selben Tag live.

Vollständige API-Abdeckung

RESTful APIs für Push, In-App, E-Mail, Segmentierung, Analytics und Nutzerverwaltung. Webhooks für Echtzeit-Events. Vollständiges CRUD auf allen Ressourcen.

Entwicklerfreundliche Docs

Interaktive API-Referenz, Code-Beispiele in mehreren Sprachen, SDK-Guides, Postman-Collections, OpenAPI-Specs. Copy-paste-Code, der funktioniert.

Für Skalierung gebaut

500.000 API-Aufrufe pro Sekunde. Response-Zeiten unter 100 ms. Kein Throttling bei Spitzenlast. 10 Mio. Spieler und 50 Mio. API-Aufrufe ohne Ausfallzeit.

API-Funktionen für Gaming

Kampagnen auslösen, Events tracken, Segmente verwalten und Analytics direkt aus Ihrem Game-Server abrufen. Jede Dashboard-Funktion ist programmatisch verfügbar. Alle API-Funktionen ansehen.

Push-Benachrichtigungen programmatisch senden

Push-Benachrichtigungen vom Game-Server aus Spieleraktionen heraus auslösen. Echtzeit-Zustellung an iOS, Android und Web. Rich Notifications, Deep Links und benutzerdefinierte Daten werden unterstützt.

POST /api/v3/notifications
{
"filter": "player_level > 20",
"notification": {
"content": {
"en": "Tournament starts in 1 hour!"
},
"data": {
"tournament_id": "12345",
"deep_link": "game://tournament/12345"
}
}
}

Spielerverhalten in Echtzeit tracken

Benutzerdefinierte Events vom Game-Client oder Server senden. Käufe, Level-Abschlüsse und Feature-Nutzung tracken. Events lösen Kampagnen aus und unterstützen die Segmentierung.

POST /api/v3/events
{
"user_id": "player_12345",
"event": "level_completed",
"attributes": {
"level": 50,
"time_seconds": 142,
"score": 8750
}
}

Spielersegmente erstellen und verwalten

Segmente programmatisch auf Basis von Events, Eigenschaften und Verhalten aufbauen. In Echtzeit aktualisieren. Kampagnen gezielt an bestimmte Spielergruppen ausspielen.

POST /api/v3/segments
{
"name": "High-value players",
"filter": {
"AND": [
{"total_spend": {"$gt": 100}},
{"last_session": {"$gte": "7d"}}
]
}
}

Kampagnen- und Spieler-Metriken abrufen

Kampagnen-Performance, Player-Engagement und Conversion-Daten abrufen. In Ihr Data Warehouse exportieren. Eigene Dashboards aufbauen.

GET /api/v3/analytics/campaigns/{campaign_id}
{
"sent": 150000,
"delivered": 142500,
"opened": 64125,
"clicked": 19237,
"conversions": 2890
}

SDK-Integration für Game-Engines

Native SDKs für alle gängigen Plattformen. Einfache Installation, vollständige Feature-Abdeckung und Code-Beispiele für häufige Szenarien. Alle Gaming-Integrationen ansehen.

Unity SDK

Unity 2019.4+ | C# | Unity Package Manager oder manueller Import | Integration in 2–4 Stunden

Unterstützt Push-Benachrichtigungen, In-App-Nachrichten, Event-Tracking und User-Properties.

// Initialize
Pushwoosh.Instance.RegisterForPushNotifications();
// Track event
Pushwoosh.Instance.PostEvent("level_completed",
new { level = 50, score = 8750 });
// Set user properties
Pushwoosh.Instance.SetUserId("player_12345");

Unreal Engine SDK

Unreal Engine 4.25+, UE5 | C++ und Blueprints | Marketplace-Plugin oder manuell | Integration in 2–4 Stunden

Unterstützt Push, Events und Analytics. Blueprint-Nodes für Code-freie Workflows.

// Initialize
UPushwooshBlueprint::RegisterForPushNotifications();
// Track event
UPushwooshBlueprint::PostEvent("level_completed",
TMap<FString, FString>{
{"level", "50"},
{"score", "8750"}
});

iOS Native SDK

iOS 12+ | Swift, Objective-C | CocoaPods, SPM, manuell | Integration in 1–2 Stunden

Vollständiger API-Zugriff mit Unterstützung für Rich Notifications und Live Activities.

// Initialize
Pushwoosh.sharedInstance().registerForPushNotifications()
// Track event
PWInAppManager.shared().postEvent("level_completed",
withAttributes: ["level": 50, "score": 8750])

Android Native SDK

Android 5.0+ (API 21+) | Kotlin, Java | Gradle-Abhängigkeit | Integration in 1–2 Stunden

Vollständiger API-Zugriff mit Rich-Notification-Unterstützung und Background-Event-Delivery.

// Initialize
Pushwoosh.getInstance().registerForPushNotifications()
// Track event
Pushwoosh.getInstance().sendTags(
Tags.Builder()
.putString("level", "50")
.putInt("score", 8750)
.build()
)

Cross-Platform SDKs

React Native, Flutter, Cordova, Xamarin. Vollständige Feature-Unterstützung über Hybrid-Stacks hinweg. Integration in 2–4 Stunden pro Plattform.

// React Native
import Pushwoosh from "pushwoosh-react-native-plugin";
Pushwoosh.register();
Pushwoosh.postEvent("level_completed", {
level: 50,
score: 8750
});

Alles, was Entwickler brauchen

Dokumentation, Tooling und Community-Ressourcen — damit Ihr Team vom ersten Tag an produktiv ist.

Interaktive API-Docs

Live-API-Explorer mit echten Anfragen. Aufrufe direkt im Browser testen. Authentifizierung wird automatisch gehandhabt.

Postman-Collection

Vorkonfigurierte Requests mit Umgebungsvariablen. Vollständige Endpoint-Abdeckung. Importieren und sofort mit dem Testen beginnen.

OpenAPI-Spec

Maschinenlesbare API-Definition. Client-Bibliotheken generieren. In jedes API-Tool importieren. Immer aktuell.

Code-Beispiele-Repo

GitHub-Repository mit Integrationsbeispielen für Unity, Unreal und native Plattformen. Community-Beiträge willkommen.

SDK-Quickstarts

Plattformspezifische Tutorials mit Schritt-für-Schritt-Integration. Video-Walkthroughs mit geschätzten Abschlusszeiten.

Test-Tools

Test-Push-Benachrichtigungen senden. Event-Tracking debuggen. API-Requests validieren. Spielerverhalten simulieren.

Webhooks und Callbacks

Echtzeit-Event-Benachrichtigungen. Kampagnenstatus-Updates. Player-Action-Trigger. Benutzerdefinierte Endpoint-Konfiguration.

Developer-Community

Stack-Overflow-Tag, Discord/Slack-Channels, GitHub-Discussions und E-Mail-Support für technische Fragen.

Was Sie mit unseren APIs bauen können

Fünf reale Implementierungen, die Game-Teams mit Pushwoosh umsetzen — relevant für Spielestudios im DACH-Raum, die auf der Gamescom und darüber hinaus präsent sind.

Serverseitig ausgelöste Benachrichtigungen

Ein Multiplayer-Spiel muss Spieler über Gilden-Events informieren. Der Game-Server erkennt, dass ein Gildenkrieg beginnt, ruft die API auf, um eine Push-Benachrichtigung an Gildenmitglieder zu senden, Deep Links öffnen das Spiel direkt beim Kriegsbildschirm, und der Server trackt, welche Spieler beigetreten sind.

// On game server
const guildMembers = await getGuildMembers(guildId);
await pushwoosh.sendNotification({
users: guildMembers,
message: "Guild war starting now!",
deepLink: `game://guild-war/${warId}`
});
// Track who joined
guildMembers.forEach(async (player) => {
if (await playerJoined(player, warId)) {
pushwoosh.trackEvent(player, "guild_war_joined", {
war_id: warId,
response_time_seconds: getResponseTime(player)
});
}
});

Ergebnis: Echtzeit-Engagement basierend auf Live-Game-Events.

Dynamische Segmentierung

Verschiedene Angebote an zahlende und nicht zahlende Spieler ausspielen. IAP-Events per API tracken, Segmente programmatisch erstellen, personalisierte Angebote senden und Conversions mit der Analytics-API messen.

// Track purchase
await pushwoosh.trackEvent(playerId, "iap_purchase", {
amount: 9.99,
item_id: "gem_pack_1000"
});
// Create high-spender segment
await pushwoosh.createSegment({
name: "High spenders",
filter: "total_iap_amount > 50"
});
// Send targeted campaign
await pushwoosh.sendToSegment("High spenders", {
message: "VIP exclusive: 50% off premium pack",
offer_id: "vip_premium_50"
});

Ergebnis: 3-fach höhere Conversion durch personalisiertes Targeting.

Echtzeit-Analytics-Integration

Engagement-Daten in Ihr Data Warehouse exportieren. Kampagnen-Metriken per API abrufen, Spieler-Event-Daten extrahieren, nach BigQuery oder Snowflake streamen und eigene BI-Dashboards aufbauen.

// Daily ETL job
const campaigns = await pushwoosh.getCampaigns({
date_from: yesterday,
date_to: today
});
for (const campaign of campaigns) {
const analytics = await pushwoosh.getCampaignAnalytics(campaign.id);
await dataWarehouse.insert("campaign_performance", {
campaign_id: campaign.id,
sent: analytics.sent,
delivered: analytics.delivered,
opened: analytics.opened,
clicked: analytics.clicked,
conversions: analytics.conversions,
revenue: analytics.revenue
});
}

Ergebnis: Einheitliche Player-Engagement-Analytics über alle Systeme hinweg.

Automatisierte Lifecycle-Kampagnen

Neue Spieler mit einer automatisierten Serie onboarden. Das SDK registriert den Nutzer bei der Anmeldung, der Server startet die Onboarding-Sequenz per API, und Kampagnen für Tag 1, 3 und 7 werden automatisch ausgelöst.

// On player signup
await pushwoosh.registerUser({
user_id: playerId,
attributes: {
signup_date: new Date(),
platform: "iOS",
acquisition_source: "organic"
}
});
// Start automated campaign
await pushwoosh.addToJourney(playerId, "new_player_onboarding");
// Track milestone events
await pushwoosh.trackEvent(playerId, "tutorial_completed", {
duration_seconds: 180
});

Ergebnis: Automatisiertes Onboarding ohne manuelles Kampagnenmanagement.

A/B-Testing per API

Verschiedene Benachrichtigungstexte für eine Turnier-Ankündigung testen. Test erstellen, Varianten an zufällige Gruppen senden, Engagement tracken und den Gewinner automatisch skalieren.

const test = await pushwoosh.createABTest({
name: "Tournament announcement copy test",
variants: [
{ name: "Variant A", message: "Tournament starts in 1 hour!", percentage: 50 },
{ name: "Variant B", message: "Win 10K gems! Tournament in 1 hour", percentage: 50 }
],
success_metric: "game_opens"
});
const results = await pushwoosh.getABTestResults(test.id);
await pushwoosh.scaleVariant(test.id, results.winner.id);

Ergebnis: Datengetriebene Optimierung im großen Maßstab.

Gebaut für Performance

<100ms
Durchschnittliche API-Antwortzeit
500K/sec
Verarbeitete API-Anfragen
99,9%
Uptime-SLA
<50ms
Echtzeit-Event-Tracking
Growth statistics chart

Sub-Sekunden-Antwortzeiten

95. Perzentil unter 200 ms. 99. Perzentil unter 500 ms. Gleichmäßige Latenz über alle Regionen hinweg.

Burst-Kapazität

500.000 Push-Benachrichtigungen pro Sekunde. Unbegrenzte Events pro Sekunde. Kein Throttling bei Spitzenlast.

Globale Infrastruktur

Multi-Region-Deployment. CDN für SDK-Auslieferung. Niedrig-Latenz-Endpoints weltweit. Optionen zur Datenhaltung.

Enterprise-taugliche API-Sicherheit

Produktionsreife Sicherheit für die größten Spielestudios. DSGVO-Konformität, verschlüsselte Übertragung und vollständiges Audit-Logging — entwickelt für den deutschen und europäischen Markt.

Authentifizierung

API-Key-Authentifizierung, OAuth 2.0, JWT-Tokens. Umgebungsspezifische Keys mit sicherem Rotation-Prozess.

Autorisierung

Rollenbasierte Zugriffskontrolle, bereichsbasierte Berechtigungen, IP-Whitelisting und automatische Key-Rotation.

Datenschutz

TLS 1.3 für die Übertragung. Verschlüsselung im Ruhezustand. PII-Maskierung in Logs. DSGVO-konforme Datenverarbeitung.

Monitoring

API-Nutzungsüberwachung, Anomalieerkennung, Missbrauchsprävention und vollständige Audit-Logs für die Compliance.

Support für Entwickler

Von Self-Service-Community-Ressourcen bis zu dedizierten Technical Account Managern — das richtige Support-Modell für jede Teamgröße.

Community-Support

Stack-Overflow-Tag, GitHub-Discussions, Discord- und Slack-Community sowie das Dokumentationsportal.

E-Mail-Support

Technische Fragen, Integrationshilfe, Bug-Reports. Antwortzeit unter 24 Stunden.

Priority-Support

Dedizierter Slack-Channel, Video-Calls für komplexe Integrationen, individuelle SDK-Beratung. Antwort in unter 4 Stunden.

Enterprise-Support

Dedizierter Technical Account Manager, individuelle API-Entwicklung, Integration vor Ort, 24/7-Telefon-Support.

Migration von anderen Plattformen

Von Firebase, OneSignal oder Airship wechseln — ohne Ausfallzeit. Beide Plattformen parallel betreiben, bis Sie bereit für den Wechsel sind. Besonders für deutsche Indie-Studios, die von Firebase migrieren, bietet Pushwoosh eine DSGVO-konforme Alternative mit vollständiger EU-Datenhaltung.

  1. SDK-Integration parallel betreiben

    Das Pushwoosh SDK neben Ihrer bestehenden Plattform installieren. Event-Zustellung in einer Testumgebung validieren.

  2. Event-Mapping und Validierung

    Bestehende Events und User-Properties auf das Pushwoosh-Schema mappen. Metriken direkt vergleichen.

  3. Schrittweise Traffic-Verlagerung

    Einen Teil des Traffics auf Pushwoosh verlagern. Zustellraten und Engagement überwachen. Über 1–2 Wochen hochskalieren.

  4. Vollständiger Wechsel

    Den gesamten Traffic auf Pushwoosh umstellen, sobald die Parität bestätigt ist. Die alte Plattform 1 Woche als Fallback behalten.

  5. Alte Plattform abschalten

    Das Legacy-SDK mit dem nächsten Release entfernen. Typische Migrationsdauer: 2–4 Wochen von Anfang bis Ende.

Integration in Minuten starten

Erkunden Sie unsere API-Dokumentation und starten Sie mit der Entwicklung. Der kostenlose Tarif enthält alles, was Sie für den Test der Integration und den Go-live in der Produktion benötigen.

Play