> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Construye un Generador de Imágenes AI con Facturación Basada en Uso

> Sigue este tutorial mientras construimos PixelGen AI - un servicio de generación de imágenes AI con facturación por uso

En este tutorial, construirás **PixelGen AI** - un servicio de generación de imágenes AI de ejemplo que demuestra la facturación basada en uso. Crearemos todo desde cero: el medidor de facturación, la configuración del producto y el código de aplicación de ejemplo que genera imágenes y rastrea el uso en tiempo real.

<Note>
  Este tutorial ofrece código de muestra para una aplicación basada en terminal. Puedes adaptar este código a tu framework específico (React, Vue, Angular, etc.) y personalizar el método de ingreso del usuario según las necesidades de tu aplicación.
</Note>

Al final de este tutorial, tendrás un servicio de muestra funcional que:

* Genera imágenes utilizando la API DALL-E de OpenAI
* Rastrea cada generación de imagen para la facturación
* Cobra a los clientes automáticamente según el uso
* Maneja diferentes niveles de calidad (estándar vs HD)

## Lo que Estamos Construyendo

Comencemos por entender nuestro servicio PixelGen AI:

* **Servicio**: Generación de imágenes AI utilizando la API DALL-E de OpenAI
* **Modelo de Precios**: Pago por imagen (\$0.05 por imagen)
* **Nivel Gratuito**: 10 imágenes gratuitas por cliente por mes
* **Opciones de Calidad**: Imágenes estándar y HD (mismo precio por simplicidad)

<Info>
  Antes de comenzar, asegúrate de tener:

  * Una cuenta de Dodo Payments
  * Acceso a la API de OpenAI
  * Conocimientos básicos de TypeScript/Node.js
</Info>

## Paso 1: Crea Tu Medidor de Uso

Comenzaremos creando un medidor en tu panel de Dodo Payments que rastreará cada imagen que genere nuestro servicio. Piensa en esto como el "contador" que rastrea eventos facturables.

<Frame>
  <img src="https://mintcdn.com/dodopayments/w9oVTi6CzZMAOQA3/images/usage-based/UBB-2.png?fit=max&auto=format&n=w9oVTi6CzZMAOQA3&q=85&s=f9d85a463fba231437151db3d4a2052a" alt="" style={{ maxHeight: '500px', width: 'auto' }} width="2324" height="1600" data-path="images/usage-based/UBB-2.png" />
</Frame>

<Tip>
  **Lo que construiremos**: Un medidor llamado "Image Generation Meter" que contabiliza cada vez que alguien genera una imagen usando nuestro servicio.
</Tip>

<Steps>
  <Step title="Open the Meters section">
    1. Inicia sesión en el panel de Dodo Payments
    2. Haz clic en **Meters** en la barra lateral izquierda
    3. Haz clic en el botón **Create Meter**

    Verás un formulario donde configuraremos el seguimiento de generación de imágenes.
  </Step>

  <Step title="Fill in the basic meter information">
    Ahora ingresaremos los detalles específicos para nuestro servicio PixelGen AI:

    **Meter Name**: Copia y pega exactamente esto → `Image Generation Meter`

    **Description**: Copia esto → `Tracks each AI image generation request made by customers using our DALL-E powered service`

    **Event Name**: Esto es crucial - copia exactamente → `image.generated`

    <Warning>
      El nombre del evento `image.generated` debe coincidir exactamente con lo que enviaremos luego desde el código de la aplicación. ¡Los nombres de eventos distinguen entre mayúsculas y minúsculas!
    </Warning>
  </Step>

  <Step title="Configure how we count images">
    Configura la agregación (cómo el medidor cuenta nuestros eventos):

    **Tipo de Agregación**: Selecciona **Contar** del menú desplegable

    **Measurement Unit**: Escribe → `images`

    <Info>
      Usamos "Count" porque queremos facturar por cada imagen generada, no por tamaño o duración. Cada imagen exitosa = 1 unidad facturable.
    </Info>
  </Step>

  <Step title="Add quality filtering">
    <Frame>
      <img src="https://mintcdn.com/dodopayments/w9oVTi6CzZMAOQA3/images/usage-based/UBB-3.png?fit=max&auto=format&n=w9oVTi6CzZMAOQA3&q=85&s=ce231b0559d31723bc12c22cd9ff9d64" alt="" style={{ maxHeight: '500px', width: 'auto' }} width="1558" height="942" data-path="images/usage-based/UBB-3.png" />
    </Frame>

    Queremos asegurarnos de contar solo imágenes legítimas (no ejecuciones de prueba o fallos):

    1. **Activa Event Filtering**: cambia esto a **ON**
    2. **Filter Logic**: Selecciona **OR** (esto significa "contar si CUALQUIERA de estas condiciones es verdadera")
    3. **Agrega la primera condición**:
       * Property Key: `quality`
       * Comparator: `equals`
       * Value: `standard`
    4. **Haz clic en "Add Condition"** para la segunda:
       * Property Key: `quality`
       * Comparator: `equals`
       * Value: `hd`

    <Tip>
      Esta configuración significa que solo contaremos eventos donde la calidad sea "standard" O "hd", filtrando eventos de prueba o solicitudes malformadas.
    </Tip>
  </Step>

  <Step title="Create your meter">
    1. Verifica que todos tus ajustes coincidan con los valores anteriores
    2. Haz clic en **Create Meter**

    <Check>
      **¡Medidor creado!** Tu "Image Generation Meter" ya está listo para comenzar a contar generaciones de imágenes. A continuación, lo conectaremos a un producto de facturación.
    </Check>
  </Step>
</Steps>

## Paso 2: Crea Tu Producto de Facturación

Ahora necesitamos crear un producto que defina nuestros precios (\$0.05 por imagen con 10 imágenes gratuitas). Esto conecta nuestro medidor a la facturación real.

<Tip>
  **Lo que construiremos**: Un producto llamado "PixelGen AI - Image Generation" que cobra \$0.05 por imagen después de las primeras 10 imágenes gratuitas cada mes.
</Tip>

<Steps>
  <Step title="Navigate to Products">
    1. En tu panel de Dodo Payments, haz clic en **Products** en la barra lateral izquierda
    2. Haz clic en **Create Product**
    3. Selecciona **Usage-Based** como tipo de producto

    Esto le indica a Dodo Payments que la facturación se basará en el uso del medidor, no en una suscripción fija.
  </Step>

  <Step title="Enter product details">
    Completa estos valores exactos para nuestro servicio PixelGen AI:

    **Product Name**: Copia esto → `PixelGen AI - Image Generation`

    **Description**: Copia esto → `AI-powered image generation service with pay-per-use billing`

    **Imagen del Producto**: Sube una imagen clara y relevante.

    <Info>
      Aparecerán en las facturas del cliente, así que haz que sean claros y profesionales.
    </Info>
  </Step>

  <Step title="Connect your meter">
    <Frame>
      <img src="https://mintcdn.com/dodopayments/w9oVTi6CzZMAOQA3/images/usage-based/UBB-5.png?fit=max&auto=format&n=w9oVTi6CzZMAOQA3&q=85&s=fd3851a1a070714baf0aec01cff717b8" alt="" style={{ maxHeight: '500px', width: 'auto' }} width="2272" height="1422" data-path="images/usage-based/UBB-5.png" />
    </Frame>

    Antes de conectar tu medidor, asegúrate de haber seleccionado **Facturación Basada en Uso** como el tipo de precio para tu producto.

    Además, establece el **Fixed Price** en `0` para asegurar que los clientes solo paguen según su uso, sin cuota base.

    Ahora, vincula el medidor que acabas de crear:

    1. Desplázate hacia abajo a la sección **Medidor Asociado**
    2. Haz clic en **Agregar Medidores**
    3. Desde el menú desplegable, selecciona **"Medidor de Generación de Imágenes"** (el que creaste anteriormente)
    4. Confirma que aparece en la configuración de tu producto

    <Check>
      Tu medidor ya está conectado con éxito a este producto.
    </Check>
  </Step>

  <Step title="Set your pricing">
    Aquí definimos nuestro modelo de negocio:

    <Frame>
      <img src="https://mintcdn.com/dodopayments/w9oVTi6CzZMAOQA3/images/usage-based/UBB-4.png?fit=max&auto=format&n=w9oVTi6CzZMAOQA3&q=85&s=b2d07bb408fd79e1b788c1b7092b8bca" alt="" style={{ maxHeight: '500px', width: 'auto' }} width="732" height="712" data-path="images/usage-based/UBB-4.png" />
    </Frame>

    **Price Per Unit**: Ingresa → `0.05` (esto es \$0.05 por imagen)

    **Free Threshold**: Ingresa → `10` (los clientes obtienen 10 imágenes gratuitas al mes)

    <Tip>
      **Cómo funciona la facturación**: Si un cliente genera 25 imágenes en un mes, se le cobrará por 15 imágenes (25 - 10 gratuitas) = 15 × $0.05 = $0.75
    </Tip>
  </Step>

  <Step title="Save your product">
    1. Revisa todos tus ajustes:
       * Nombre: PixelGen AI - Image Generation
       * Medidor: Image Generation Meter
       * Precio: \$0.05 por imagen
       * Nivel gratuito: 10 imágenes
    2. Haz clic en **Save Changes**

    <Check>
      **¡Producto creado!** Tu facturación ya está configurada. Los clientes serán cobrados automáticamente según su uso de generación de imágenes.
    </Check>
  </Step>
</Steps>

## Paso 3: Realiza una Compra de Prueba

Antes de comenzar a recibir eventos de uso, necesitamos realizar una compra de prueba.

<Steps>
  <Step title="Get your payment link">
    1. En tu panel de Dodo Payments, ve a **Products**
    2. Busca tu producto "PixelGen AI - Image Generation"
    3. Haz clic en el botón **Share** junto a tu producto
    4. Copia el enlace de pago que aparece

    El enlace de pago tendrá un aspecto similar a: `https://test.checkout.dodopayments.com/buy/pdt_IgPWlRsfpbPd5jQKezzW1?quantity=1`
  </Step>

  <Step title="Complete a test purchase">
    1. Abre el enlace de pago en una nueva pestaña del navegador
    2. Ingresa los datos de pago de prueba y completa la compra.

    <Check>
      Después del pago exitoso, tendrás un ID de cliente que usaremos en el código de nuestra aplicación.
    </Check>
  </Step>

  <Step title="Find your customer ID">
    1. Vuelve a tu panel de Dodo Payments
    2. Navega a **Ventas → Clientes** en la barra lateral
    3. Encuentra el cliente que acabas de crear (con el correo de prueba)
    4. Copia el ID del cliente - se verá así `cus_abc123def456`

    <Note>
      Guarda este ID de cliente: lo codificaremos en nuestro código de muestra para asegurarnos de que los eventos se rastreen correctamente.
    </Note>
  </Step>
</Steps>

## Paso 4: Construye la Aplicación de Ejemplo

Ahora tenemos nuestra configuración de facturación completa y un cliente de prueba creado. Vamos a construir la aplicación de ejemplo PixelGen AI que genera imágenes y rastrea automáticamente el uso para la facturación.

<Steps>
  <Step title="Set up your project">
    Crea un nuevo directorio e inicializa el proyecto:

    ```bash theme={null}
    mkdir pixelgen-ai
    cd pixelgen-ai
    npm init -y
    ```
  </Step>

  <Step title="Install dependencies">
    Instala los paquetes que necesitamos:

    ```bash theme={null}
    npm install openai dotenv
    npm install -D typescript @types/node ts-node
    ```
  </Step>

  <Step title="Create the main application">
    Crea un archivo llamado `index.ts` y copia este código completo de la aplicación:
  </Step>
</Steps>

Aquí está la aplicación completa de PixelGen AI con facturación integrada:

<CodeGroup>
  ```typescript index.ts expandable theme={null}
  import 'dotenv/config';
  import OpenAI from 'openai';
  import * as readline from 'readline';
  import { randomUUID } from 'crypto';

  // Initialize OpenAI client
  const openai = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY,
  });

  // Dodo Payments configuration
  const DODO_PAYMENTS_CONFIG = {
    apiKey: process.env.DODO_PAYMENTS_API_KEY,
    baseUrl: 'https://test.dodopayments.com',
    customerId: 'cus_FX5FAB43aShGyiHJGIqjB', // Replace with your actual customer ID from Step 3
  };

  // DALL-E 3 pricing (as of 2024-2025)
  const PRICING = {
    'standard': 0.040, // $0.040 per image (1024×1024)
    'hd': 0.080,       // $0.080 per image (1024×1024, HD quality)
  };

  interface ImageGenerationOptions {
    prompt: string;
    model?: 'dall-e-3' | 'dall-e-2';
    quality?: 'standard' | 'hd';
    size?: '1024x1024' | '1792x1024' | '1024x1792';
    style?: 'vivid' | 'natural';
  }

  interface UsageEvent {
    event_id: string;
    customer_id: string;
    event_name: string;
    timestamp: string;
    metadata: {
      quality: string;
    };
  }

  /**
   * Send usage event to Dodo Payments for billing tracking
   */
  async function sendUsageEvent(event: UsageEvent): Promise<void> {
    try {
      console.log('Sending usage event to Dodo Payments...');
      console.log(`URL: ${DODO_PAYMENTS_CONFIG.baseUrl}/events/ingest`);
      console.log(`API Key present: ${!!DODO_PAYMENTS_CONFIG.apiKey}`);
      console.log(`API Key length: ${DODO_PAYMENTS_CONFIG.apiKey?.length || 0}`);
      console.log(`Customer ID: ${DODO_PAYMENTS_CONFIG.customerId}`);
      
      const requestBody = {
        events: [event]
      };
      console.log('Request body:', JSON.stringify(requestBody, null, 2));
      
      const headers = {
        'Authorization': `Bearer ${DODO_PAYMENTS_CONFIG.apiKey}`,
        'Content-Type': 'application/json',
      }
      console.log('Headers:', headers);
      const response = await fetch(`${DODO_PAYMENTS_CONFIG.baseUrl}/events/ingest`, {
        method: 'POST',
        headers: headers,
        body: JSON.stringify(requestBody),
      });

      console.log(`Response status: ${response.status}`);
      console.log(`Response headers:`, Object.fromEntries(response.headers.entries()));

      if (!response.ok) {
        const errorData = await response.text();
        console.log(`Error response body: ${errorData}`);
        throw new Error(`HTTP ${response.status}: ${errorData}`);
      }

      const result = await response.json();
      console.log('Usage event sent successfully');
      console.log(`   • Event ID: ${event.event_id}`);
      console.log(`   • Customer: ${event.customer_id}`);
      console.log(`   • Quality: ${event.metadata.quality}`);
      
    } catch (error) {
      console.error('Failed to send usage event:', error);
      // In production, you might want to queue failed events for retry
      throw error;
    }
  }

  async function generateImage(options: ImageGenerationOptions) {
    const startTime = Date.now();
    const eventId = randomUUID();
    
    try {
      console.log('Generating image...');
      console.log(`Prompt: "${options.prompt}"`);
      console.log(`Quality: ${options.quality || 'standard'}`);
      console.log(`Size: ${options.size || '1024x1024'}`);
      
      const response = await openai.images.generate({
        model: options.model || 'dall-e-3',
        prompt: options.prompt,
        n: 1,
        size: options.size || '1024x1024',
        quality: options.quality || 'standard',
        style: options.style || 'vivid',
      });

      const endTime = Date.now();
      const duration = (endTime - startTime) / 1000;
      const cost = PRICING[options.quality || 'standard'];
      
      // Create usage event for Dodo Payments
      const usageEvent: UsageEvent = {
        event_id: eventId,
        customer_id: DODO_PAYMENTS_CONFIG.customerId!,
        event_name: 'image.generated',
        timestamp: new Date().toISOString(),
        metadata: {
          quality: options.quality || 'standard',
        }
      };

      // Send usage event to Dodo Payments for billing
      await sendUsageEvent(usageEvent);
      
      console.log('\nImage generated successfully!');
      console.log(`Generation Stats:`);
      console.log(`   • Duration: ${duration.toFixed(2)} seconds`);
      console.log(`   • Quality: ${options.quality || 'standard'}`);
      console.log(`   • Cost: $${cost.toFixed(3)}`);
      console.log(`   • Image URL: ${response.data?.[0]?.url}`);
      
      if (response.data?.[0]?.revised_prompt) {
        console.log(`   • Revised prompt: "${response.data[0].revised_prompt}"`);
      }

      return {
        imageUrl: response.data?.[0].url,
        revisedPrompt: response.data?.[0].revised_prompt,
        cost: cost,
        duration: duration,
        eventId: eventId,
      };

    } catch (error) {
      console.error('Error generating image:', error);
      
      // Send failure event for monitoring (optional)
      try {
        const failureEvent: UsageEvent = {
          event_id: eventId,
          customer_id: DODO_PAYMENTS_CONFIG.customerId!,
          event_name: 'image.generation.failed',
          timestamp: new Date().toISOString(),
          metadata: {
            quality: options.quality || 'standard',
          }
        };
        
        // Note: You might want to create a separate meter for failed attempts
        // await sendUsageEvent(failureEvent);
      } catch (eventError) {
        console.error('Failed to send failure event:', eventError);
      }
      
      throw error;
    }
  }

  async function getUserInput(): Promise<string> {
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });

    return new Promise((resolve) => {
      rl.question('Enter your image prompt: ', (answer) => {
        rl.close();
        resolve(answer);
      });
    });
  }

  async function main() {
    console.log('PixelGen AI - Image Generator with Usage Billing\n');
    
    // Validate environment variables
    const requiredEnvVars = [
      'OPENAI_API_KEY',
      'DODO_PAYMENTS_API_KEY'
    ];
    
    for (const envVar of requiredEnvVars) {
      if (!process.env[envVar]) {
        console.error(`Error: ${envVar} environment variable is not set.`);
        console.log('Please set all required environment variables:');
        console.log('export OPENAI_API_KEY="your-openai-key"');
        console.log('export DODO_PAYMENTS_API_KEY="your-dodo-api-key"');
        console.log('Note: Customer ID is hardcoded in the application');
        process.exit(1);
      }
    }

    try {
      const prompt = await getUserInput();
      
      if (!prompt.trim()) {
        console.log('No prompt provided. Exiting...');
        return;
      }

      const result = await generateImage({
        prompt: prompt.trim(),
        quality: 'standard', // Change to 'hd' for higher quality (costs more)
        size: '1024x1024',
        style: 'vivid'
      });

      console.log('\nProcess completed successfully!');
      console.log(`Billing Information:`);
      console.log(`   • Total cost: $${result.cost.toFixed(3)}`);
      console.log(`   • Event ID: ${result.eventId}`);
      console.log(`   • Billing will be processed automatically via Dodo Payments`);
      
    } catch (error) {
      console.error('Application error:', error);
      process.exit(1);
    }
  }

  // Run the application
  if (require.main === module) {
    main().catch(console.error);
  }
  ```

  ```bash .env theme={null}
  # Create .env file with your API keys
  OPENAI_API_KEY=your_openai_api_key_here
  DODO_PAYMENTS_API_KEY=your_DODO_PAYMENTS_payments_api_key_here
  # Note: Customer ID is hardcoded in the application code
  ```

  ```typescript package.json theme={null}
  {
    "name": "pixelgen-ai",
    "version": "1.0.0",
    "description": "AI Image Generation with Usage-Based Billing",
    "main": "index.js",
    "scripts": {
      "start": "ts-node index.ts",
      "build": "tsc",
      "dev": "ts-node --watch index.ts"
    },
    "dependencies": {
      "openai": "^4.0.0",
      "dotenv": "^16.0.0"
    },
    "devDependencies": {
      "@types/node": "^20.0.0",
      "typescript": "^5.0.0",
      "ts-node": "^10.0.0"
    }
  }
  ```
</CodeGroup>

## Paso 5: Prueba Tu Aplicación de Ejemplo

¡Es hora de probar nuestro servicio de ejemplo PixelGen AI y ver la facturación en acción! Asegurémonos de que todo funcione de extremo a extremo.

<Tip>
  **Lo que estamos probando**: Generaremos algunas imágenes, verificaremos que los eventos lleguen a Dodo Payments y confirmaremos que los cálculos de facturación son correctos.
</Tip>

<Steps>
  <Step title="Set up your environment">
    Primero, asegúrate de tener todo configurado:

    1. Crea un archivo `.env` en tu directorio `pixelgen-ai`
    2. Agrega tus claves de API reales:

    ```bash theme={null}
    OPENAI_API_KEY=sk-your-actual-openai-key
    DODO_PAYMENTS_API_KEY=your-actual-dodo-api-key
    # Customer ID is hardcoded in the application
    ```

    3. Instala las dependencias y ejecuta la aplicación:

    ```bash theme={null}
    npm install
    npm start
    ```

    <Warning>
      Asegúrate de usar claves de API reales y actualiza el ID de cliente codificado en el código con el ID real del Paso 3.
    </Warning>
  </Step>

  <Step title="Generate your first test image">
    Cuando la aplicación inicie, verás:

    ```
    PixelGen AI - Image Generator with Usage Billing

    Enter your image prompt:
    ```

    Prueba este prompt: **"Un robot lindo pintando un paisaje"**

    Deberías ver una salida como esta:

    ```
    Generating image...
    Prompt: "A cute robot painting a landscape"
    Quality: standard
    Size: 1024x1024

    Sending usage event to Dodo Payments...
    Usage event sent successfully
       • Event ID: 550e8400-e29b-41d4-a716-446655440000
       • Customer: cus_atXa1lklCRRzMicTqfiw2
       • Quality: standard

    Image generated successfully!
    Generation Stats:
       • Duration: 8.45 seconds
       • Quality: standard
       • Cost: $0.040
       • Image URL: https://oaidalleapi...
    ```

    <Check>
      Si ves "Usage event sent successfully", ¡tu integración de facturación está funcionando!
    </Check>
  </Step>

  <Step title="Generate a few more images">
    Generemos 2-3 imágenes más para probar múltiples eventos. Intenta estos prompts:

    1. **"Un atardecer sobre montañas con nubes moradas"**
    2. **"Una máquina de café steampunk en una cocina victoriana"**
    3. **"Un dragón amigable leyendo un libro en una biblioteca"**

    Cada vez, observa el mensaje "Usage event sent successfully".
  </Step>

  <Step title="Check your Dodo Payments dashboard">
    Ahora verifiquemos que los eventos se están recibiendo:

    1. Abre tu panel de Dodo Payments
    2. Ve a *Facturación por Uso* → \***Medidores** → **Medidor de Generación de Imágenes**
    3. Haz clic en la pestaña **Eventos**
    4. Deberías ver tus eventos de generación de imágenes listados

    **Qué buscar**:

    * Nombres de eventos: `image.generated`
    * ID de cliente: Tu ID de cliente de prueba

    <Check>
      ¡Deberías ver un evento por cada imagen generada!
    </Check>
  </Step>

  <Step title="Verify billing calculations">
    Verifiquemos si el conteo de uso está funcionando:

    <Frame>
      <img src="https://mintcdn.com/dodopayments/w9oVTi6CzZMAOQA3/images/usage-based/UBB-1.png?fit=max&auto=format&n=w9oVTi6CzZMAOQA3&q=85&s=7fb86a266b5aa84f281b680601bd998e" alt="" style={{ maxHeight: '500px', width: 'auto' }} width="1536" height="1252" data-path="images/usage-based/UBB-1.png" />
    </Frame>

    1. En tu medidor, ve a la pestaña **Clientes**
    2. Encuentra tu cliente de prueba
    3. Verifica la columna "Unidades Consumidas"
  </Step>

  <Step title="Test the billing threshold">
    Superemos la capa gratuita para ver la facturación en acción:

    1. Genera 8 imágenes más (para alcanzar un total de 12)
    2. Verifica tu panel de medidor nuevamente
    3. Ahora deberías ver:
       * Unidades consumidas: 12
       * Unidades facturables: 2 (12 - 10 gratuitas)
       * Monto de facturación: \$0.10

    <Check>
      **¡Éxito!** Tu facturación basada en uso funciona perfectamente. Los clientes se cobrarán automáticamente según su uso real de generación de imágenes.
    </Check>
  </Step>
</Steps>

## Solución de Problemas

Problemas comunes y sus soluciones:

<AccordionGroup>
  <Accordion title="Events not appearing in dashboard">
    **Causas posibles:**

    * El nombre del evento no coincide exactamente con la configuración del medidor
    * El ID de cliente no existe en tu cuenta
    * La clave de API es inválida o ha expirado
    * Problemas de conectividad de red

    **Soluciones:**

    1. Verifica que el nombre del evento coincida exactamente con la configuración del medidor (distingue mayúsculas/minúsculas)
    2. Comprueba que el ID del cliente exista en Dodo Payments
    3. Prueba la clave de API con una llamada simple a la API
    4. Revisa la conectividad de red y la configuración del firewall
  </Accordion>
</AccordionGroup>

## ¡Felicidades! Has Construido PixelGen AI

¡Has creado exitosamente un fragmento para la generación de imágenes AI con facturación basada en uso! Esto es lo que lograste:

<CardGroup cols={2}>
  <Card title="Usage Meter" icon="sliders">
    Se creó el "Image Generation Meter" que rastrea cada evento de generación de imagen
  </Card>

  <Card title="Billing Product" icon="credit-card">
    Se configuró un precio de \$0.05 por imagen con 10 imágenes gratuitas mensuales
  </Card>

  <Card title="AI Application" icon="robot">
    Se creó una aplicación funcional en TypeScript que genera imágenes con DALL-E de OpenAI
  </Card>

  <Card title="Automated Billing" icon="bolt">
    Se integró el seguimiento de eventos en tiempo real que factura automáticamente a los clientes
  </Card>
</CardGroup>