> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.wuzzlo.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.wuzzlo.com/_mcp/server.

# Create a Wuzzlo game session

POST /api/operator/login
Content-Type: application/json

Operator to Wuzzlo. Create a player game session and receive the game URL. Sign the exact JSON body with the operator private key. Required fields are operatorId, userId, username, and gameId. Use gameId 9000 to open the lobby. X-Request-Id is optional; Wuzzlo generates one when omitted.

Reference: https://docs.wuzzlo.com/wuzzlo/operator-to-wuzzlo/create-a-wuzzlo-game-session

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: collection
  version: 1.0.0
paths:
  /api/operator/login:
    post:
      operationId: createAWuzzloGameSession
      summary: Create a Wuzzlo game session
      description: >-
        Operator to Wuzzlo. Create a player game session and receive the game
        URL. Sign the exact JSON body with the operator private key. Required
        fields are operatorId, userId, username, and gameId. Use gameId 9000 to
        open the lobby. X-Request-Id is optional; Wuzzlo generates one when
        omitted.
      tags:
        - operatorToWuzzlo
      parameters:
        - name: Signature
          in: header
          description: >-
            Operator-to-Wuzzlo: Base64 RSA-SHA256 PKCS#1 v1.5 signature of the
            exact UTF-8 JSON body, created with the operator private key.
          required: true
          schema:
            type: string
        - name: X-Request-Id
          in: header
          description: >-
            Optional request correlation id for operator login. If omitted,
            GameService generates one internally.
          required: false
          schema:
            type: string
      responses:
        '200':
          description: Business success or business error encoded in the response body
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GameLaunchResponse'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/OperatorLoginRequest'
components:
  schemas:
    OperatorLoginRequest:
      type: object
      properties:
        operatorId:
          type: string
        userId:
          type: string
        username:
          type: string
        gameId:
          type: string
        currency:
          type: string
        clientIp:
          type: string
        platformId:
          type: string
        redirectUrl:
          type: string
      required:
        - operatorId
        - userId
        - username
        - gameId
      title: OperatorLoginRequest
    GameLaunchResponse:
      type: object
      properties:
        requestId:
          type: string
        gameUrl:
          type: string
        status:
          type: integer
        errorDescription:
          type: string
        expiresAtUtc:
          type:
            - string
            - 'null'
          format: date-time
      required:
        - requestId
        - status
        - errorDescription
      title: GameLaunchResponse
  securitySchemes:
    OperatorSignature:
      type: apiKey
      in: header
      name: Signature
      description: >-
        Operator-to-Wuzzlo: Base64 RSA-SHA256 PKCS#1 v1.5 signature of the exact
        UTF-8 JSON body, created with the operator private key.

```

## Examples

### Launch success



**Request**

```json
undefined
```

**Response**

```json
{
  "requestId": "req-operator-login-001",
  "status": 0,
  "errorDescription": "Completed Successfully",
  "gameUrl": "https://test.wuzzlo.com/tesla/84d4db15195b4fe6b8316a6f5dfd5731/9001",
  "expiresAtUtc": "2026-07-14T12:00:00Z"
}
```

**SDK Code**

```python Launch success
import requests

url = "https://api.example.com/api/operator/login"

headers = {
    "Signature": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript Launch success
const url = 'https://api.example.com/api/operator/login';
const options = {
  method: 'POST',
  headers: {Signature: '<apiKey>', 'Content-Type': 'application/json'},
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Launch success
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/operator/login"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Signature", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Launch success
require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/operator/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Signature"] = '<apiKey>'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java Launch success
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/api/operator/login")
  .header("Signature", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Launch success
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/api/operator/login', [
  'headers' => [
    'Content-Type' => 'application/json',
    'Signature' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Launch success
using RestSharp;

var client = new RestClient("https://api.example.com/api/operator/login");
var request = new RestRequest(Method.POST);
request.AddHeader("Signature", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Launch success
import Foundation

let headers = [
  "Signature": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/api/operator/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Lobby launch success



**Request**

```json
undefined
```

**Response**

```json
{
  "requestId": "req-operator-login-lobby-001",
  "status": 0,
  "errorDescription": "Completed Successfully",
  "gameUrl": "https://test.wuzzlo.com/tesla/84d4db15195b4fe6b8316a6f5dfd5731",
  "expiresAtUtc": "2026-07-14T12:00:00Z"
}
```

**SDK Code**

```python Lobby launch success
import requests

url = "https://api.example.com/api/operator/login"

headers = {
    "Signature": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript Lobby launch success
const url = 'https://api.example.com/api/operator/login';
const options = {
  method: 'POST',
  headers: {Signature: '<apiKey>', 'Content-Type': 'application/json'},
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Lobby launch success
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/operator/login"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Signature", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Lobby launch success
require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/operator/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Signature"] = '<apiKey>'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java Lobby launch success
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/api/operator/login")
  .header("Signature", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php Lobby launch success
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/api/operator/login', [
  'headers' => [
    'Content-Type' => 'application/json',
    'Signature' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Lobby launch success
using RestSharp;

var client = new RestClient("https://api.example.com/api/operator/login");
var request = new RestRequest(Method.POST);
request.AddHeader("Signature", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift Lobby launch success
import Foundation

let headers = [
  "Signature": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/api/operator/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### OperatorId invalid



**Request**

```json
undefined
```

**Response**

```json
{
  "requestId": "req-operator-login-invalid-operator",
  "status": 3,
  "errorDescription": "OperatorId Invalid"
}
```

**SDK Code**

```python OperatorId invalid
import requests

url = "https://api.example.com/api/operator/login"

headers = {
    "Signature": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript OperatorId invalid
const url = 'https://api.example.com/api/operator/login';
const options = {
  method: 'POST',
  headers: {Signature: '<apiKey>', 'Content-Type': 'application/json'},
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go OperatorId invalid
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/operator/login"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Signature", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby OperatorId invalid
require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/operator/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Signature"] = '<apiKey>'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java OperatorId invalid
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/api/operator/login")
  .header("Signature", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php OperatorId invalid
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/api/operator/login', [
  'headers' => [
    'Content-Type' => 'application/json',
    'Signature' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp OperatorId invalid
using RestSharp;

var client = new RestClient("https://api.example.com/api/operator/login");
var request = new RestRequest(Method.POST);
request.AddHeader("Signature", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift OperatorId invalid
import Foundation

let headers = [
  "Signature": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/api/operator/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### GameId invalid



**Request**

```json
undefined
```

**Response**

```json
{
  "requestId": "req-operator-login-invalid-game",
  "status": 4,
  "errorDescription": "GameId Invalid"
}
```

**SDK Code**

```python GameId invalid
import requests

url = "https://api.example.com/api/operator/login"

headers = {
    "Signature": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, headers=headers)

print(response.json())
```

```javascript GameId invalid
const url = 'https://api.example.com/api/operator/login';
const options = {
  method: 'POST',
  headers: {Signature: '<apiKey>', 'Content-Type': 'application/json'},
  body: undefined
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go GameId invalid
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/operator/login"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("Signature", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby GameId invalid
require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/operator/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Signature"] = '<apiKey>'
request["Content-Type"] = 'application/json'

response = http.request(request)
puts response.read_body
```

```java GameId invalid
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/api/operator/login")
  .header("Signature", "<apiKey>")
  .header("Content-Type", "application/json")
  .asString();
```

```php GameId invalid
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/api/operator/login', [
  'headers' => [
    'Content-Type' => 'application/json',
    'Signature' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp GameId invalid
using RestSharp;

var client = new RestClient("https://api.example.com/api/operator/login");
var request = new RestRequest(Method.POST);
request.AddHeader("Signature", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
IRestResponse response = client.Execute(request);
```

```swift GameId invalid
import Foundation

let headers = [
  "Signature": "<apiKey>",
  "Content-Type": "application/json"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/api/operator/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Launch a specific game



**Request**

```json
{
  "operatorId": "tesla",
  "userId": "1001",
  "username": "Player 1001",
  "gameId": "9001",
  "currency": "INR",
  "clientIp": "127.0.0.1",
  "platformId": "desktop",
  "redirectUrl": "https://test.wuzzlo.com/lobby"
}
```

**Response**

```json
{
  "requestId": "req-operator-login-001",
  "status": 0,
  "errorDescription": "Completed Successfully",
  "gameUrl": "https://test.wuzzlo.com/tesla/84d4db15195b4fe6b8316a6f5dfd5731/9001",
  "expiresAtUtc": "2026-07-14T12:00:00Z"
}
```

**SDK Code**

```python Launch a specific game
import requests

url = "https://api.example.com/api/operator/login"

payload = {
    "operatorId": "tesla",
    "userId": "1001",
    "username": "Player 1001",
    "gameId": "9001",
    "currency": "INR",
    "clientIp": "127.0.0.1",
    "platformId": "desktop",
    "redirectUrl": "https://test.wuzzlo.com/lobby"
}
headers = {
    "Signature": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Launch a specific game
const url = 'https://api.example.com/api/operator/login';
const options = {
  method: 'POST',
  headers: {Signature: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"operatorId":"tesla","userId":"1001","username":"Player 1001","gameId":"9001","currency":"INR","clientIp":"127.0.0.1","platformId":"desktop","redirectUrl":"https://test.wuzzlo.com/lobby"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Launch a specific game
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/operator/login"

	payload := strings.NewReader("{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"1001\",\n  \"username\": \"Player 1001\",\n  \"gameId\": \"9001\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"https://test.wuzzlo.com/lobby\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Signature", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Launch a specific game
require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/operator/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Signature"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"1001\",\n  \"username\": \"Player 1001\",\n  \"gameId\": \"9001\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"https://test.wuzzlo.com/lobby\"\n}"

response = http.request(request)
puts response.read_body
```

```java Launch a specific game
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/api/operator/login")
  .header("Signature", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"1001\",\n  \"username\": \"Player 1001\",\n  \"gameId\": \"9001\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"https://test.wuzzlo.com/lobby\"\n}")
  .asString();
```

```php Launch a specific game
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/api/operator/login', [
  'body' => '{
  "operatorId": "tesla",
  "userId": "1001",
  "username": "Player 1001",
  "gameId": "9001",
  "currency": "INR",
  "clientIp": "127.0.0.1",
  "platformId": "desktop",
  "redirectUrl": "https://test.wuzzlo.com/lobby"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'Signature' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Launch a specific game
using RestSharp;

var client = new RestClient("https://api.example.com/api/operator/login");
var request = new RestRequest(Method.POST);
request.AddHeader("Signature", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"1001\",\n  \"username\": \"Player 1001\",\n  \"gameId\": \"9001\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"https://test.wuzzlo.com/lobby\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Launch a specific game
import Foundation

let headers = [
  "Signature": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "operatorId": "tesla",
  "userId": "1001",
  "username": "Player 1001",
  "gameId": "9001",
  "currency": "INR",
  "clientIp": "127.0.0.1",
  "platformId": "desktop",
  "redirectUrl": "https://test.wuzzlo.com/lobby"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/api/operator/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Launch the lobby sentinel game



**Request**

```json
{
  "operatorId": "tesla",
  "userId": "3",
  "username": "user1",
  "gameId": "9000",
  "currency": "INR",
  "clientIp": "127.0.0.1",
  "platformId": "desktop",
  "redirectUrl": "test.wuzzlo.com/lobby"
}
```

**Response**

```json
{
  "requestId": "req-operator-login-001",
  "status": 0,
  "errorDescription": "Completed Successfully",
  "gameUrl": "https://test.wuzzlo.com/tesla/84d4db15195b4fe6b8316a6f5dfd5731/9001",
  "expiresAtUtc": "2026-07-14T12:00:00Z"
}
```

**SDK Code**

```python Launch the lobby sentinel game
import requests

url = "https://api.example.com/api/operator/login"

payload = {
    "operatorId": "tesla",
    "userId": "3",
    "username": "user1",
    "gameId": "9000",
    "currency": "INR",
    "clientIp": "127.0.0.1",
    "platformId": "desktop",
    "redirectUrl": "test.wuzzlo.com/lobby"
}
headers = {
    "Signature": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Launch the lobby sentinel game
const url = 'https://api.example.com/api/operator/login';
const options = {
  method: 'POST',
  headers: {Signature: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"operatorId":"tesla","userId":"3","username":"user1","gameId":"9000","currency":"INR","clientIp":"127.0.0.1","platformId":"desktop","redirectUrl":"test.wuzzlo.com/lobby"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Launch the lobby sentinel game
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/operator/login"

	payload := strings.NewReader("{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"3\",\n  \"username\": \"user1\",\n  \"gameId\": \"9000\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"test.wuzzlo.com/lobby\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Signature", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Launch the lobby sentinel game
require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/operator/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Signature"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"3\",\n  \"username\": \"user1\",\n  \"gameId\": \"9000\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"test.wuzzlo.com/lobby\"\n}"

response = http.request(request)
puts response.read_body
```

```java Launch the lobby sentinel game
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.example.com/api/operator/login")
  .header("Signature", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"3\",\n  \"username\": \"user1\",\n  \"gameId\": \"9000\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"test.wuzzlo.com/lobby\"\n}")
  .asString();
```

```php Launch the lobby sentinel game
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.example.com/api/operator/login', [
  'body' => '{
  "operatorId": "tesla",
  "userId": "3",
  "username": "user1",
  "gameId": "9000",
  "currency": "INR",
  "clientIp": "127.0.0.1",
  "platformId": "desktop",
  "redirectUrl": "test.wuzzlo.com/lobby"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'Signature' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Launch the lobby sentinel game
using RestSharp;

var client = new RestClient("https://api.example.com/api/operator/login");
var request = new RestRequest(Method.POST);
request.AddHeader("Signature", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"operatorId\": \"tesla\",\n  \"userId\": \"3\",\n  \"username\": \"user1\",\n  \"gameId\": \"9000\",\n  \"currency\": \"INR\",\n  \"clientIp\": \"127.0.0.1\",\n  \"platformId\": \"desktop\",\n  \"redirectUrl\": \"test.wuzzlo.com/lobby\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Launch the lobby sentinel game
import Foundation

let headers = [
  "Signature": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "operatorId": "tesla",
  "userId": "3",
  "username": "user1",
  "gameId": "9000",
  "currency": "INR",
  "clientIp": "127.0.0.1",
  "platformId": "desktop",
  "redirectUrl": "test.wuzzlo.com/lobby"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/api/operator/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```