> ## 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. # एक AI इमेज जनरेटर बनाएं जिसमें उपयोग-आधारित बिलिंग हो > इस ट्यूटोरियल में हम PixelGen AI बनाएंगे - एक AI इमेज जनरेशन सेवा जिसमें उपयोग के अनुसार बिलिंग होगी इस ट्यूटोरियल में, आप **PixelGen AI** बनाएंगे - एक नमूना AI इमेज जनरेशन सेवा जो उपयोग-आधारित बिलिंग का प्रदर्शन करती है। हम सब कुछ शून्य से बनाएंगे: बिलिंग मीटर, उत्पाद कॉन्फ़िगरेशन, और नमूना एप्लिकेशन कोड जो इमेज उत्पन्न करता है और वास्तविक समय में उपयोग को ट्रैक करता है। यह ट्यूटोरियल टर्मिनल-आधारित एप्लिकेशन के लिए नमूना कार्यान्वयन कोड प्रदान करता है। आप इस कोड को अपने विशिष्ट फ्रेमवर्क (React, Vue, Angular, आदि) के अनुसार संशोधित कर सकते हैं और अपनी एप्लिकेशन की आवश्यकताओं के अनुसार उपयोगकर्ता इनपुट विधि को अनुकूलित कर सकते हैं। इस ट्यूटोरियल के अंत तक, आपके पास एक कार्यशील नमूना सेवा होगी जो: * OpenAI के DALL-E API का उपयोग करके इमेज उत्पन्न करती है * बिलिंग के लिए हर इमेज जनरेशन को ट्रैक करती है * उपयोग के आधार पर ग्राहकों से स्वचालित रूप से शुल्क लेती है * विभिन्न गुणवत्ता स्तरों (मानक बनाम HD) को संभालती है ## हम क्या बना रहे हैं आइए हम अपने PixelGen AI सेवा को समझने से शुरू करें: * **सेवा**: OpenAI के DALL-E API का उपयोग करके AI इमेज जनरेशन * **मूल्य निर्धारण मॉडल**: प्रति इमेज (\$0.05 प्रति इमेज) * **फ्री टियर**: प्रति ग्राहक प्रति माह 10 मुफ्त इमेज * **गुणवत्ता विकल्प**: मानक और HD इमेज (सरलता के लिए समान मूल्य) शुरू करने से पहले, सुनिश्चित करें कि आपके पास: * एक Dodo Payments खाता * OpenAI के API तक पहुंच * TypeScript/Node.js की मूलभूत समझ ## चरण 1: अपना उपयोग मीटर बनाएं हम आपके Dodo Payments डैशबोर्ड में एक मीटर बनाने से शुरू करेंगे जो हमारी सेवा द्वारा उत्पन्न हर इमेज को ट्रैक करेगा। इसे "काउंटर" के रूप में सोचें जो बिल योग्य घटनाओं को ट्रैक करता है। **हम जो बना रहे हैं**: एक मीटर जिसका नाम "Image Generation Meter" है जो हर बार हमारे सेवा का उपयोग करके कोई छवि उत्पन्न होने पर गिनती करता है। 1. अपने Dodo Payments डैशबोर्ड में लॉग इन करें 2. बाईं साइडबार में **Meters** पर क्लिक करें 3. **Create Meter** बटन पर क्लिक करें आपको एक फॉर्म दिखाई देगा जहां हम अपनी इमेज जनरेशन ट्रैकिंग कॉन्फ़िगर करेंगे। अब हम अपनी PixelGen AI सेवा के लिए विशेष विवरण दर्ज करेंगे: **Meter Name**: इसे ठीक इसी तरह कॉपी और पेस्ट करें → `Image Generation Meter` **Description**: इसे कॉपी करें → `Tracks each AI image generation request made by customers using our DALL-E powered service` **Event Name**: यह बहुत महत्वपूर्ण है - इसे बिल्कुल इसी तरह कॉपी करें → `image.generated` इवेंट नाम `image.generated` को ठीक उसी तरह का होना चाहिए जैसा हम बाद में अपने एप्लिकेशन कोड से भेजेंगे। इवेंट नाम केस-सेंसिटिव होते हैं! एग्रीगेशन सेट करें (कि मीटर हमारी इवेंट्स को कैसे गिनेगा): **संघटन प्रकार**: ड्रॉपडाउन से **गिनती** चुनें **Measurement Unit**: Type → `images` हम "Count" का उपयोग कर रहे हैं क्योंकि हम प्रति जनरेट की गई छवि के आधार पर बिल करना चाहते हैं, आकार या जनरेशन समय के आधार पर नहीं। हर सफल छवि = 1 बिल योग्य यूनिट। हम यह सुनिश्चित करना चाहते हैं कि हम केवल वैध इमेज को गिनें (परीक्षण रन या विफलताओं को नहीं): 1. **Enable Event Filtering**: इसे **ON** करें 2. **Filter Logic**: **OR** चुनें (इसका मतलब है "यदि इनमें से किसी एक शर्त के सत्य होने पर गिनती करें") 3. **पहली शर्त जोड़ें**: * Property Key: `quality` * Comparator: `equals` * Value: `standard` 4. **"Add Condition" पर क्लिक करें** दूसरी शर्त के लिए: * Property Key: `quality` * Comparator: `equals` * Value: `hd` इस सेटअप का मतलब है कि हम केवल उन्हीं इवेंट्स को गिनेंगे जिनकी गुणवत्ता "standard" या "hd" है - इससे किसी भी टेस्ट इवेंट या खराब अनुरोधों को फ़िल्टर किया जाएगा। 1. सभी सेटिंग्स को ऊपर दिए गए मानों से मेल खाती हैं या नहीं, यह दोबारा देखें 2. **Create Meter** पर क्लिक करें **Meter बनाया गया!** आपका "Image Generation Meter" अब छवि निर्माण की गिनती शुरू करने के लिए तैयार है। अगला कदम इसे बिलिंग उत्पाद से जोड़ना है। ## चरण 2: अपना बिलिंग उत्पाद बनाएं अब हमें एक उत्पाद बनाने की आवश्यकता है जो हमारी मूल्य निर्धारण को परिभाषित करता है (\$0.05 प्रति इमेज और 10 मुफ्त इमेज)। यह हमारे मीटर को वास्तविक बिलिंग से जोड़ता है। **हम जो बना रहे हैं**: एक उत्पाद जिसका नाम "PixelGen AI - Image Generation" है, जो प्रत्येक महीने पहले 10 मुफ्त छवियों के बाद प्रति छवि \$0.05 चार्ज करता है। 1. अपने Dodo Payments डैशबोर्ड में, बाईं साइडबार में **Products** पर क्लिक करें 2. **Create Product** पर क्लिक करें 3. उत्पाद प्रकार के रूप में **Usage-Based** का चयन करें यह Dodo Payments को बताता है कि बिलिंग मीटर उपयोग के आधार पर होगी, कोई निश्चित सदस्यता नहीं। हमारी PixelGen AI सेवा के लिए इन सटीक मानों को भरें: **Product Name**: इसे कॉपी करें → `PixelGen AI - Image Generation` **Description**: इसे कॉपी करें → `AI-powered image generation service with pay-per-use billing` **उत्पाद छवि**: एक स्पष्ट, प्रासंगिक छवि अपलोड करें। ये ग्राहक चालानों पर दिखाई देंगे, इसलिए इन्हें स्पष्ट और पेशेवर बनाएं। अपने मीटर को कनेक्ट करने से पहले, सुनिश्चित करें कि आपने अपने उत्पाद के लिए मूल्य प्रकार के रूप में **उपयोग आधारित बिलिंग** चुना है। इसके अतिरिक्त, **Fixed Price** को `0` पर सेट करें ताकि ग्राहकों से केवल उनके उपयोग के आधार पर शुल्क लिया जाए, कोई बुनियादी शुल्क नहीं। अब, आपने जो मीटर बनाया है उसे लिंक करें: 1. **संबंधित मीटर** अनुभाग में स्क्रॉल करें 2. **मीटर जोड़ें** पर क्लिक करें 3. ड्रॉपडाउन से **"इमेज जनरेशन मीटर"** (जो आपने पहले बनाया था) चुनें 4. पुष्टि करें कि यह आपके उत्पाद कॉन्फ़िगरेशन में दिखाई देता है आपका मीटर अब इस उत्पाद से सफलतापूर्वक जुड़ चुका है। यहां हम अपने व्यापार मॉडल को परिभाषित करते हैं: **Price Per Unit**: दर्ज करें → `0.05` (यह प्रति छवि \$0.05 है) **Free Threshold**: दर्ज करें → `10` (ग्राहकों को प्रति माह 10 मुफ्त छवियां मिलती हैं) **बिलिंग कैसे काम करती है**: यदि कोई ग्राहक एक महीने में 25 छवियां उत्पन्न करता है, तो उन्हें 15 छवियों (25 - 10 मुफ्त) का शुल्क लिया जाएगा = 15 × $0.05 = $0.75 1. अपनी सभी सेटिंग्स की समीक्षा करें: * नाम: PixelGen AI - Image Generation * मीटर: Image Generation Meter * मूल्य: प्रति छवि \$0.05 * मुफ्त स्तर: 10 छवियां 2. **Save Changes** पर क्लिक करें **Product बनाया गया!** आपकी बिलिंग अब कॉन्फ़िगर हो चुकी है। ग्राहकों से उनके छवि उत्पादन उपयोग के आधार पर स्वचालित रूप से शुल्क लिया जाएगा। ## चरण 3: एक परीक्षण खरीदारी करें हम उपयोग घटनाओं को प्राप्त करना शुरू करने से पहले, हमें एक परीक्षण खरीदारी करने की आवश्यकता है। 1. अपने Dodo Payments डैशबोर्ड में **Products** पर जाएं 2. अपने "PixelGen AI - Image Generation" उत्पाद को ढूंढें 3. अपने उत्पाद के पास **Share** बटन पर क्लिक करें 4. जो भुगतान लिंक प्रदर्शित होता है उसे कॉपी करें भुगतान लिंक कुछ ऐसा दिखाई देगा: `https://test.checkout.dodopayments.com/buy/pdt_IgPWlRsfpbPd5jQKezzW1?quantity=1` 1. नए ब्राउज़र टैब में भुगतान लिंक खोलें 2. परीक्षण भुगतान विवरण दर्ज करें और खरीदारी पूरी करें। सफल भुगतान के बाद, आपको एक ग्राहक आईडी मिलेगी जिसे हम अपने एप्लिकेशन कोड में उपयोग करेंगे। 1. अपनी Dodo Payments डैशबोर्ड पर वापस जाएँ 2. साइडबार में **बिक्री → ग्राहक** पर जाएं 3. उस ग्राहक को खोजें जिसे आपने अभी बनाया है (परीक्षण ईमेल के साथ) 4. ग्राहक ID की प्रतिलिपि बनाएँ - यह इस तरह दिखेगा `cus_abc123def456` इस ग्राहक ID को सहेजें - हम इसे अपने नमूना एप्लिकेशन कोड में हार्डकोड करेंगे ताकि इवेंट्स सही ढंग से ट्रैक हों। ## चरण 4: नमूना एप्लिकेशन बनाएं अब हमारे पास हमारी बिलिंग सेटअप पूरी है और एक परीक्षण ग्राहक बनाया गया है। चलिए PixelGen AI एप्लिकेशन बनाते हैं जो इमेज उत्पन्न करता है और स्वचालित रूप से बिलिंग के लिए उपयोग को ट्रैक करता है। एक नया निर्देशिका बनाएं और परियोजना को प्रारंभ करें: ```bash theme={null} mkdir pixelgen-ai cd pixelgen-ai npm init -y ``` हमें जिन पैकेजों की आवश्यकता है उन्हें इंस्टॉल करें: ```bash theme={null} npm install openai dotenv npm install -D typescript @types/node ts-node ``` `index.ts` नाम की एक फ़ाइल बनाएं और इस संपूर्ण एप्लिकेशन कोड को कॉपी करें: यहां PixelGen AI एप्लिकेशन है जिसमें एकीकृत बिलिंग है: ```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 { 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 { 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" } } ``` ## चरण 5: अपने नमूना एप्लिकेशन का परीक्षण करें अब हमारे नमूना PixelGen AI सेवा का परीक्षण करने का समय है और देखें कि बिलिंग कैसे काम करती है! आइए सुनिश्चित करें कि सब कुछ अंत से अंत तक काम करता है। **हम जो परीक्षण कर रहे हैं**: हम कुछ छवियां बनाएंगे, पुष्टि करेंगे कि इवेंट्स Dodo Payments तक पहुंच रहे हैं, और बिलिंग गणनाएं सही हैं या नहीं यह सुनिश्चित करेंगे। सबसे पहले, सुनिश्चित करें कि आपके पास सब कुछ कॉन्फ़िगर है: 1. अपने `pixelgen-ai` निर्देशिका में `.env` फ़ाइल बनाएं 2. अपने वास्तविक API कुंजी जोड़ें: ```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. निर्भरताएँ स्थापित करें और ऐप चलाएं: ```bash theme={null} npm install npm start ``` सुनिश्चित करें कि आप वास्तविक API कुंजियाँ उपयोग कर रहे हैं और कोड में हार्डकोड की गई ग्राहक ID को चरण 3 में प्राप्त अपनी वास्तविक ग्राहक ID से अपडेट करें! जब ऐप शुरू होता है, तो आपको यह दिखाई देगा: ``` PixelGen AI - Image Generator with Usage Billing Enter your image prompt: ``` इस प्रॉम्प्ट को आजमाएं: **"एक प्यारा रोबोट एक परिदृश्य पेंट कर रहा है"** आपको इस तरह का आउटपुट देखना चाहिए: ``` 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... ``` यदि आप "Usage event sent successfully" देखते हैं, तो आपकी बिलिंग एकीकरण कार्य कर रही है! आइए 2-3 और छवियां बनाएँ ताकि कई इवेंट्स का परीक्षण हो सके। इन प्रम्प्ट्स को आज़माएँ: 1. **"बैंगनी बादलों के साथ पहाड़ों पर सूर्यास्त"** 2. **"एक विक्टोरियन रसोई में स्टीमपंक कॉफी मशीन"** 3. **"एक दोस्ताना ड्रैगन एक पुस्तक पढ़ रहा है एक पुस्तकालय में"** हर बार, "Usage event sent successfully" संदेश पर ध्यान दें। अब आइए पुष्टि करें कि इवेंट्स प्राप्त किए जा रहे हैं: 1. अपने Dodo Payments डैशबोर्ड को खोलें 2. *उपयोग बिलिंग* → \***मीटर** → **इमेज जनरेशन मीटर** पर जाएं 3. **घटनाएँ** टैब पर क्लिक करें 4. आपको अपनी इमेज जनरेशन घटनाएँ सूचीबद्ध दिखाई देनी चाहिए **किस चीज़ की तलाश करें**: * इवेंट नाम: `image.generated` * ग्राहक ID: आपकी परीक्षण ग्राहक ID आपको हर बनाई गई छवि के लिए एक इवेंट दिखाई देना चाहिए! आइए देखें कि उपयोग गणना काम कर रही है या नहीं: 1. अपने मीटर में, **ग्राहक** टैब पर जाएं 2. अपने परीक्षण ग्राहक को खोजें 3. "उपयोग की गई इकाइयाँ" कॉलम की जांच करें आइए मुफ्त स्तर से अधिक उपयोग करें ताकि बिलिंग क्रिया में देखें: 1. 8 और इमेज उत्पन्न करें (कुल 12 तक पहुँचने के लिए) 2. अपने मीटर डैशबोर्ड की फिर से जांच करें 3. आपको अब यह देखना चाहिए: * उपयोग की गई इकाइयाँ: 12 * बिल योग्य इकाइयाँ: 2 (12 - 10 मुफ्त) * बिलिंग राशि: \$0.10 **सफलता!** आपका उपयोग-आधारित बिलिंग पूरी तरह से काम कर रही है। ग्राहक वास्तविक छवि निर्माण उपयोग के आधार पर स्वचालित रूप से शुल्क दिए जाएंगे। ## समस्या निवारण सामान्य समस्याएँ और उनके समाधान: **संभावित कारण:** * इवेंट नाम मीटर कॉन्फ़िगरेशन से बिल्कुल मेल नहीं खाता * ग्राहक ID आपके खाते में मौजूद नहीं है * API कुंजी अमान्य या समाप्त हो चुकी है * नेटवर्क कनेक्टिविटी समस्याएँ **समाधान:** 1. सुनिश्चित करें कि इवेंट नाम मीटर कॉन्फ़िगरेशन से बिल्कुल मेल खाता है (केस-सेंसिटिव) 2. जांचें कि ग्राहक ID Dodo Payments में मौजूद है 3. एक सरल API कॉल के साथ API कुंजी का परीक्षण करें 4. नेटवर्क कनेक्टिविटी और फ़ायरवॉल सेटिंग्स की जांच करें ## बधाई हो! आपने PixelGen AI बनाया आपने उपयोग-आधारित बिलिंग के साथ AI इमेज जनरेशन के लिए एक स्निपेट सफलतापूर्वक बनाया है! आपने जो हासिल किया है वह यहाँ है: "Image Generation Meter" बनाया गया जो हर चित्र निर्माण इवेंट को ट्रैक करता है \$0.05 प्रति छवि के हिसाब से मूल्य निर्धारण और प्रति माह 10 मुफ्त छवियों के साथ कॉन्फ़िगर किया गया OpenAI के DALL-E का उपयोग करके एक कार्यशील TypeScript एप्लिकेशन बनाया गया वास्तविक समय इवेंट ट्रैकिंग को एकीकृत किया गया जो ग्राहकों को स्वचालित रूप से बिल करता है