User and Subscription

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({ apiKey: "your-api-key" });
// Access this API via: client.user

/**
 * @param requestOptions - Optional request configuration
 * @returns User information and subscription details
 * @throws UnprocessableEntityError if request fails
 */
client.user.get(
  requestOptions?: RequestOptions
): HttpResponsePromise<User>;

interface User {
  /** Unique user ID */
  subscription: Subscription;
  /** Whether user is a workspace member */
  is_new_user: boolean;
  /** User's xi_api_key */
  xi_api_key: string;
  /** Whether user can use Instant Voice Cloning */
  can_use_delayed_payment_methods: boolean;
}

interface Subscription {
  /** Subscription tier */
  tier: string;
  /** Character count for current period */
  character_count: number;
  /** Character limit for current period */
  character_limit: number;
  /** Whether user can extend character limit */
  can_extend_character_limit: boolean;
  /** Allowed to extend limit to this number */
  allowed_to_extend_character_limit: number;
  /** Next character count reset (Unix timestamp) */
  next_character_count_reset_unix: number;
  /** Voice limit */
  voice_limit: number;
  /** Professional voice limit */
  professional_voice_limit: number;
  /** Whether user can extend voice limit */
  can_extend_voice_limit: boolean;
  /** Whether user can use Instant Voice Cloning */
  can_use_instant_voice_cloning: boolean;
  /** Whether user can use Professional Voice Cloning */
  can_use_professional_voice_cloning: boolean;
  /** Currency for payments */
  currency?: string;
  /** Subscription status */
  status: "active" | "trialing" | "past_due" | "canceled" | "incomplete";
  /** Billing period start (Unix timestamp) */
  billing_period_start_unix?: number;
  /** Billing period end (Unix timestamp) */
  billing_period_end_unix?: number;
  /** Next invoice amount */
  next_invoice_amount?: number;
  /** Whether invoices will be sent */
  has_open_invoices?: boolean;
}

/**
 * @param requestOptions - Optional request configuration
 * @returns Subscription details
 * @throws UnprocessableEntityError if request fails
 */
client.user.subscription.get(
  requestOptions?: RequestOptions
): HttpResponsePromise<Subscription>;

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({ apiKey: "your-api-key" });

// Get user information
const user = await client.user.get();

console.log("User ID:", user.xi_api_key);
console.log("New User:", user.is_new_user);
console.log("Subscription Tier:", user.subscription.tier);

// Check remaining characters
const user = await client.user.get();
const subscription = user.subscription;

const remaining = subscription.character_limit - subscription.character_count;
const percentUsed = (subscription.character_count / subscription.character_limit) * 100;

console.log(`Characters Used: ${subscription.character_count}/${subscription.character_limit}`);
console.log(`Remaining: ${remaining} characters`);
console.log(`Usage: ${percentUsed.toFixed(1)}%`);

// Check when quota resets
const resetDate = new Date(subscription.next_character_count_reset_unix * 1000);
console.log(`Quota resets on: ${resetDate.toLocaleString()}`);

// Check if subscription is active
const user = await client.user.get();
const sub = user.subscription;

if (sub.status === "active") {
  console.log("Subscription is active");
} else if (sub.status === "past_due") {
  console.warn("Subscription payment is past due");
} else if (sub.status === "canceled") {
  console.error("Subscription has been canceled");
} else {
  console.log("Subscription status:", sub.status);
}

// Check voice cloning capabilities
const user = await client.user.get();
const sub = user.subscription;

console.log("Voice Cloning Capabilities:");
console.log(`  Instant Voice Cloning: ${sub.can_use_instant_voice_cloning ? "Available" : "Not available"}`);
console.log(`  Professional Voice Cloning: ${sub.can_use_professional_voice_cloning ? "Available" : "Not available"}`);
console.log(`  Voice Limit: ${sub.voice_limit}`);
console.log(`  Professional Voice Limit: ${sub.professional_voice_limit}`);

// Monitor character usage
async function monitorUsage(): Promise<void> {
  const user = await client.user.get();
  const sub = user.subscription;

  const percentUsed = (sub.character_count / sub.character_limit) * 100;

  if (percentUsed >= 90) {
    console.warn("⚠️ Warning: 90% of character quota used!");
  } else if (percentUsed >= 75) {
    console.log("ℹ️ Notice: 75% of character quota used");
  }

  console.log(`Current usage: ${sub.character_count}/${sub.character_limit} (${percentUsed.toFixed(1)}%)`);
}

await monitorUsage();

// Get billing period and next invoice
const user = await client.user.get();
const sub = user.subscription;

if (sub.billing_period_start_unix && sub.billing_period_end_unix) {
  const periodStart = new Date(sub.billing_period_start_unix * 1000);
  const periodEnd = new Date(sub.billing_period_end_unix * 1000);

  console.log("Billing Period:");
  console.log(`  Start: ${periodStart.toLocaleDateString()}`);
  console.log(`  End: ${periodEnd.toLocaleDateString()}`);
}

if (sub.next_invoice_amount !== undefined) {
  console.log(`Next Invoice: ${sub.currency || "USD"} ${sub.next_invoice_amount}`);
}

if (sub.has_open_invoices) {
  console.warn("You have open invoices");
}

// Check if limits can be extended
const user = await client.user.get();
const sub = user.subscription;

if (sub.can_extend_character_limit) {
  console.log(`You can extend character limit to: ${sub.allowed_to_extend_character_limit}`);
}

if (sub.can_extend_voice_limit) {
  console.log("You can extend voice limit");
}

// Display complete subscription summary
async function displaySubscriptionSummary(): Promise<void> {
  const user = await client.user.get();
  const sub = user.subscription;

  console.log("=== Subscription Summary ===\n");

  console.log(`Tier: ${sub.tier}`);
  console.log(`Status: ${sub.status}\n`);

  console.log("Character Quota:");
  console.log(`  Used: ${sub.character_count.toLocaleString()}`);
  console.log(`  Limit: ${sub.character_limit.toLocaleString()}`);
  console.log(`  Remaining: ${(sub.character_limit - sub.character_count).toLocaleString()}`);
  console.log(`  Resets: ${new Date(sub.next_character_count_reset_unix * 1000).toLocaleString()}\n`);

  console.log("Voice Cloning:");
  console.log(`  Instant: ${sub.can_use_instant_voice_cloning ? "✓" : "✗"}`);
  console.log(`  Professional: ${sub.can_use_professional_voice_cloning ? "✓" : "✗"}`);
  console.log(`  Voice Limit: ${sub.voice_limit}`);
  console.log(`  Pro Voice Limit: ${sub.professional_voice_limit}\n`);

  if (sub.billing_period_start_unix) {
    const daysLeft = Math.ceil(
      (sub.billing_period_end_unix! - Date.now() / 1000) / 86400
    );
    console.log(`Billing Period: ${daysLeft} days remaining`);
  }
}

await displaySubscriptionSummary();

// Set up usage alerts
interface UsageAlert {
  threshold: number;
  message: string;
}

const alerts: UsageAlert[] = [
  { threshold: 50, message: "50% of quota used" },
  { threshold: 75, message: "75% of quota used" },
  { threshold: 90, message: "90% of quota used - consider upgrading" },
  { threshold: 100, message: "Quota exhausted!" },
];

async function checkUsageAlerts(): Promise<void> {
  const user = await client.user.get();
  const sub = user.subscription;

  const percentUsed = (sub.character_count / sub.character_limit) * 100;

  for (const alert of alerts) {
    if (percentUsed >= alert.threshold) {
      console.log(`⚠️ ${alert.message}`);
      break; // Only show highest threshold alert
    }
  }
}

await checkUsageAlerts();

// Calculate days until character quota resets
async function daysUntilReset(): Promise<number> {
  const user = await client.user.get();
  const resetTime = user.subscription.next_character_count_reset_unix;

  const now = Date.now() / 1000;
  const secondsUntilReset = resetTime - now;
  const daysUntilReset = Math.ceil(secondsUntilReset / 86400);

  return daysUntilReset;
}

const days = await daysUntilReset();
console.log(`Quota resets in ${days} days`);

// Get only subscription information
const subscription = await client.user.subscription.get();

console.log("Tier:", subscription.tier);
console.log("Status:", subscription.status);
console.log("Character Limit:", subscription.character_limit);

// Check if specific features are available
async function checkFeatureAccess(feature: string): Promise<boolean> {
  const user = await client.user.get();
  const sub = user.subscription;

  switch (feature) {
    case "instant_voice_cloning":
      return sub.can_use_instant_voice_cloning;
    case "professional_voice_cloning":
      return sub.can_use_professional_voice_cloning;
    case "extend_character_limit":
      return sub.can_extend_character_limit;
    case "extend_voice_limit":
      return sub.can_extend_voice_limit;
    default:
      return false;
  }
}

const hasIVC = await checkFeatureAccess("instant_voice_cloning");
console.log("Can use Instant Voice Cloning:", hasIVC);

// Track usage across time
interface UsageSnapshot {
  date: string;
  character_count: number;
  character_limit: number;
}

const usageHistory: UsageSnapshot[] = [];

async function recordDailyUsage(): Promise<void> {
  const user = await client.user.get();
  const sub = user.subscription;

  usageHistory.push({
    date: new Date().toISOString(),
    character_count: sub.character_count,
    character_limit: sub.character_limit,
  });

  // Keep last 30 days
  if (usageHistory.length > 30) {
    usageHistory.shift();
  }
}

// Run daily
await recordDailyUsage();