gamma-cost-tuning

Gamma Cost Tuning

Overview

Optimize Gamma API usage to minimize credit consumption. Gamma uses a credit-based billing system where costs are driven by image generation model tier and content complexity. API access requires Pro or higher subscription.

Prerequisites

• Active Gamma Pro/Ultra/Teams/Business subscription
• Understanding of credit system
• Completed gamma-install-auth setup

Gamma Credit System

Image Model Tiers

Card text generation also costs credits based on the AI model used.

Plan Comparison

Instructions

Step 1: Track Credit Usage

// src/gamma/cost-tracker.ts
interface UsageEntry {
  generationId: string;
  creditsUsed: number;
  outputFormat: string;
  timestamp: Date;
}

class CreditTracker {
  private usage: UsageEntry[] = [];

  record(entry: UsageEntry) {
    this.usage.push(entry);
  }

  getDaily(): { total: number; count: number; avg: number } {
    const today = new Date().toDateString();
    const todayUsage = this.usage.filter(
      (u) => u.timestamp.toDateString() === today
    );
    const total = todayUsage.reduce((sum, u) => sum + u.creditsUsed, 0);
    return {
      total,
      count: todayUsage.length,
      avg: todayUsage.length > 0 ? Math.round(total / todayUsage.length) : 0,
    };
  }

  getMonthly(): { total: number; count: number } {
    const thisMonth = new Date().getMonth();
    const monthUsage = this.usage.filter(
      (u) => u.timestamp.getMonth() === thisMonth
    );
    return {
      total: monthUsage.reduce((sum, u) => sum + u.creditsUsed, 0),
      count: monthUsage.length,
    };
  }
}

// Track after each generation
const tracker = new CreditTracker();

async function generateTracked(gamma: GammaClient, request: GenerateRequest) {
  const { generationId } = await gamma.generate(request);
  const result = await pollUntilDone(gamma, generationId);

  tracker.record({
    generationId,
    creditsUsed: result.creditsUsed ?? 0,
    outputFormat: request.outputFormat ?? "presentation",
    timestamp: new Date(),
  });

  return result;
}

Step 2: Optimize Image Costs

The biggest cost driver is image generation tier. Reduce costs by:

// EXPENSIVE: default image settings (may use Advanced/Premium tier)
await gamma.generate({
  content: "Company quarterly review",
  outputFormat: "presentation",
  // No imageOptions = AI chooses model tier
});

// CHEAPER: explicitly use standard tier when quality isn't critical
await gamma.generate({
  content: "Company quarterly review",
  outputFormat: "presentation",
  imageOptions: {
    style: "simple flat illustration", // Simpler styles use fewer credits
  },
});

// CHEAPEST: text-focused, minimal images
await gamma.generate({
  content: "Company quarterly review",
  outputFormat: "document", // Documents typically use fewer images
  textAmount: "detailed",   // Focus on text, not visuals
});

Step 3: Use Templates to Reduce Regeneration

// WASTEFUL: regenerating entire presentations for minor content changes
for (const client of clients) {
  await gamma.generate({
    content: `Proposal for ${client.name}: ${fullProposalText}`,
    outputFormat: "presentation",
  });
  // Each generation costs full credits
}

// EFFICIENT: use templates for repeated structures
// Create a one-page template gamma in the app
// Then generate variations with targeted prompts
for (const client of clients) {
  await gamma.generateFromTemplate({
    gammaId: "template_proposal_id",
    prompt: `Customize for ${client.name}. Focus on ${client.industry}.`,
    exportAs: "pdf",
  });
  // Template generations can be more cost-effective
}

Step 4: Budget Alerts

// src/gamma/budget.ts
const MONTHLY_BUDGET = 5000; // credits
const ALERT_THRESHOLDS = [0.5, 0.75, 0.9, 1.0]; // 50%, 75%, 90%, 100%

async function checkBudget(tracker: CreditTracker) {
  const { total } = tracker.getMonthly();
  const percentUsed = total / MONTHLY_BUDGET;

  for (const threshold of ALERT_THRESHOLDS) {
    if (percentUsed >= threshold) {
      await sendAlert(
        `Gamma budget ${(threshold * 100)}% used: ${total}/${MONTHLY_BUDGET} credits`
      );
    }
  }

  // Hard stop at 100%
  if (percentUsed >= 1.0) {
    throw new Error(`Monthly Gamma budget exceeded: ${total}/${MONTHLY_BUDGET} credits`);
  }
}

Step 5: Caching to Avoid Regeneration

// Cache generation results to avoid paying twice for same content
import NodeCache from "node-cache";

const generationCache = new NodeCache({ stdTTL: 86400 }); // 24 hour TTL

async function generateCached(
  gamma: GammaClient,
  request: GenerateRequest
): Promise<GenerateResult> {
  // Create cache key from request parameters
  const key = JSON.stringify({
    content: request.content,
    outputFormat: request.outputFormat,
    themeId: request.themeId,
    textMode: request.textMode,
  });

  const cached = generationCache.get<GenerateResult>(key);
  if (cached) {
    console.log("Cache hit — skipping generation");
    return cached;
  }

  const result = await generateAndWait(gamma, request);
  generationCache.set(key, result);
  return result;
}

Cost Reduction Summary

Error Handling

Resources

• Gamma Pricing
• API Access and Pricing
• Credit System Explained

Next Steps

Proceed to gamma-reference-architecture for architecture patterns.