Documentation

# Add to your .env file
PARMOT_API_KEY="parmot_your_api_key_here"
OPENAI_API_KEY="your_openai_api_key_here"
ANTHROPIC_API_KEY="your_anthropic_api_key_here"
COHERE_API_KEY="your_cohere_api_key_here"

// Streaming responses are automatically tracked
const stream = await client.chat.completions.create({
  model: "gpt-4o-mini", 
  messages: [{ role: "user", content: "Count to 10" }],
  stream: true,
  user_id: "user_123"
});

for await (const chunk of stream) {
  if (chunk.choices[0]?.delta?.content) {
    process.stdout.write(chunk.choices[0].delta.content);
  }
}

// Usage is automatically recorded when stream completes

import { TrackedAnthropic } from "parmot";

const client = new TrackedAnthropic({
  apiKey: "your_anthropic_api_key",
  parmotApiKey: "your_parmot_api_key"
});

// Non-streaming
const response = await client.messages.create({
  max_tokens: 100,
  messages: [{ role: "user", content: "Hello!" }],
  model: "claude-3-5-haiku-20241022",
  user_id: "user_123"
});

console.log(response.content[0].text);

// Streaming  
const stream = await client.messages.create({
  max_tokens: 100,
  messages: [{ role: "user", content: "Tell me a joke." }],
  model: "claude-3-5-haiku-20241022",
  user_id: "user_123",
  stream: true
});

for await (const event of stream) {
  if (event.delta?.text) {
    process.stdout.write(event.delta.text);
  }
}

import { TrackedCohere } from "parmot";

const client = new TrackedCohere({
  apiKey: "your_cohere_api_key",
  parmotApiKey: "your_parmot_api_key"
});

// Non-streaming (not yet implemented in TypeScript SDK)
// Streaming (not yet implemented in TypeScript SDK)

import Stripe from 'stripe';
const stripe = new Stripe("sk_your_stripe_key");

// When creating a Stripe subscription, include the end user ID in metadata
const subscription = await stripe.subscriptions.create({
  customer: "cus_customer_id",
  items: [{
    price: "price_your_stripe_price_id",
  }],
  metadata: {
    end_user_id: "user_123"  // Your app's end user ID
  }
});

import Stripe from 'stripe';
import express from 'express';
import { ParmotClient } from 'parmot';

const app = express();
const stripe = new Stripe("sk_your_stripe_key");
const parmot = new ParmotClient();

app.post('/stripe/webhook', express.raw({type: 'application/json'}), async (req, res) => {
  const sig = req.headers['stripe-signature'];
  
  let event;
  try {
    event = stripe.webhooks.constructEvent(req.body, sig, "whsec_your_webhook_secret");
  } catch (err) {
    console.log(`Webhook signature verification failed.`, err.message);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  switch (event.type) {
    case 'invoice.payment_succeeded':
      // Get end user ID from subscription metadata
      const subscriptionId = event.data.object.subscription;
      const subscription = await stripe.subscriptions.retrieve(subscriptionId);
      const endUserId = subscription.metadata?.end_user_id;
      
      if (endUserId) {
        // Move user to paid plan
        await parmot.assignEndUserToPlan(endUserId, "Pro");
      }
      break;
      
    case 'invoice.payment_failed':
      // Get end user ID from subscription metadata
      const failedSubscriptionId = event.data.object.subscription;
      const failedSubscription = await stripe.subscriptions.retrieve(failedSubscriptionId);
      const failedEndUserId = failedSubscription.metadata?.end_user_id;
      
      if (failedEndUserId) {
        // Move user to free plan  
        await parmot.assignEndUserToPlan(failedEndUserId, "Free");
      }
      break;
  }

  res.json({received: true});
});

import { 
  TrackedOpenAI, 
  ParmotEndUserUsageLimitError,
  ParmotEndUserRateLimitError 
} from "parmot";

const client = new TrackedOpenAI();

try {
  const response = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: "Hello!" }],
    user_id: "user_123"
  });
} catch (error) {
  if (error instanceof ParmotEndUserUsageLimitError) {
    console.log(`Usage limit exceeded: ${error.message}`);
    console.log(`Current usage: ${error.current_usage}`);
    console.log(`Limit: ${error.limit}`);
    console.log(`Limit type: ${error.limit_type}`);
    // Handle limit exceeded - maybe upgrade user plan
  } else if (error instanceof ParmotEndUserRateLimitError) {
    console.log(`Rate limit exceeded: ${error.message}`);
    console.log(`Retry after: ${error.retry_after} seconds`);
  } else {
    console.log(`Other error: ${error}`);
  }
}