Guía de integración de juegos para PC y consola

Guía completa para implementar la atribución de juegos de PC y consola con Singular, que permite una medición y análisis precisos de las campañas en plataformas de escritorio y de videojuegos.

Descripción general

Opciones de integración

Singular ofrece dos enfoques para la atribución de juegos de PC y consola. Selecciona el método que mejor se adapte a tus requisitos de implementación y necesidades de atribución.

Comparación de flujos de atribución

Flujo de Singular Links de PC/consola:

1. El usuario hace clic en el Singular Link: El usuario hace clic en el enlace de tracking de Singular en la campaña de marketing
2. Redirección a la página de destino: El usuario es redirigido a una página de destino o tienda (no se requiere Web SDK)
3. Descarga e instalación: El usuario descarga e instala el juego
4. Primer lanzamiento: El usuario abre el juego por primera vez
5. Reporte S2S: El juego reporta la sesión mediante la API de S2S
6. Atribución probabilística: Singular hace coincidir la instalación del juego con el clic en el Singular Link en función de la dirección IP

Flujo de Web SDK + Match ID:

1. El usuario hace clic en el enlace de la campaña: El usuario hace clic en un anuncio o enlace de la campaña de marketing
2. Página de destino con Web SDK: El usuario llega a una página de destino con el Web SDK de Singular implementado
3. Captura del clic: El Web SDK captura los datos del clic y genera un Match ID
4. Autenticación del usuario (opcional): Si el usuario inicia sesión, el Match ID puede pasarse al juego para la atribución determinística
5. Descarga e instalación: El usuario descarga e instala el juego
6. Primer lanzamiento: El usuario abre el juego y, opcionalmente, recupera el Match ID
7. Reporte S2S con Match ID: El juego reporta la sesión mediante la API de S2S con o sin Match ID
8. Coincidencia de atribución: Singular realiza la coincidencia determinística (si se proporciona el Match ID) o la coincidencia probabilística (basada en IP)

Integración de servidor a servidor

Independientemente del método de atribución elegido, implementar la integración de la API de S2S es obligatorio para toda la atribución de juegos de PC y consola.

Capacidades de integración:

• Tracking de sesiones del juego: Reporta las sesiones y la actividad de los usuarios a lo largo de los lanzamientos del juego
• Atribución de instalaciones: Atribuye nuevas instalaciones del juego a las campañas de marketing
• Análisis de eventos: Haz tracking de los eventos dentro del juego y las interacciones de los usuarios para el análisis del embudo
• Medición de ingresos: Mide las compras dentro del juego y el rendimiento de la monetización
• Compatibilidad multiplataforma: Tracking unificado en PC, Xbox, PlayStation, Nintendo y Meta Quest

Requisitos previos

Antes de implementar la integración de PC y consola, asegúrate de cumplir con los siguientes requisitos.

Recursos de documentación

Referencia completa de la API y guías de implementación para la integración de PC y consola.

Método 1: Singular Links de PC/consola (recomendado)

Enfoque de integración simplificado que usa enlaces de tracking de Singular para la atribución probabilística sin requerir la implementación del Web SDK en las páginas de destino.

Descripción general

Cómo funciona

Los Singular Links de PC/consola permiten la atribución al capturar los datos del clic directamente en el enlace de tracking, lo que elimina la necesidad de implementar el Web SDK en las páginas de destino.

Beneficios clave:

• No requiere Web SDK: Redirige a los usuarios a cualquier página de destino, incluidas las tiendas de terceros (Steam, Epic, etc.)
• Integración simplificada: Solo requiere la implementación de la API de S2S del lado del juego
• Despliegue rápido: Crea y lanza campañas rápidamente sin modificar las páginas de destino
• Destinos flexibles: Compatibilidad con una única redirección a cualquier URL de destino

Método de atribución:

• Probabilística (basada en IP): Singular hace coincidir la instalación del juego con el clic en el Singular Link en función de la dirección IP y las características del dispositivo

Pasos de implementación

Paso 1: Requisitos previos

Asegúrate de cumplir con los siguientes requisitos antes de crear Singular Links de PC/consola.

Paso 2: Crear el Singular Link de PC/consola

Crea Singular Links de PC/consola en el dashboard de Singular para hacer tracking de los clics de la campaña y habilitar la atribución.

Pasos de configuración:

1. Ir a Manage Links: En el dashboard de Singular, ve a Attribution → Manage Links
2. Seleccionar la App: Elige una App que tenga app sites de PC/consola configurados
3. Crear un nuevo enlace: Haz clic en el botón Create New Link
4. Seleccionar el tipo de plataforma: En el campo Platform Tracking Type, selecciona "PC/Console"
5. Configurar el destino: Selecciona un app site específico de PC/consola o elige la opción "Track all app sites under this app"
6. Definir la URL de destino: Configura la URL de redirección (página de destino, página de tienda, etc.)
7. Configurar los ajustes de atribución: Define las ventanas de atribución y los parámetros de tracking según sea necesario
8. Generar el enlace: Guarda y genera el enlace de tracking de Singular

Paso 3: Implementar la integración de S2S

Implementa la integración de la API de servidor a servidor para reportar las sesiones y los eventos del juego. Consulta la sección Conceptos de integración a continuación para conocer todos los detalles de la implementación de S2S.

Implementación requerida:

• Notificación de sesión: Reporta los lanzamientos del juego mediante el Session Notification Endpoint
• Tracking de eventos: Reporta los eventos y los ingresos dentro del juego mediante el Event Notification Endpoint
• Identificación del dispositivo: Genera y conserva un identificador de dispositivo único (SDID)

Paso 4: Lanzar campañas

Usa los Singular Links de PC/consola generados en las campañas de marketing para habilitar el tracking de atribución.

Configuración de la campaña:

• Copiar el enlace de tracking: Copia el Singular Link generado desde Manage Links
• Configurar la campaña: Usa el Singular Link como URL de destino de la campaña
• Lanzar la campaña: Activa la campaña con el Singular Link
• Monitorear la atribución: Consulta los datos de atribución en los reportes de Singular a medida que los usuarios hacen clic en los enlaces y abren el juego

Coincidencia de atribución

Cómo funciona la atribución

Al usar Singular Links de PC/consola, Singular realiza la coincidencia de atribución probabilística en función de la dirección IP y el momento.

Proceso de atribución:

1. El usuario hace clic en el Singular Link: Singular captura los datos del clic, incluidas la dirección IP y la marca de tiempo
2. El usuario descarga el juego: El usuario procede a descargar e instalar el juego
3. Lanzamiento del juego: El usuario abre el juego por primera vez
4. Reporte S2S: El juego reporta la sesión a Singular mediante la API de S2S, incluida la dirección IP del usuario
5. Coincidencia probabilística: Singular hace coincidir la instalación del juego con el clic en el Singular Link en función de la dirección IP dentro de la ventana de atribución
6. Atribución completa: La instalación se atribuye a la fuente de la campaña

Método 2: Web SDK + Match ID (avanzado)

Enfoque de integración avanzado que usa el Web SDK de Singular en las páginas de destino con un Match ID opcional para la atribución determinística cuando los usuarios se autentican.

Descripción general

Cuándo usar este método

Implementa el enfoque Web SDK + Match ID cuando tu caso de uso requiera capacidades de atribución mejoradas más allá de la coincidencia probabilística básica.

Casos de uso:

• Web Attribution: Necesitas las funciones de Web Attribution y el análisis web de Singular
• Atribución determinística: Los usuarios se autentican en las páginas de destino y quieres la máxima precisión de atribución
• Tracking entre dispositivos: Los usuarios pueden descargar el juego en un dispositivo diferente al de la visita a la página de destino
• Análisis avanzado: Necesitas métricas detalladas de interacción web antes de la instalación del juego

Métodos de atribución:

• Probabilística (basada en IP): Coincidencia automática basada en la dirección IP (igual que los Singular Links de PC/consola)
• Determinística (Match ID): Coincidencia precisa mediante un identificador único que se pasa de la página de destino al juego cuando el usuario se autentica

Pasos de implementación

Paso 1: Implementar el Web SDK

Implementa el Web SDK de Singular en las páginas de destino de marketing para capturar los datos del clic y habilitar la atribución.

Implementación del Web SDK:

• Sigue la guía del Web SDK: Descripción general y primeros pasos del Web SDK
• Configuración del Product ID: El Product ID del Web SDK debe coincidir con el identificador del juego (parámetro i ) usado en la integración de S2S
• Despliegue en la página de destino: Despliega el Web SDK en todas las páginas de destino de marketing

Paso 2: Implementar la integración de S2S

Implementa la integración de la API de servidor a servidor para reportar las sesiones y los eventos del juego. Consulta la sección Conceptos de integración a continuación para conocer todos los detalles de la implementación de S2S.

Implementación requerida:

• Notificación de sesión: Reporta los lanzamientos del juego mediante el Session Notification Endpoint
• Tracking de eventos: Reporta los eventos y los ingresos dentro del juego mediante el Event Notification Endpoint
• Identificación del dispositivo: Genera y conserva un identificador de dispositivo único (SDID)

Paso 3: Implementar el Match ID (opcional)

Para la atribución determinística, implementa el Match ID para pasar un identificador único de la página de destino al juego cuando los usuarios se autentican.

Implementación del Match ID:

• Recuperar el Match ID: Usa el método getMatchID() del Web SDK después de la autenticación del usuario
• Pasarlo al juego: Implementa un mecanismo para pasar el Match ID de la web al juego (parámetro de consulta, API, etc.)
• Incluirlo en la primera sesión: Reporta el Match ID en la primera sesión del juego mediante el parámetro match_id

Consulta la sección Implementación del Match ID a continuación para conocer los pasos detallados de la integración del Match ID.

Coincidencia de atribución

Cómo funciona la atribución

Al usar el Web SDK, Singular realiza la coincidencia de atribución mediante métodos probabilísticos o determinísticos, según si se proporciona el Match ID.

Atribución probabilística (sin Match ID):

1. El usuario hace clic en la campaña: El usuario hace clic en el enlace de la campaña de marketing
2. Visita a la página de destino: El Web SDK captura los datos del clic, incluida la dirección IP
3. El usuario descarga el juego: El usuario descarga e instala el juego
4. Lanzamiento del juego: El usuario abre el juego por primera vez
5. Reporte S2S: El juego reporta la sesión a Singular mediante la API de S2S
6. Coincidencia por IP: Singular hace coincidir la instalación del juego con el clic web en función de la dirección IP

Atribución determinística (con Match ID):

1. El usuario hace clic en la campaña: El usuario hace clic en el enlace de la campaña de marketing
2. Visita a la página de destino: El Web SDK genera un Match ID único
3. El usuario se autentica: El usuario inicia sesión en la página de destino
4. Match ID recuperado: La implementación recupera el Match ID del Web SDK
5. Match ID pasado al juego: El Match ID se pasa al juego mediante un parámetro de consulta, una API u otro mecanismo
6. El usuario descarga el juego: El usuario descarga e instala el juego
7. Lanzamiento del juego con Match ID: El usuario abre el juego y recupera el Match ID almacenado
8. Reporte S2S con Match ID: El juego reporta la primera sesión incluyendo el parámetro match_id
9. Coincidencia determinística: Singular hace coincidir la instalación del juego con el clic web usando el Match ID para una atribución precisa

Conceptos de integración

Conceptos básicos y requisitos para implementar la integración de S2S de PC y consola con Singular. Estos conceptos aplican a ambos métodos de atribución.

Autenticación

Todas las solicitudes a la API de S2S de PC y consola de Singular requieren la autenticación con la SDK key en el parámetro a . Para conocer los aspectos técnicos de la autenticación compartida (dónde encontrar tu SDK Key y cómo se pasa), consulta Autenticación en Fundamentos de S2S .

Privacidad del usuario

Singular recomienda ofrecer a los usuarios finales la posibilidad de aceptar o rechazar el tracking. Para conocer los parámetros de privacidad compartidos, incluidos data_sharing_options y Limit Data Sharing, consulta Parámetros de privacidad en Fundamentos de S2S .

Plataformas compatibles

Definición de plataforma

La plataforma representa dónde juega el usuario y debe pasarse en el parámetro p en todas las solicitudes de la API de S2S.

Valores de plataforma admitidos:

• pc - Plataformas de computadora personal
• xbox - Consolas de videojuegos Microsoft Xbox
• playstation - Consolas de videojuegos Sony PlayStation
• nintendo - Consolas de videojuegos Nintendo
• metaquest - Visores de realidad virtual Meta Quest

Sistemas operativos y tiendas

Además de la plataforma, especifica el sistema operativo/de juego mediante el parámetro os y la tienda de distribución mediante el parámetro install_source .

Identificador del juego

Identificación de la aplicación

El identificador del juego asocia los eventos del juego con un juego específico y debe pasarse en el parámetro i en cada solicitud.

Requisitos del identificador:

• Formato: Se admite cualquier valor, pero Singular recomienda la notación DNS inversa (por ejemplo, com.singular.game )
• Consistencia multiplataforma: Debe usarse el mismo identificador del juego para el mismo juego en todas las plataformas compatibles
• Alineación con el Web SDK (solo Método 2): Si usas el método Web SDK + Match ID, el identificador del juego debe coincidir con el Product ID del Web SDK configurado en las páginas de destino para que la atribución funcione

Ejemplos de configuración:

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

Identificación del dispositivo

Tracking único de instalaciones del juego

El identificador de instalación/dispositivo asocia los eventos del juego a lo largo de múltiples sesiones del juego para la misma instalación y debe pasarse en el parámetro sdid en cada solicitud.

Especificaciones del identificador:

• Formato: Se recomienda el formato UUID Version 4
• Generación: Valor generado por el juego/servidor en el primer lanzamiento del juego (instalación)
• Persistencia: Debe persistir durante toda la vida de la instalación del juego
• Unicidad: Cada instalación del juego requiere un identificador único

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

Implementación del Match ID

El Match ID habilita la atribución determinística para las campañas web al pasar un identificador único del Web SDK a la instalación del juego. Esta función solo está disponible al usar el método de atribución Web SDK + Match ID.

Cómo funciona el Match ID:

1. El Web SDK genera el Match ID: El Web SDK de Singular crea un Match ID único cuando el usuario visita la página de destino
2. Recuperar el Match ID: Usa los métodos del Web SDK para recuperar el Match ID de la página de destino después de la autenticación del usuario
3. Pasarlo al juego: Tu implementación pasa el Match ID de la página web al juego durante el proceso de descarga/instalación (por ejemplo, parámetro de consulta, deep link, cookie)
4. Reportarlo en el primer lanzamiento: El juego incluye el Match ID en la primera notificación de sesión a Singular mediante el parámetro match_id
5. Coincidencia determinística: Singular usa el Match ID para una coincidencia de atribución precisa

Métodos de Match ID del Web SDK

Implementación nativa

El Web SDK de Singular ofrece métodos nativos para recuperar, definir y borrar los valores del Match ID en las páginas de destino.

Métodos disponibles:

Ejemplos de implementación

// 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;
});

Pasar el Match ID al juego

Estrategias de implementación

Después de recuperar el Match ID del Web SDK, implementa un mecanismo para pasar el valor de la página de destino a la instalación del juego.

Enfoques comunes:

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

Implementación de la API de S2S

Reportar el Match ID

Una vez que el juego recupera el Match ID de la implementación web, inclúyelo en la primera notificación de sesión a Singular para la coincidencia de atribución.

Solicitud de sesión con 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
});

Prácticas recomendadas del Match ID

Lista de verificación de implementación

Para conocer todos los detalles de la metodología de atribución y la resolución de problemas, consulta las Preguntas frecuentes sobre la atribución de juegos de PC y consola .

Tracking de sesiones del juego

Reportar las sesiones del juego a Singular es obligatorio en la integración de PC y consola, ya que habilita la atribución de instalaciones, el tracking de reengagement y el análisis de retención de usuarios.

Session Notification Endpoint

Requisito de implementación

Llama al Session Notification Endpoint cada vez que se abra el juego para notificar a Singular sobre la sesión del juego.

Procesamiento de sesiones

Flujo de atribución

Las notificaciones de sesión permiten a Singular realizar múltiples funciones de atribución y análisis en función del contexto de la sesión.

Lógica de procesamiento:

• Primera sesión (instalación): Si es la primera sesión del juego después de una instalación única, Singular reconoce la nueva instalación y activa el proceso de atribución de instalaciones
• Sesión de reengagement: Si la sesión califica como reengagement (próximamente), Singular activa el proceso de atribución de reengagement (consulta las Preguntas frecuentes sobre reengagement )
• Sesión regular: De lo contrario, se marca como sesión del juego para el tracking de actividad y retención del usuario

Prácticas recomendadas de implementación

Recopilación asincrónica de datos

Al recopilar datos para reportar una sesión del juego, espera a que las funciones asincrónicas devuelvan un resultado y gestionen las distintas funcionalidades antes de enviar la notificación de sesión.

Ejemplo de solicitud de sesión

Implementación de muestra

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'
});

Tracking de eventos dentro del juego

Haz tracking de los eventos dentro del juego y las interacciones de los usuarios para analizar el rendimiento de las campañas de marketing, optimizar los embudos de usuarios y medir la interacción a lo largo del recorrido del jugador.

Planificación de eventos

Definición de eventos

Antes de implementar la integración de S2S, define los eventos de los que tu organización quiere hacer tracking para el análisis de campañas y la medición del comportamiento de los usuarios.

Guía de planificación de eventos: Definir eventos dentro del juego

Event Notification Endpoint

Reporte de eventos

Llama al Event Notification Endpoint cuando ocurra un evento en el juego para notificar a Singular para el análisis de atribución y la optimización de campañas.

El nombre del evento incluido en la llamada a la API determina cómo se identifica el evento en los reportes, exports y postbacks de Singular.

Prácticas recomendadas para nombrar eventos

Eventos estándar

Singular recomienda usar la convención de nomenclatura estándar de eventos y atributos para agilizar la integración con partners y la compatibilidad de análisis.

Tracking de eventos de ingresos

Medición de ingresos

Haz tracking de los ingresos de las compras dentro del juego para analizar el rendimiento de las campañas y el ROI, con los datos disponibles en reportes, log exports y postbacks.

Implementación de eventos de ingresos: Usa el Event Notification Endpoint con parámetros de ingresos adicionales para designar los eventos de ingresos.

Parámetros de ingresos requeridos:

• is_revenue_event=true - Marca el evento como evento de ingresos (opcional si el nombre del evento es __iap__ o el importe es mayor que cero)
• amt=1.99 - Importe de ingresos
• cur=USD - Código de moneda ISO 4217

Ejemplos de solicitud de eventos

Implementaciones de muestra

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 pasos

Completa tu integración de PC y consola con recursos y soporte adicionales.

Recursos adicionales

Documentación y soporte

• Referencia de la API: Referencia de endpoints de S2S de PC y consola
• Preguntas frecuentes sobre atribución: Preguntas frecuentes sobre la atribución de juegos de PC y consola
• Web SDK (opcional): Descripción general y primeros pasos del Web SDK
• Planificación de eventos: Definir eventos dentro del juego
• Eventos estándar: Referencia de eventos estándar de Singular
• Códigos de respuesta: Códigos de respuesta y manejo de errores de S2S

Canales de soporte

Obtener ayuda

Comunícate con el equipo de Singular para obtener asistencia de implementación y soporte técnico.

• Solution Engineer: Consulta con un Solution Engineer de Singular sobre funciones avanzadas y planificación de la integración
• Customer Success Manager: Comunícate con tu CSM para la habilitación de funciones Enterprise y la configuración de la cuenta
• Equipo de soporte: Envía tickets de soporte para problemas técnicos y asistencia en la resolución de problemas