Pre-release Sign-up is not open yet. Platform verification and the signed client download are in development. See what is available
Guide · available

Quickstart

From a new account to a player admitted by your game server through a protected session. The console and server steps work today; the client SDK builds from source and is not yet published as a signed download.

1. Create an account and organization

Sign up, confirm your email address using the link we send, then sign in. The console asks for an organization name; you become its owner. An organization holds your games, team and subscription, and you can belong to several.

2. Register a game

Open Games and register your title. Each game gets:

  • a game ID (game_...), a public identifier you will embed in client builds;
  • a protection tier: Core, Advanced or Elite. The tier decides which features the game can use;
  • feature switches: the game's page lists every feature of every tier. Within the game's tier you switch each one on or off, for example requiring TPM attestation but not IOMMU protection. Everything starts on. The server applies the switches to every session; a client cannot change them;
  • a protection policy, starting at version 1 with that tier as its profile, and an enforcement mode: Enforce, or Monitor while the game is in development;
  • a status: Development or Live. Taking a game live needs an active subscription that covers its tier.

Every policy change is saved as a new numbered version and recorded in the audit log.

3. Create a server key

On the game page, create a server key and name it after where it will be used. The secret starts with obs_sk_ and is shown once: store it in your secret manager, never in a client build or a repository. We keep only a hash.

  • Rotate issues a replacement and keeps the old key valid for 24 hours so you can redeploy without downtime.
  • Revoke disables a key immediately.

4. Call the API

curl https://obscurity.ac/api/v1/game \
  -H "Authorization: Bearer obs_sk_your_key_here"

The response describes the game the key belongs to and its active policy:

{
  "game": {"id": "game_...", "name": "Example", "slug": "example", "engine": "custom", "status": "development"},
  "organization": {"id": "org_...", "name": "Example Studio"},
  "policy": {
    "version": 1,
    "schema": 2,
    "profile": "advanced",
    "features": {"build_check": true, "tpm20": true, "secure_boot": true, "hvci": true, "iommu": true},
    "platform_requirements": {"tpm20": "required", "secure_boot": "required", "hvci": "required", "iommu": "required"},
    "boot_component": "not_required",
    "enforcement": "enforce"
  },
  "entitlement": {"access": "active", "tier": "advanced", "covers_policy": true},
  "credential": {"id": "key_...", "name": "production game servers", "expires_at": null}
}

A key identifies exactly one game. There is no parameter that selects a different game or organization.

5. Open a session from the game client

Link the client SDK into your game and give it the game ID. It holds no secret.

#include <obscurity/obscurity.h>

obs_config config = {0};
config.struct_size = sizeof(config);
config.game_id = "game_...";
config.api_base = "https://obscurity.ac";

obs_client* obscurity = NULL;
obs_create(&config, &obscurity);

obs_decision decision = {0};
decision.struct_size = sizeof(decision);
if (obs_start_session(obscurity, &decision) != OBS_OK) {
    /* decision.category says what kind of result this is and decision.message
       is written for the player. None of the outcomes is an accusation. */
}

char token[128];
obs_join_token(obscurity, token, sizeof(token));
/* send `token` to your game server with the player's login */

While a game is in development and has no subscription it may run up to 10 sessions at once, so you can integrate before you pay.

6. Verify the player on your game server

The client saying it has a session proves nothing. Your game server asks Obscurity, with its server key:

curl https://obscurity.ac/api/v1/sessions/verify \
  -H "Authorization: Bearer obs_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"join_token": "obs_jt_...", "player_id": "your-account-id"}'

Admit the player only when the answer is "valid": true. Each token works once and for one minute. See the server API reference.

7. Register your released builds

On the game page, add the SHA-256 of each game executable you ship. From then on a client reporting any other hash is refused in Enforce mode and flagged in Monitor mode. This stops stale and casually modified copies. It is not proof that the running game is unmodified, because the hash is reported by the player's PC.

8. Invite your team

Under Team, invite colleagues by email and choose a role. Invitations expire after 7 days and count toward your plan's seats while pending.

What comes next

Report rejected actions from your game server and review what the detectors find: see detections, review and restrictions. Advanced games can additionally require verified platform security: see platform verification, which is built but not released. The integration model shows how the pieces fit together.