Midjourney-Abrechnungsmodell

​

Wie Midjourney abrechnet

1. Preisstufen: Midjourney bietet vier Abonnementstufen von $10 bis $120 pro Monat an. Jede umfasst eine festgelegte Menge an Fast GPU Time.
2. Relax Mode: Die Standard- und höheren Pläne umfassen unbegrenzte Bildgenerierungen in einer Warteschlange mit niedriger Priorität, sobald die Fast Time aufgebraucht ist, sodass Nutzer nicht an eine harte Grenze stoßen.
3. Zusätzliche GPU-Stunden: Nutzer können zusätzliche Fast GPU Time für $4 pro Stunde kaufen, wenn sie nach dem Aufbrauchen ihres monatlichen Kontingents schnelle Ergebnisse benötigen.
4. Messung in GPU-Sekunden: Die Nutzung wird anhand der GPU-Zeit gemessen, die jede Generierung benötigt. Daher kosten komplexe Renderings mehr als einfache Entwürfe.
5. Community-Kreislauf: Nutzer können durch das Bewerten von Bildern kostenlose GPU-Zeit verdienen, was außerdem beim Trainieren der Midjourney-Modelle hilft.

​

Was macht es einzigartig?

• Abrechnung nach GPU-Zeit: Komplexe Renderings werden höher bepreist als einfache Entwürfe, entsprechend ihren Rechenkosten.
• Relax Mode ist eine unbegrenzte Ausweichoption, die die Abwanderung reduziert, da Nutzer auch nach dem Aufbrauchen des monatlichen Kontingents weiterhin Zugriff haben.
• Die Aufteilung in Fast und Relax fördert Upgrades, indem sie Nutzern, die Wert auf Geschwindigkeit legen, eine priorisierte Verarbeitung anbietet.
• Zusätzliche GPU-Stunden geben Power-Usern untermonatlich die Möglichkeit, ihre Kapazität mit hoher Priorität aufzustocken.

​

Mit Dodo Payments erstellen

// getCustomerUsage, getSubscription, getThresholdForPlan, and queueGeneration are
// your application's own functions. getCustomerUsage can sum this cycle's events
// from client.usageEvents.list() or read a counter your app maintains.
async function handleGenerationRequest(customerId: string, prompt: string) {
  const usage = await getCustomerUsage(customerId, 'gpu.fast_seconds');
  const subscription = await getSubscription(customerId);
  const threshold = getThresholdForPlan(subscription.product_id);
  
  if (usage.current >= threshold) {
    if (subscription.product_id === 'pdt_basic') {
      throw new Error('Fast GPU hours exhausted. Upgrade to Standard for Relax Mode.');
    }
    
    // Relax Mode. Route to low-priority queue
    return await queueGeneration(customerId, prompt, {
      priority: 'low',
      mode: 'relax',
      model: 'standard'
    });
  }
  
  // Fast Mode. Priority processing
  return await queueGeneration(customerId, prompt, {
    priority: 'high',
    mode: 'fast',
    model: 'premium'
  });
}

import DodoPayments from 'dodopayments';

async function trackFastGeneration(customerId: string, gpuSeconds: number, jobId: string) {
  // Only track Fast mode generations. Relax mode is free and unlimited
  const client = new DodoPayments({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  });

  await client.usageEvents.ingest({
    events: [{
      event_id: `gen_${jobId}`,
      customer_id: customerId,
      event_name: 'gpu.fast_seconds',
      timestamp: new Date().toISOString(),
      metadata: {
        gpu_seconds: gpuSeconds,
        resolution: '1024x1024',
        mode: 'fast'
      }
    }]
  });
}

// After customer purchases extra hours
const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_extra_gpu_hour', quantity: 5 }
  ],
  customer: { customer_id: customerId },
  return_url: 'https://yourapp.com/dashboard'
});

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_mj_standard', quantity: 1 }
  ],
  customer: { email: 'artist@example.com' },
  return_url: 'https://yourapp.com/studio'
});

​

Mit dem Time Range Ingestion Blueprint beschleunigen

npm install @dodopayments/ingestion-blueprints

import { Ingestion, trackTimeRange } from '@dodopayments/ingestion-blueprints';

const ingestion = new Ingestion({
  apiKey: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'live_mode',
  eventName: 'gpu.fast_seconds',
});

// runGeneration, prompt, settings, and customerId come from your application.
const startTime = Date.now();
const result = await runGeneration(prompt, settings);
const durationMs = Date.now() - startTime;

await trackTimeRange(ingestion, {
  customerId: customerId,
  durationMs: durationMs,
  metadata: {
    mode: 'fast',
    resolution: '1024x1024',
  },
});

​

Die Fast-vs.-Relax-Architektur

1. Alle Anfragen durchlaufen deine Anwendung.
2. Die Anwendung vergleicht die Fast-GPU-Nutzung des Kunden mit dem kostenlosen Schwellenwert des Plans.
3. Liegt die Nutzung unter dem Schwellenwert, wird die Anfrage an die Fast-Warteschlange weitergeleitet und erfasst.
4. Liegt die Nutzung über dem Schwellenwert, wird die Anfrage an die Relax-Warteschlange weitergeleitet, die nicht erfasst wird und eine niedrigere Priorität hat.
5. Der Basic-Plan verfügt über keine Relax-Ausweichoption. Daher blockiert die Anwendung Anfragen, sobald das Limit erreicht ist.

​

Verwendete zentrale Dodo-Funktionen