Getting Started

#!/bin/bash
API_KEY="op_live_..."
SECRET_KEY="sk_live_..."

BODY='{"externalPlayerId":"player_123","username":"João Silva"}'
TIMESTAMP=$(date +%s%3N)   # milissegundos (Linux com GNU date)
DATA="${API_KEY}${TIMESTAMP}${BODY}"
SIGNATURE=$(echo -n "$DATA" | openssl dgst -sha256 -hmac "$SECRET_KEY" | cut -d' ' -f2)

curl -s -X POST "https://mines.fourplay.studio/api/operator/session/create" \
  -H "Content-Type: application/json" \
  -H "X-Operator-Id: $API_KEY" \
  -H "X-Timestamp: $TIMESTAMP" \
  -H "X-Signature: $SIGNATURE" \
  -d "$BODY"

const crypto = require('crypto');

const API_KEY    = process.env.FOURPLAY_API_KEY;
const SECRET_KEY = process.env.FOURPLAY_SECRET_KEY;

async function createSession(externalPlayerId, username) {
  const body      = JSON.stringify({ externalPlayerId, ...(username && { username }) });
  const timestamp = Date.now().toString();
  const data      = API_KEY + timestamp + body;
  const signature = crypto.createHmac('sha256', SECRET_KEY).update(data).digest('hex');

  const res = await fetch('https://mines.fourplay.studio/api/operator/session/create', {
    method: 'POST',
    headers: {
      'Content-Type':  'application/json',
      'X-Operator-Id': API_KEY,
      'X-Timestamp':   timestamp,
      'X-Signature':   signature,
    },
    body,
  });

  if (!res.ok) {
    const err = await res.json();
    throw new Error(err.message ?? 'Session creation failed');
  }

  return res.json(); // { token: "eyJ..." }
}

const { token } = await createSession('player_123', 'João Silva');
const gameUrl = `https://mines.fourplay.studio/?token=${token}`;
console.log('Abrir jogo em:', gameUrl);

<?php
function createSession(string $externalPlayerId, ?string $username = null): array {
    $apiKey    = getenv('FOURPLAY_API_KEY');
    $secretKey = getenv('FOURPLAY_SECRET_KEY');

    $payload  = ['externalPlayerId' => $externalPlayerId];
    if ($username) $payload['username'] = $username;
    $body      = json_encode($payload);

    $timestamp = (string)(int)(microtime(true) * 1000);
    $data      = $apiKey . $timestamp . $body;
    $signature = hash_hmac('sha256', $data, $secretKey);

    $ch = curl_init('https://mines.fourplay.studio/api/operator/session/create');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => $body,
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            "X-Operator-Id: {$apiKey}",
            "X-Timestamp: {$timestamp}",
            "X-Signature: {$signature}",
        ],
    ]);
    $raw      = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    $result = json_decode($raw, true);
    if ($httpCode !== 200) {
        throw new RuntimeException($result['message'] ?? 'Session creation failed');
    }
    return $result; // ['token' => 'eyJ...']
}

$result  = createSession('player_123', 'João Silva');
$gameUrl = "https://mines.fourplay.studio/?token={$result['token']}";
header("Location: $gameUrl");

import hmac, hashlib, time, json, os
import urllib.request

API_KEY    = os.environ['FOURPLAY_API_KEY']
SECRET_KEY = os.environ['FOURPLAY_SECRET_KEY']

def create_session(external_player_id: str, username: str | None = None) -> dict:
    payload = {'externalPlayerId': external_player_id}
    if username:
        payload['username'] = username
    body      = json.dumps(payload, separators=(',', ':'))
    timestamp = str(int(time.time() * 1000))
    data      = API_KEY + timestamp + body
    signature = hmac.new(SECRET_KEY.encode(), data.encode(), hashlib.sha256).hexdigest()

    req = urllib.request.Request(
        'https://mines.fourplay.studio/api/operator/session/create',
        data=body.encode(),
        headers={
            'Content-Type':  'application/json',
            'X-Operator-Id': API_KEY,
            'X-Timestamp':   timestamp,
            'X-Signature':   signature,
        },
        method='POST',
    )
    with urllib.request.urlopen(req) as resp:
        return json.loads(resp.read())

result   = create_session('player_123', 'João Silva')
game_url = f"https://mines.fourplay.studio/?token={result['token']}"
print('Abrir jogo em:', game_url)

using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

var apiKey    = Environment.GetEnvironmentVariable("FOURPLAY_API_KEY")!;
var secretKey = Environment.GetEnvironmentVariable("FOURPLAY_SECRET_KEY")!;
using var http = new HttpClient();

async Task<string> CreateSession(string externalPlayerId, string? username = null)
{
    var payload   = username != null
        ? new { externalPlayerId, username }
        : (object)new { externalPlayerId };
    var body      = JsonSerializer.Serialize(payload);
    var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds().ToString();
    var data      = apiKey + timestamp + body;
    using var mac = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
    var sig       = Convert.ToHexString(mac.ComputeHash(Encoding.UTF8.GetBytes(data))).ToLower();

    var req = new HttpRequestMessage(HttpMethod.Post,
        "https://mines.fourplay.studio/api/operator/session/create")
    {
        Content = new StringContent(body, Encoding.UTF8, "application/json")
    };
    req.Headers.Add("X-Operator-Id", apiKey);
    req.Headers.Add("X-Timestamp",   timestamp);
    req.Headers.Add("X-Signature",   sig);

    var resp   = await http.SendAsync(req);
    var json   = await resp.Content.ReadAsStringAsync();
    var result = JsonSerializer.Deserialize<JsonElement>(json);
    return result.GetProperty("token").GetString()!;
}

var token   = await CreateSession("player_123", "João Silva");
var gameUrl = $"https://mines.fourplay.studio/?token={token}";
Console.WriteLine("Abrir jogo em: " + gameUrl);