Build arcade games that ship with identity, scores, profiles, progression, and saves.

<!-- index.html -->
<script src="https://seariching.com/sdk/portal-sdk.v1.js"></script>
<script type="module" src="./game.js"></script>

const sea = await window.SeaGames.init();

const user = await sea.getUser();
console.log(user?.guest ? "Guest player" : `Signed in as ${user?.name}`);

const result = await sea.submitScore("high-score", finalScore, {
  level,
  durationMs,
});

const leaderboard = await sea.getLeaderboard("high-score", { limit: 10 });

const sea = await window.SeaGames.init();

await sea.save("slot-1", {
  inventory,
  checkpoint,
  settings,
});

const save = await sea.load("slot-1");

const sea = await window.SeaGames.init();

const profile = await sea.getProfile();
await sea.updateProfile({ name: "CAPTAIN PIXEL" });

const rival = await sea.getProfileById("user_123");

const sea = await window.SeaGames.init();

if (sea.capabilities.includes("progression")) {
  const result = await sea.submitMatchResult({
    idempotencyKey: crypto.randomUUID(),
    mode: "league",
    stats: {
      won: true,
      linesCleared: 42,
      quads: 3,
    },
    ranked: {
      won: true,
      opponentTr: 12500,
    },
  });

  console.log(result.xpGained, result.trDelta);
}

const sea = await window.SeaGames.init();

const unsubscribePause = sea.on("pause", () => {
  game.pause();
});

const unsubscribeResume = sea.on("resume", () => {
  game.resume();
});

npm install @seariching/sdk

import type { SeaGamesClient } from "@seariching/sdk/portal";
import { createSeaAnalytics } from "@seariching/sdk/analytics";
import { createSeaEntitlements } from "@seariching/sdk/entitlements";
import { createSeaGameOverrides } from "@seariching/sdk/game-overrides";
import { createSeaPlayerData } from "@seariching/sdk/player-data";
import { createSeaRemoteConfig } from "@seariching/sdk/remote-config";
import { createSeaCloudSaves } from "@seariching/sdk/saves";
import { verifyWebhookSignature } from "@seariching/sdk/webhooks";
import { createRealtime } from "@seariching/sdk/realtime";

declare global {
  interface Window {
    SeaGames: {
      init(options?: { parentOrigin?: string }): Promise<SeaGamesClient>;
    };
  }
}

import { createSeaRemoteConfig } from "@seariching/sdk/remote-config";

const remoteConfig = createSeaRemoteConfig({
  supabase,
  gameSlug: "my-rpg",
  getOwnerId: () => owner.id,
});

const xpMultiplier = await remoteConfig.get("xp.multiplier", 1, {
  segments: ["event_weekend"],
});

const published = await remoteConfig.publish("xp.multiplier", 1.5, {
  segment: "event_weekend",
  priority: 20,
});

await remoteConfig.deactivate(published.key, {
  segment: published.segment,
});

import { createSeaGameOverrides } from "@seariching/sdk/game-overrides";

const gameOverrides = createSeaGameOverrides({
  supabase,
  gameSlug: "my-rpg",
  getOwnerId: () => owner.id,
  getRolloutId: () => player.id,
});

const spawnTable = await gameOverrides.get("combat.spawn_table", {
  tier: "default",
}, {
  segments: ["ranked"],
});

const published = await gameOverrides.publish("combat.spawn_table", {
  tier: "hard",
}, {
  segment: "ranked",
  rolloutPercentage: 50,
  priority: 20,
});

await gameOverrides.deactivate(published.key, {
  segment: published.segment,
});

import { createSeaAnalytics } from "@seariching/sdk/analytics";

const analytics = createSeaAnalytics({
  supabase,
  gameSlug: "my-fps",
  getUserId: () => player.id,
  getOwnerId: () => owner.id,
});

await analytics.track({
  name: "match.completed",
  payload: { won: true, mode: "ranked" },
  sessionId: "session-1",
});

await analytics.reportError({
  name: "render.failed",
  message: "Renderer failed",
  stack: error.stack,
  sessionId: "session-1",
});

const matches = await analytics.listEvents({
  name: "match.completed",
  limit: 50,
});
const crashes = await analytics.listCrashReports({ limit: 25 });

import { createSeaStats } from "@seariching/sdk/stats";

const stats = createSeaStats({
  supabase,
  gameSlug: "my-fps",
  getUserId: () => player.id,
  getOwnerId: () => owner.id,
});

const definitions = await stats.listDefinitions();
await stats.increment("kills", 1);
const kills = await stats.get("kills");
const myStats = await stats.list();

await stats.setForPlayer("player_2", "mmr", 1200);
await stats.incrementForPlayer("player_2", "ranked_wins", 1);

import { createSeaAchievements } from "@seariching/sdk/achievements";

const achievements = createSeaAchievements({
  supabase,
  gameSlug: "my-arcade",
  getUserId: () => player.id,
  getOwnerId: () => owner.id,
});

const visible = await achievements.listDefinitions();
const hiddenForOwner = await achievements.listDefinitions({
  includeHidden: true,
});
const unlocked = await achievements.list();

await achievements.progress("clear_100_lines", 4);
await achievements.unlock("first_win");
await achievements.unlockForPlayer("player_2", "secret_boss");

import { createSeaEconomy } from "@seariching/sdk/economy";

const economy = createSeaEconomy({
  supabase,
  gameSlug: "my-rpg",
  getUserId: () => player.id,
  getOwnerId: () => owner.id,
});

const currencies = await economy.listCurrencies();
const itemDefinitions = await economy.listItemDefinitions();
const coin = await economy.getBalance("coin");
const inventory = await economy.listInventory();

await economy.grantCurrency("coin", 100, {
  idempotencyKey: "quest-1-reward",
});
await economy.grantItem("iron_sword", 1, {
  idempotencyKey: "quest-1-sword",
});
await economy.spendCurrency("coin", 25, {
  idempotencyKey: "shop-buy-1",
});

await economy.grantCurrencyForPlayer("player_2", "coin", 100, {
  idempotencyKey: "server-quest-player-2",
});
await economy.grantItemForPlayer("player_2", "event_badge", 1, {
  idempotencyKey: "event-badge-player-2",
});

import { createSeaEntitlements } from "@seariching/sdk/entitlements";

const entitlements = createSeaEntitlements({
  supabase,
  gameSlug: "my-rpg",
  getUserId: () => player.id,
  getOwnerId: () => owner.id,
});

const definitions = await entitlements.listDefinitions();
const ownsBattlePass = await entitlements.has("battle_pass");
const activeUnlocks = await entitlements.list();

await entitlements.grant("premium_skin", {
  idempotencyKey: "purchase-123",
});
await entitlements.revoke("premium_skin", {
  idempotencyKey: "refund-123",
});

const playerPasses = await entitlements.listForPlayer("player_2");
await entitlements.grantForPlayer("player_2", "battle_pass", {
  idempotencyKey: "admin-grant-player-2",
});

import { createSeaCloudSaves } from "@seariching/sdk/saves";

const saves = createSeaCloudSaves({
  supabase,
  gameSlug: "my-rpg",
  getUserId: () => player.id,
});

const slots = await saves.list();
const loaded = await saves.load("slot1");

const saved = await saves.save("slot1", {
  hp: 20,
  quest: "cavern",
}, {
  expectedVersion: loaded?.version ?? 0,
});

await saves.delete("slot1", {
  expectedVersion: saved.version,
});

console.log(slots.map((slot) => slot.version));

import { createSeaPlayerData } from "@seariching/sdk/player-data";

const playerData = createSeaPlayerData({
  supabase,
  gameSlug: "my-rpg",
  getUserId: () => player.id,
  getOwnerId: () => owner.id,
});

const loadout = await playerData.get("loadout");
const records = await playerData.list();

const updated = await playerData.set("quest.main", {
  step: 3,
}, {
  expectedVersion: loadout?.version ?? 0,
});

const playerQuest = await playerData.getForPlayer("player_2", "quest.main");
await playerData.setForPlayer("player_2", "quest.main", {
  step: 4,
}, {
  expectedVersion: playerQuest?.version ?? 0,
});

await playerData.delete("quest.main", {
  expectedVersion: updated.version,
});

import { createSeaAdminDebug } from "@seariching/sdk/admin-debug";

const adminDebug = createSeaAdminDebug({
  supabase,
  gameSlug: "my-mmo",
  getOwnerId: () => owner.id,
});

const snapshot = await adminDebug.getPlayerSnapshot("player_2");

console.log(snapshot.profile?.level);
console.log(snapshot.wallets, snapshot.inventory);
console.log(snapshot.playerData, snapshot.saves);
console.log(snapshot.moderation);

import { createSeaAuditLogs } from "@seariching/sdk/audit-logs";

const auditLogs = createSeaAuditLogs({
  supabase,
  gameSlug: "my-mmo",
  getActorId: () => owner.id,
});

await auditLogs.record({
  action: "moderation.ban",
  targetType: "player",
  targetId: "player_2",
  metadata: { reason: "abuse" },
});

const recentModeration = await auditLogs.list({
  action: "moderation.ban",
  actorId: owner.id,
  targetType: "player",
  createdAfter: "2026-07-01T00:00:00Z",
  limit: 50,
});

import { createMatchmaking } from "@seariching/sdk/matchmaking";

const matchmaking = createMatchmaking({
  supabase,
  gameSlug: "my-fps",
});

const room = await matchmaking.createRoom({
  name: "ranked squad",
  maxPlayers: 4,
  visibility: "private",
  idempotencyKey: matchSetupId,
});

const publicRooms = await matchmaking.listRooms();
await matchmaking.joinRoom(room.code);
await matchmaking.leaveRoom(room.code);
await matchmaking.closeRoom(room.code);

import { createSeaChat } from "@seariching/sdk/chat";

const chat = createSeaChat({
  supabase,
  gameSlug: "my-mmo",
  getUserId: () => player.id,
  getOwnerId: () => owner.id,
});

const channel = await chat.createChannel("public", {
  name: "global",
});
await chat.sendMessage(channel.id, "hello world");

await chat.reportPlayer("player_2", "abuse", {
  details: "abusive chat",
});

const reports = await chat.listModerationReports({
  status: "open",
  limit: 50,
});
await chat.updateModerationReportStatus(reports[0].id, "actioned");

if (reports[0].messageId) {
  await chat.deleteMessageAsOwner(reports[0].messageId);
}

import { createSeaSocial } from "@seariching/sdk/social";

const social = createSeaSocial({
  supabase,
  gameSlug: "my-mmo",
  getUserId: () => player.id,
});

await social.sendFriendRequest("player_2");
const friends = await social.listFriends();
const requests = await social.listFriendRequests();

await social.sendInvite("player_2", {
  kind: "lobby",
  context: { roomCode: "ABCD12" },
});
const invites = await social.listInvites();

await social.blockPlayer("abusive_player");
const blocks = await social.listBlocks();

await social.updatePresence({
  status: "online",
  activity: "ranked_lobby",
  metadata: { partySize: 3 },
});
const friendPresence = await social.getPresence("player_2");

import { createSeaGuilds } from "@seariching/sdk/guilds";

const guilds = createSeaGuilds({
  supabase,
  gameSlug: "my-mmo",
  getUserId: () => player.id,
});

const guild = await guilds.create("sea-raiders", "Sea Raiders", {
  description: "Ranked crew",
  openJoin: true,
  metadata: { region: "na" },
});

const publicGuilds = await guilds.listGuilds();
const roster = await guilds.listMembers(guild.id);

await guilds.sendInvite(guild.id, "player_2");
const invites = await guilds.listInvites();
await guilds.acceptInvite(invites[0].id);
await guilds.joinOpenGuild(guild.id);