Guia de Integração de Jogos para PC e Console

Guia completo para implementar a atribuição de jogos para PC e Console com a Singular, permitindo medição e análise precisas de campanhas em plataformas de desktop e de jogos.

Visão Geral

Opções de Integração

A Singular oferece duas abordagens para a atribuição de jogos para PC e Console. Selecione o método que melhor se adequa aos seus requisitos de implementação e necessidades de atribuição.

Comparação de Fluxos de Atribuição

Fluxo de Singular Links para PC/Console:

1. Usuário Clica no Singular Link: O usuário clica no link de rastreamento Singular em uma campanha de marketing
2. Redirecionamento para a Página de Destino: O usuário é redirecionado para a página de destino ou loja (não requer Web SDK)
3. Download e Instalação: O usuário baixa e instala o jogo
4. Primeira Inicialização: O usuário inicia o jogo pela primeira vez
5. Report via S2S: O jogo reporta a sessão via API S2S
6. Atribuição Probabilística: A Singular associa a instalação do jogo ao clique no Singular Link com base no endereço IP

Fluxo de Web SDK + Match ID:

1. Usuário Clica no Link da Campanha: O usuário clica no anúncio ou link da campanha de marketing
2. Página de Destino com Web SDK: O usuário chega a uma página de destino com o Singular Web SDK implementado
3. Captura do Clique: O Web SDK captura os dados do clique e gera um Match ID
4. Autenticação do Usuário (Opcional): Se o usuário fizer login, o Match ID pode ser passado ao jogo para atribuição determinística
5. Download e Instalação: O usuário baixa e instala o jogo
6. Primeira Inicialização: O usuário inicia o jogo e, opcionalmente, recupera o Match ID
7. Report via S2S com Match ID: O jogo reporta a sessão via API S2S com ou sem o Match ID
8. Correspondência de Atribuição: A Singular realiza a correspondência determinística (se o Match ID for fornecido) ou probabilística (baseada em IP)

Integração Server-to-Server

Independentemente do método de atribuição escolhido, a implementação da integração da API S2S é obrigatória para toda atribuição de jogos para PC e Console.

Capacidades de Integração:

• Rastreamento de Sessões do Jogo: Reporte sessões e atividades de usuários em todas as inicializações do jogo
• Atribuição de Instalações: Atribua novas instalações do jogo a campanhas de marketing
• Análise de Eventos: Rastreie eventos in-game e interações de usuários para análise de funil
• Medição de Receita: Meça as compras in-game e o desempenho de monetização
• Suporte Multiplataforma: Rastreamento unificado em PC, Xbox, PlayStation, Nintendo e Meta Quest

Pré-requisitos

Antes de implementar a integração de PC e Console, certifique-se de que os seguintes requisitos sejam atendidos.

Recursos de Documentação

Referência completa da API e guias de implementação para a integração de PC e Console.

Método 1: Singular Links para PC/Console (Recomendado)

Abordagem de integração simplificada usando links de rastreamento Singular para atribuição probabilística sem exigir a implementação do Web SDK nas páginas de destino.

Visão Geral

Como Funciona

Os Singular Links para PC/Console permitem a atribuição capturando os dados do clique diretamente no link de rastreamento, eliminando a necessidade de implementar o Web SDK nas páginas de destino.

Principais Benefícios:

• Não Requer Web SDK: Redirecione os usuários para qualquer página de destino, incluindo lojas de terceiros (Steam, Epic, etc.)
• Integração Simplificada: Requer apenas a implementação da API S2S no lado do jogo
• Implantação Rápida: Crie e lance campanhas rapidamente sem modificações nas páginas de destino
• Destinos Flexíveis: Suporte a redirecionamento único para qualquer URL de destino

Método de Atribuição:

• Probabilística (baseada em IP): A Singular associa a instalação do jogo ao clique no Singular Link com base no endereço IP e nas características do dispositivo

Etapas de Implementação

Etapa 1: Pré-requisitos

Certifique-se de que os seguintes requisitos sejam atendidos antes de criar Singular Links para PC/Console.

Etapa 2: Criar o Singular Link para PC/Console

Crie Singular Links para PC/Console no dashboard da Singular para rastrear cliques de campanha e habilitar a atribuição.

Etapas de Configuração:

1. Acesse Manage Links: No dashboard da Singular, vá em Attribution → Manage Links
2. Selecione o App: Escolha um App que tenha app sites de PC/Console configurados
3. Crie um Novo Link: Clique no botão Create New Link
4. Selecione o Tipo de Plataforma: No campo Platform Tracking Type, selecione "PC/Console"
5. Configure o Alvo: Selecione um app site específico de PC/Console ou escolha a opção "Track all app sites under this app"
6. Defina a URL de Destino: Configure a URL de redirecionamento (página de destino, página da loja, etc.)
7. Configure as Definições de Atribuição: Defina as janelas de atribuição e os parâmetros de rastreamento conforme necessário
8. Gere o Link: Salve e gere o link de rastreamento Singular

Etapa 3: Implementar a Integração S2S

Implemente a integração da API Server-to-Server para reportar sessões e eventos do jogo. Consulte a seção Conceitos de Integração abaixo para obter os detalhes completos de implementação do S2S.

Implementação Necessária:

• Notificação de Sessão: Reporte as inicializações do jogo usando o Session Notification Endpoint
• Rastreamento de Eventos: Reporte eventos in-game e receita usando o Event Notification Endpoint
• Identificação de Dispositivo: Gere e persista um identificador único de dispositivo (SDID)

Etapa 4: Lançar Campanhas

Use os Singular Links para PC/Console gerados em campanhas de marketing para habilitar o rastreamento de atribuição.

Configuração da Campanha:

• Copie o Link de Rastreamento: Copie o Singular Link gerado em Manage Links
• Configure a Campanha: Use o Singular Link como URL de destino da campanha
• Lance a Campanha: Ative a campanha com o Singular Link
• Monitore a Atribuição: Visualize os dados de atribuição nos relatórios da Singular à medida que os usuários clicam nos links e iniciam o jogo

Correspondência de Atribuição

Como Funciona a Atribuição

Ao usar Singular Links para PC/Console, a Singular realiza a correspondência de atribuição probabilística com base no endereço IP e no tempo.

Processo de Atribuição:

1. Usuário Clica no Singular Link: Os dados do clique são capturados pela Singular, incluindo endereço IP e timestamp
2. Usuário Baixa o Jogo: O usuário prossegue para baixar e instalar o jogo
3. Inicialização do Jogo: O usuário inicia o jogo pela primeira vez
4. Report via S2S: O jogo reporta a sessão à Singular via API S2S, incluindo o endereço IP do usuário
5. Correspondência Probabilística: A Singular associa a instalação do jogo ao clique no Singular Link com base no endereço IP dentro da janela de atribuição
6. Atribuição Concluída: A instalação é atribuída à origem da campanha

Método 2: Web SDK + Match ID (Avançado)

Abordagem de integração avançada usando o Singular Web SDK em páginas de destino com Match ID opcional para atribuição determinística quando os usuários se autenticam.

Visão Geral

Quando Usar Este Método

Implemente a abordagem Web SDK + Match ID quando o seu caso de uso exigir capacidades de atribuição aprimoradas além da correspondência probabilística básica.

Casos de Uso:

• Web Attribution: Você precisa dos recursos de Web Attribution da Singular e de web analytics
• Atribuição Determinística: Os usuários se autenticam nas páginas de destino e você deseja a maior precisão de atribuição
• Rastreamento Entre Dispositivos: Os usuários podem baixar o jogo em um dispositivo diferente daquele da visita à página de destino
• Análise Avançada: Você precisa de métricas detalhadas de engajamento web antes da instalação do jogo

Métodos de Atribuição:

• Probabilística (baseada em IP): Correspondência automática com base no endereço IP (igual aos Singular Links para PC/Console)
• Determinística (Match ID): Correspondência precisa usando um identificador único passado da página de destino ao jogo quando o usuário se autentica

Etapas de Implementação

Etapa 1: Implementar o Web SDK

Implemente o Singular Web SDK nas páginas de destino de marketing para capturar os dados do clique e habilitar a atribuição.

Implementação do Web SDK:

• Siga o Guia do Web SDK: Visão Geral e Introdução ao Web SDK
• Configuração do Product ID: O Product ID do Web SDK deve corresponder ao identificador do jogo (parâmetro i ) usado na integração S2S
• Implantação na Página de Destino: Implante o Web SDK em todas as páginas de destino de marketing

Etapa 2: Implementar a Integração S2S

Implemente a integração da API Server-to-Server para reportar sessões e eventos do jogo. Consulte a seção Conceitos de Integração abaixo para obter os detalhes completos de implementação do S2S.

Implementação Necessária:

• Notificação de Sessão: Reporte as inicializações do jogo usando o Session Notification Endpoint
• Rastreamento de Eventos: Reporte eventos in-game e receita usando o Event Notification Endpoint
• Identificação de Dispositivo: Gere e persista um identificador único de dispositivo (SDID)

Etapa 3: Implementar o Match ID (Opcional)

Para atribuição determinística, implemente o Match ID para passar um identificador único da página de destino ao jogo quando os usuários se autenticam.

Implementação do Match ID:

• Recupere o Match ID: Use o método getMatchID() do Web SDK após a autenticação do usuário
• Passe ao Jogo: Implemente um mecanismo para passar o Match ID da web ao jogo (query parameter, API, etc.)
• Inclua na Primeira Sessão: Reporte o Match ID na primeira sessão do jogo via parâmetro match_id

Consulte a seção Implementação do Match ID abaixo para obter as etapas detalhadas de integração do Match ID.

Correspondência de Atribuição

Como Funciona a Atribuição

Ao usar o Web SDK, a Singular realiza a correspondência de atribuição usando métodos probabilísticos ou determinísticos, dependendo de o Match ID ser fornecido.

Atribuição Probabilística (Sem Match ID):

1. Usuário Clica na Campanha: O usuário clica no link da campanha de marketing
2. Visita à Página de Destino: O Web SDK captura os dados do clique, incluindo o endereço IP
3. Usuário Baixa o Jogo: O usuário baixa e instala o jogo
4. Inicialização do Jogo: O usuário inicia o jogo pela primeira vez
5. Report via S2S: O jogo reporta a sessão à Singular via API S2S
6. Correspondência por IP: A Singular associa a instalação do jogo ao clique web com base no endereço IP

Atribuição Determinística (Com Match ID):

1. Usuário Clica na Campanha: O usuário clica no link da campanha de marketing
2. Visita à Página de Destino: O Web SDK gera um Match ID único
3. Usuário se Autentica: O usuário faz login na página de destino
4. Match ID Recuperado: A implementação recupera o Match ID do Web SDK
5. Match ID Passado ao Jogo: O Match ID é passado ao jogo via query parameter, API ou outro mecanismo
6. Usuário Baixa o Jogo: O usuário baixa e instala o jogo
7. Inicialização do Jogo com Match ID: O usuário inicia o jogo e recupera o Match ID armazenado
8. Report via S2S com Match ID: O jogo reporta a primeira sessão incluindo o parâmetro match_id
9. Correspondência Determinística: A Singular associa a instalação do jogo ao clique web usando o Match ID para atribuição precisa

Conceitos de Integração

Conceitos e requisitos fundamentais para implementar a integração S2S de PC e Console com a Singular. Esses conceitos se aplicam a ambos os métodos de atribuição.

Autenticação

Todas as requisições à API S2S de PC e Console da Singular exigem autenticação por SDK key no parâmetro a . Para as mecânicas de autenticação compartilhadas (onde encontrar a sua SDK Key e como ela é passada), consulte Autenticação em Fundamentos de S2S .

Privacidade do Usuário

A Singular recomenda oferecer aos usuários finais a capacidade de dar opt in ou opt out do rastreamento. Para os parâmetros de privacidade compartilhados, incluindo data_sharing_options e Limit Data Sharing, consulte Parâmetros de privacidade em Fundamentos de S2S .

Plataformas Suportadas

Definição de Plataforma

A plataforma representa onde o usuário joga o jogo e deve ser passada no parâmetro p em todas as requisições da API S2S.

Valores de Plataforma Suportados:

• pc - Plataformas de computador pessoal
• xbox - Consoles de jogos Microsoft Xbox
• playstation - Consoles de jogos Sony PlayStation
• nintendo - Consoles de jogos Nintendo
• metaquest - Headsets de VR Meta Quest

Sistemas Operacionais e Lojas

Além da plataforma, especifique o sistema operacional/de jogo via parâmetro os e a loja de distribuição via parâmetro install_source .

Identificador do Jogo

Identificação da Aplicação

O identificador do jogo associa os eventos do jogo a um jogo específico e deve ser passado no parâmetro i em todas as requisições.

Requisitos do Identificador:

• Formato: Qualquer valor é suportado, mas a Singular recomenda a notação DNS reversa (por exemplo, com.singular.game )
• Consistência Entre Plataformas: O mesmo identificador do jogo deve ser usado para o mesmo jogo em todas as plataformas suportadas
• Alinhamento com o Web SDK (apenas Método 2): Se estiver usando o método Web SDK + Match ID, o identificador do jogo deve corresponder ao Product ID do Web SDK configurado nas páginas de destino para que a atribuição funcione

Exemplos de Configuração:

const config = {
  apiKey: 'YOUR_SDK_KEY',
  productId: 'com.singular.game',  // Must match S2S identifier
  // ... other config
};

p=pc&i=com.singular.game

p=xbox&i=com.singular.game

p=playstation&i=com.singular.game

Identificação de Dispositivo

Rastreamento de Instalações Únicas do Jogo

O identificador de instalação/dispositivo associa os eventos do jogo ao longo de múltiplas sessões da mesma instalação do jogo e deve ser passado no parâmetro sdid em todas as requisições.

Especificações do Identificador:

• Formato: Formato UUID Versão 4 recomendado
• Geração: Valor gerado pelo jogo/servidor na primeira inicialização do jogo (instalação)
• Persistência: Deve persistir durante toda a vida da instalação do jogo
• Unicidade: Cada instalação do jogo requer um identificador único

Exemplo: sdid=40009df0-d618-4d81-9da1-cbb3337b8dec

Implementação do Match ID

O Match ID habilita a atribuição determinística para campanhas web passando um identificador único do Web SDK para a instalação do jogo. Este recurso só está disponível ao usar o método de atribuição Web SDK + Match ID.

Como Funciona o Match ID:

1. O Web SDK Gera o Match ID: O Singular Web SDK cria um Match ID único quando o usuário visita a página de destino
2. Recupere o Match ID: Use os métodos do Web SDK para recuperar o Match ID da página de destino após a autenticação do usuário
3. Passe ao Jogo: A sua implementação passa o Match ID da página web ao jogo durante o processo de download/instalação (por exemplo, query parameter, deep link, cookie)
4. Reporte na Primeira Inicialização: O jogo inclui o Match ID na primeira notificação de sessão à Singular via parâmetro match_id
5. Correspondência Determinística: A Singular usa o Match ID para correspondência de atribuição precisa

Métodos de Match ID do Web SDK

Implementação Nativa

O Singular Web SDK fornece métodos nativos para recuperar, definir e limpar valores de Match ID nas páginas de destino.

Métodos Disponíveis:

Exemplos de Implementação

// Get the Singular-generated Match ID
const matchId = window.singularSdk.getMatchID();
console.log('Match ID:', matchId);

// Store Match ID for passing to game
localStorage.setItem('singular_match_id', matchId);

// Set your own Match ID value
const customMatchId = 'your-custom-match-id-123';
window.singularSdk.setMatchID(customMatchId);

console.log('Custom Match ID set:', customMatchId);

// Clear custom Match ID and revert to default
window.singularSdk.clearMatchID();

// Get the new default Match ID
const defaultMatchId = window.singularSdk.getMatchID();
console.log('Default Match ID restored:', defaultMatchId);

// Initialize Web SDK
const config = new SingularConfig(sdkKey, sdkSecret, productId)
  .withInitFinishedCallback(() => {
    console.log('Singular SDK initialized');
  });

singularSdk.init(config);

// Handle download button click
document.getElementById('download-button').addEventListener('click', function() {
  // Get Match ID before redirecting to download
  const matchId = window.singularSdk.getMatchID();

  // Pass Match ID to download page via query parameter
  const downloadUrl = `https://example.com/download?match_id=${matchId}`;

  // Redirect to download page
  window.location.href = downloadUrl;
});

Passando o Match ID ao Jogo

Estratégias de Implementação

Após recuperar o Match ID do Web SDK, implemente um mecanismo para passar o valor da página de destino à instalação do jogo.

Abordagens Comuns:

https://example.com/download?match_id=abc123

document.cookie = `match_id=${matchId}; path=/; max-age=86400`;

localStorage.setItem('singular_match_id', matchId);

mygame://install?match_id=abc123

Implementação da API S2S

Reportando o Match ID

Uma vez que o jogo recupere o Match ID da implementação web, inclua-o na primeira notificação de sessão à Singular para a correspondência de atribuição.

Requisição de Sessão com Match ID:

import requests

def report_first_session_with_match_id(sdk_key, game_id, device_id, platform, match_id):
    """
    Report first game session with Match ID for attribution
    """
    session_url = "https://s2s.singular.net/api/v1/launch"

    params = {
        'a': sdk_key,
        'i': game_id,
        'sdid': device_id,
        'p': platform,
        'os': 'windows',
        'install_source': 'steam',
        'ip': get_user_ip(),
        'match_id': match_id  # Include Match ID for attribution
    }

    response = requests.get(session_url, params=params)
    return response.json()

# Example: First launch with Match ID
report_first_session_with_match_id(
    sdk_key='your_sdk_key_here',
    game_id='com.singular.game',
    device_id='40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform='pc',
    match_id='abc123def456'  # Retrieved from landing page
)

curl -G "https://s2s.singular.net/api/v1/launch" \
  --data-urlencode "a=your_sdk_key_here" \
  --data-urlencode "i=com.singular.game" \
  --data-urlencode "sdid=40009df0-d618-4d81-9da1-cbb3337b8dec" \
  --data-urlencode "p=pc" \
  --data-urlencode "os=windows" \
  --data-urlencode "install_source=steam" \
  --data-urlencode "ip=172.58.29.235" \
  --data-urlencode "match_id=abc123def456"

async function reportFirstSessionWithMatchId(config) {
    const sessionUrl = 'https://s2s.singular.net/api/v1/launch';

    const params = new URLSearchParams({
        'a': config.sdkKey,
        'i': config.gameId,
        'sdid': config.deviceId,
        'p': config.platform,
        'os': config.osVersion,
        'install_source': config.store,
        'ip': await getUserIP(),
        'match_id': config.matchId  // Include Match ID
    });

    const response = await fetch(`${sessionUrl}?${params.toString()}`);
    return await response.json();
}

// Example: First launch with Match ID
reportFirstSessionWithMatchId({
    sdkKey: 'your_sdk_key_here',
    gameId: 'com.singular.game',
    deviceId: '40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform: 'pc',
    osVersion: 'windows',
    store: 'steam',
    matchId: 'abc123def456'  // Retrieved from landing page
});

Melhores Práticas de Match ID

Checklist de Implementação

Para detalhes completos sobre a metodologia de atribuição e solução de problemas, consulte o FAQ de Atribuição de Jogos para PC e Console .

Rastreamento de Sessões do Jogo

Reportar as sessões do jogo à Singular é obrigatório na integração de PC e Console, permitindo a atribuição de instalações, o rastreamento de re-engajamento e a análise de retenção de usuários.

Session Notification Endpoint

Requisito de Implementação

Chame o Session Notification Endpoint sempre que o jogo for iniciado para notificar a Singular sobre a sessão do jogo.

Processamento de Sessões

Fluxo de Trabalho de Atribuição

As notificações de sessão permitem que a Singular execute múltiplas funções de atribuição e análise com base no contexto da sessão.

Lógica de Processamento:

• Primeira Sessão (Instalação): Se for a primeira sessão do jogo após uma instalação única, a Singular reconhece a nova instalação e aciona o processo de atribuição de instalação
• Sessão de Re-engajamento: Se a sessão se qualificar como re-engajamento (em breve), a Singular aciona o processo de atribuição de re-engajamento (consulte o FAQ de Re-engajamento )
• Sessão Regular: Caso contrário, é marcada como sessão de jogo para rastreamento de atividade e retenção do usuário

Melhores Práticas de Implementação

Coleta Assíncrona de Dados

Ao coletar dados para reportar a sessão do jogo, aguarde o retorno das funções assíncronas e trate as diversas funcionalidades antes de enviar a notificação de sessão.

Exemplo de Requisição de Sessão

Implementação de Exemplo

import requests

def report_game_session(sdk_key, game_id, device_id, platform, os_version, store):
    """
    Report game session to Singular
    """
    session_url = "https://s2s.singular.net/api/v1/launch"

    params = {
        'a': sdk_key,
        'i': game_id,
        'sdid': device_id,
        'p': platform,
        'os': os_version,
        'install_source': store,
        'ip': get_user_ip()
    }

    try:
        response = requests.get(session_url, params=params, timeout=10)

        if response.status_code == 200:
            data = response.json()
            if data.get('status') == 'ok':
                print("Session reported successfully")
                return True
            else:
                print(f"Session error: {data.get('reason')}")
                return False
        else:
            print(f"HTTP error: {response.status_code}")
            return False

    except Exception as e:
        print(f"Exception reporting session: {e}")
        return False

# Example usage
report_game_session(
    sdk_key='your_sdk_key_here',
    game_id='com.singular.game',
    device_id='40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform='pc',
    os_version='windows',
    store='steam'
)

curl -G "https://s2s.singular.net/api/v1/launch" \
  --data-urlencode "a=your_sdk_key_here" \
  --data-urlencode "i=com.singular.game" \
  --data-urlencode "sdid=40009df0-d618-4d81-9da1-cbb3337b8dec" \
  --data-urlencode "p=pc" \
  --data-urlencode "os=windows" \
  --data-urlencode "install_source=steam" \
  --data-urlencode "ip=172.58.29.235"

async function reportGameSession(config) {
    const sessionUrl = 'https://s2s.singular.net/api/v1/launch';

    const params = new URLSearchParams({
        'a': config.sdkKey,
        'i': config.gameId,
        'sdid': config.deviceId,
        'p': config.platform,
        'os': config.osVersion,
        'install_source': config.store,
        'ip': await getUserIP()
    });

    try {
        const response = await fetch(`${sessionUrl}?${params.toString()}`);
        const data = await response.json();

        if (data.status === 'ok') {
            console.log('Session reported successfully');
            return true;
        } else {
            console.error('Session error:', data.reason);
            return false;
        }
    } catch (error) {
        console.error('Exception reporting session:', error);
        return false;
    }
}

// Example usage
reportGameSession({
    sdkKey: 'your_sdk_key_here',
    gameId: 'com.singular.game',
    deviceId: '40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform: 'pc',
    osVersion: 'windows',
    store: 'steam'
});

Rastreamento de Eventos In-Game

Rastreie eventos in-game e interações de usuários para analisar o desempenho de campanhas de marketing, otimizar funis de usuários e medir o engajamento ao longo da jornada do jogador.

Planejamento de Eventos

Definição de Eventos

Antes de implementar a integração S2S, defina os eventos que a sua organização deseja rastrear para análise de campanhas e medição do comportamento do usuário.

Guia de Planejamento de Eventos: Definindo Eventos In-Game

Event Notification Endpoint

Report de Eventos

Chame o Event Notification Endpoint quando um evento ocorrer no jogo para notificar a Singular para análise de atribuição e otimização de campanhas.

O nome do evento incluído na chamada da API determina como o evento é identificado nos relatórios, exports e postbacks da Singular.

Melhores Práticas de Nomenclatura de Eventos

Eventos Padrão

A Singular recomenda usar a convenção de nomenclatura padrão de eventos e atributos para simplificar a integração com parceiros e a compatibilidade com análises.

Rastreamento de Eventos de Receita

Medição de Receita

Rastreie a receita de compras in-game para analisar o desempenho de campanhas e o ROI, com dados disponíveis em relatórios, log exports e postbacks.

Implementação de Eventos de Receita: Use o Event Notification Endpoint com parâmetros de receita adicionais para designar eventos de receita.

Parâmetros de Receita Obrigatórios:

• is_revenue_event=true - Marca o evento como evento de receita (opcional se o nome do evento for __iap__ ou o valor for maior que zero)
• amt=1.99 - Valor da receita
• cur=USD - Código de moeda ISO 4217

Exemplos de Requisição de Eventos

Implementações de Exemplo

import requests

def report_game_event(sdk_key, game_id, device_id, platform, event_name, event_attributes=None):
    """
    Report in-game event to Singular
    """
    event_url = "https://s2s.singular.net/api/v1/evt"

    params = {
        'a': sdk_key,
        'i': game_id,
        'sdid': device_id,
        'p': platform,
        'n': event_name,
        'ip': get_user_ip()
    }

    if event_attributes:
        import json
        params['e'] = json.dumps(event_attributes)

    response = requests.get(event_url, params=params)
    return response.json()

# Example: Level complete event
report_game_event(
    sdk_key='your_sdk_key_here',
    game_id='com.singular.game',
    device_id='40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform='pc',
    event_name='sng_level_achieved',
    event_attributes={
        'level': '5',
        'score': '1250'
    }
)

def report_revenue_event(sdk_key, game_id, device_id, platform, amount, currency):
    """
    Report revenue event to Singular
    """
    event_url = "https://s2s.singular.net/api/v1/evt"

    params = {
        'a': sdk_key,
        'i': game_id,
        'sdid': device_id,
        'p': platform,
        'n': '__iap__',
        'is_revenue_event': 'true',
        'amt': amount,
        'cur': currency,
        'ip': get_user_ip()
    }

    response = requests.get(event_url, params=params)
    return response.json()

# Example: $9.99 purchase
report_revenue_event(
    sdk_key='your_sdk_key_here',
    game_id='com.singular.game',
    device_id='40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform='pc',
    amount=9.99,
    currency='USD'
)

curl -G "https://s2s.singular.net/api/v1/evt" \
  --data-urlencode "a=your_sdk_key_here" \
  --data-urlencode "i=com.singular.game" \
  --data-urlencode "sdid=40009df0-d618-4d81-9da1-cbb3337b8dec" \
  --data-urlencode "p=pc" \
  --data-urlencode "n=sng_level_achieved" \
  --data-urlencode 'e={"level":"5","score":"1250"}' \
  --data-urlencode "ip=172.58.29.235"

curl -G "https://s2s.singular.net/api/v1/evt" \
  --data-urlencode "a=your_sdk_key_here" \
  --data-urlencode "i=com.singular.game" \
  --data-urlencode "sdid=40009df0-d618-4d81-9da1-cbb3337b8dec" \
  --data-urlencode "p=pc" \
  --data-urlencode "n=__iap__" \
  --data-urlencode "is_revenue_event=true" \
  --data-urlencode "amt=9.99" \
  --data-urlencode "cur=USD" \
  --data-urlencode "ip=172.58.29.235"

async function reportGameEvent(config) {
    const eventUrl = 'https://s2s.singular.net/api/v1/evt';

    const params = new URLSearchParams({
        'a': config.sdkKey,
        'i': config.gameId,
        'sdid': config.deviceId,
        'p': config.platform,
        'n': config.eventName,
        'ip': await getUserIP()
    });

    if (config.attributes) {
        params.append('e', JSON.stringify(config.attributes));
    }

    const response = await fetch(`${eventUrl}?${params.toString()}`);
    return await response.json();
}

// Example: Level complete
reportGameEvent({
    sdkKey: 'your_sdk_key_here',
    gameId: 'com.singular.game',
    deviceId: '40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform: 'pc',
    eventName: 'sng_level_achieved',
    attributes: {
        level: '5',
        score: '1250'
    }
});

async function reportRevenueEvent(config) {
    const eventUrl = 'https://s2s.singular.net/api/v1/evt';

    const params = new URLSearchParams({
        'a': config.sdkKey,
        'i': config.gameId,
        'sdid': config.deviceId,
        'p': config.platform,
        'n': '__iap__',
        'is_revenue_event': 'true',
        'amt': config.amount,
        'cur': config.currency,
        'ip': await getUserIP()
    });

    const response = await fetch(`${eventUrl}?${params.toString()}`);
    return await response.json();
}

// Example: $9.99 purchase
reportRevenueEvent({
    sdkKey: 'your_sdk_key_here',
    gameId: 'com.singular.game',
    deviceId: '40009df0-d618-4d81-9da1-cbb3337b8dec',
    platform: 'pc',
    amount: 9.99,
    currency: 'USD'
});

Próximos Passos

Complete a sua integração de PC e Console com recursos e suporte adicionais.

Recursos Adicionais

Documentação e Suporte

• Referência da API: Referência de Endpoints S2S para PC e Console
• FAQ de Atribuição: FAQ de Atribuição de Jogos para PC e Console
• Web SDK (Opcional): Visão Geral e Introdução ao Web SDK
• Planejamento de Eventos: Definindo Eventos In-Game
• Eventos Padrão: Referência de Eventos Padrão da Singular
• Códigos de Resposta: Códigos de Resposta S2S e Tratamento de Erros

Canais de Suporte

Obtendo Ajuda

Entre em contato com a equipe da Singular para obter assistência de implementação e suporte técnico.

• Solution Engineer: Consulte um Solution Engineer da Singular para recursos avançados e planejamento de integração
• Customer Success Manager: Entre em contato com o CSM para habilitação de recursos enterprise e configuração de conta
• Equipe de Suporte: Abra tickets de suporte para problemas técnicos e assistência na solução de problemas