api-keys-providers

name	api-keys-providers
description	Expert guidance for implementing AI API keys and AI providers. Use when integrating OpenAI, Anthropic, Google AI, or other AI providers, setting up AI API authentication, switching between AI providers, or managing AI service credentials.

What are AI API Keys?

AI API keys are credentials that authenticate your application with AI service providers like OpenAI, Anthropic, Google, Cohere, and others. They enable your application to make requests to AI models for tasks like text generation, image creation, code completion, and more.

When to Use AI API Keys

• Integrating AI models into your application
• Building AI-powered features (chat, code completion, image generation)
• Implementing multi-provider AI strategies
• Switching between AI providers for cost optimization
• Implementing fallback mechanisms for AI services

AI Provider Comparison

• OpenAI: GPT models, strong reasoning, widely adopted (GPT-5.5, GPT-5.4)
• Anthropic: Claude models, constitutional AI, safety-focused (Opus 4.7, Sonnet 4.6)
• Google AI: Gemini models, multimodal capabilities (Gemini 3.1 Pro, Flash)
• Mistral AI: Open-weight models, cost-effective (Mistral Large 3, Devstral 2)
• xAI (Grok): Truth-seeking LLM, real-time search (Grok 4.20)
• Cohere: Command models, RAG-focused, enterprise-friendly
• Together AI: Open-source models, custom fine-tuning
• Vercel AI Gateway: Unified API for multiple providers
• Groq: Ultra-low latency inference with LPU architecture

Setting Up AI API Keys

OpenAI

# Get API key from https://platform.openai.com/api-keys
export OPENAI_API_KEY="sk-proj-..."

const apiKey = process.env.OPENAI_API_KEY;

Latest Models (2025/2026):

• gpt-5.5 - Flagship model for complex reasoning and coding
• gpt-5.4 - More affordable model for coding and professional work
• gpt-5.4-mini - Strongest mini model for coding, computer use, subagents
• gpt-image-2 - State-of-the-art image generation
• gpt-realtime-1.5 - Best voice model for audio in/out
• gpt-4o-transcribe - Speech-to-text model

Anthropic

# Get API key from https://console.anthropic.com/
export ANTHROPIC_API_KEY="sk-ant-..."

const apiKey = process.env.ANTHROPIC_API_KEY;

Latest Models (2025/2026):

• claude-opus-4.7 - Latest flagship model
• claude-sonnet-4.6 - Balanced performance and speed
• claude-haiku-4.5 - Fast and cost-effective
• Note: Claude 3.5 Sonnet deprecated August 20, 2025

Google AI (Gemini)

# Get API key from https://makersuite.google.com/app/apikey
export GOOGLE_API_KEY="AIza..."

const apiKey = process.env.GOOGLE_API_KEY;

Latest Models (2025/2026):

• gemini-3.1-pro - Advanced intelligence, complex problem-solving
• gemini-3-flash - Frontier-class performance at lower cost
• gemini-3.1-flash-lite - Efficient frontier model
• gemini-2.5-pro - Pro-level capabilities
• gemini-2.5-flash - Fast multimodal model
• nano-banana-2 - Image generation and editing
• gemini-3.1-flash-live - Real-time dialogue API
• gemini-3.1-flash-tts - Speech generation

Mistral AI

# Get API key from https://console.mistral.ai/
export MISTRAL_API_KEY="..."

const apiKey = process.env.MISTRAL_API_KEY;

Latest Models (2025/2026):

• mistral-large-3 - State-of-the-art open-weight multimodal
• devstral-2 - Frontier code agents model
• mistral-medium-3.5 - Frontier-class multimodal for agentic/coding

xAI (Grok)

# Get API key from https://console.x.ai/
export XAI_API_KEY="..."

const apiKey = process.env.XAI_API_KEY;

Latest Models (2025/2026):

• grok-4.20 - Most truth-seeking LLM
• grok-4.20-reasoning - Reasoning variant
• Voice API - Real-time conversation and transcription
• Imagine API - Image and video generation

Vercel AI Gateway

# Get API key from https://vercel.com/dashboard
export VERCEL_AI_API_KEY="..."

const apiKey = process.env.VERCEL_AI_API_KEY;

Vercel AI Gateway provides unified access to hundreds of models through a single endpoint. It supports:

• Automatic fallbacks during provider outages
• Unified billing and observability
• Access to all major model labs
• Model string format: provider/model-name (e.g., openai/gpt-5.5)

Groq

# Get API key from https://console.groq.com/
export GROQ_API_KEY="..."

const apiKey = process.env.GROQ_API_KEY;

Groq provides ultra-low latency inference using LPU (Language Processing Unit) architecture:

• Delivers up to 300 tokens/second (10x faster than H100)
• Supports Llama, Mixtral, and other open-source models
• Ideal for real-time applications requiring low latency

Cohere

# Get API key from https://dashboard.cohere.com/api-keys
export COHERE_API_KEY="..."

const apiKey = process.env.COHERE_API_KEY;

Secure Storage for AI API Keys

Environment Variables (Recommended)

# .env file (never commit to git)
OPENAI_API_KEY=sk-proj-...
ANTHROPIC_API_KEY=sk-ant-...
GOOGLE_API_KEY=AIza...
COHERE_API_KEY=...

Using dotenv in Node.js

import dotenv from 'dotenv';
dotenv.config();

const openaiKey = process.env.OPENAI_API_KEY;
const anthropicKey = process.env.ANTHROPIC_API_KEY;

Using python-dotenv in Python

from dotenv import load_dotenv
import os

load_dotenv()

openai_key = os.environ.get('OPENAI_API_KEY')
anthropic_key = os.environ.get('ANTHROPIC_API_KEY')

Secret Management Services (Production)

• AWS Secrets Manager: Store AI API keys securely
• HashiCorp Vault: Enterprise secret management
• Google Secret Manager: Cloud-native for Google AI
• Azure Key Vault: For Azure OpenAI

AI Provider Abstraction Layer

Base AI Provider Class

class AIProvider {
  constructor(config) {
    this.apiKey = config.apiKey;
    this.model = config.model;
    this.timeout = config.timeout || 30000;
  }

  async chat(messages, options = {}) {
    throw new Error('chat() must be implemented by subclass');
  }

  async complete(prompt, options = {}) {
    throw new Error('complete() must be implemented by subclass');
  }
}

OpenAI Provider Implementation

import OpenAI from 'openai';

class OpenAIProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.client = new OpenAI({
      apiKey: this.apiKey,
      timeout: this.timeout
    });
  }

  async chat(messages, options = {}) {
    try {
      const response = await this.client.chat.completions.create({
        model: this.model,
        messages: messages,
        ...options
      });
      return response.choices[0].message;
    } catch (error) {
      throw new Error(`OpenAI API error: ${error.message}`);
    }
  }

  async complete(prompt, options = {}) {
    try {
      const response = await this.client.completions.create({
        model: this.model,
        prompt: prompt,
        ...options
      });
      return response.choices[0].text;
    } catch (error) {
      throw new Error(`OpenAI API error: ${error.message}`);
    }
  }
}

Anthropic Provider Implementation

import Anthropic from '@anthropic-ai/sdk';

class AnthropicProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.client = new Anthropic({
      apiKey: this.apiKey,
      timeout: this.timeout
    });
  }

  async chat(messages, options = {}) {
    try {
      const response = await this.client.messages.create({
        model: this.model,
        messages: messages,
        max_tokens: options.max_tokens || 1024,
        ...options
      });
      return response.content[0];
    } catch (error) {
      throw new Error(`Anthropic API error: ${error.message}`);
    }
  }

  async complete(prompt, options = {}) {
    try {
      const response = await this.client.messages.create({
        model: this.model,
        messages: [{ role: 'user', content: prompt }],
        max_tokens: options.max_tokens || 1024,
        ...options
      });
      return response.content[0];
    } catch (error) {
      throw new Error(`Anthropic API error: ${error.message}`);
    }
  }
}

Google AI Provider Implementation

import { GoogleGenerativeAI } from '@google/generative-ai';

class GoogleAIProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.client = new GoogleGenerativeAI(this.apiKey);
  }

  async chat(messages, options = {}) {
    try {
      const model = this.client.getGenerativeModel(this.model);
      const chat = model.startChat();
      const response = await chat.sendMessage(messages[messages.length - 1].content);
      return response.response.text();
    } catch (error) {
      throw new Error(`Google AI API error: ${error.message}`);
    }
  }

  async complete(prompt, options = {}) {
    try {
      const model = this.client.getGenerativeModel(this.model);
      const response = await model.generateContent(prompt);
      return response.response.text();
    } catch (error) {
      throw new Error(`Google AI API error: ${error.message}`);
    }
  }
}

Mistral AI Provider Implementation

import Mistral from '@mistralai/mistralai';

class MistralProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.client = new Mistral({
      apiKey: this.apiKey,
      timeout: this.timeout
    });
  }

  async chat(messages, options = {}) {
    try {
      const response = await this.client.chat.complete({
        model: this.model,
        messages: messages,
        ...options
      });
      return response.choices[0].message;
    } catch (error) {
      throw new Error(`Mistral API error: ${error.message}`);
    }
  }

  async complete(prompt, options = {}) {
    try {
      const response = await this.client.chat.complete({
        model: this.model,
        messages: [{ role: 'user', content: prompt }],
        ...options
      });
      return response.choices[0].message.content;
    } catch (error) {
      throw new Error(`Mistral API error: ${error.message}`);
    }
  }
}

xAI (Grok) Provider Implementation

import { Client } from '@xai-sdk';

class XAIProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.client = new Client({
      apiKey: this.apiKey,
      timeout: this.timeout
    });
  }

  async chat(messages, options = {}) {
    try {
      const chat = this.client.chat.create({
        model: this.model,
        messages: messages,
        ...options
      });
      return chat;
    } catch (error) {
      throw new Error(`xAI API error: ${error.message}`);
    }
  }

  async complete(prompt, options = {}) {
    try {
      const chat = this.client.chat.create({
        model: this.model,
        messages: [{ role: 'user', content: prompt }],
        ...options
      });
      return chat;
    } catch (error) {
      throw new Error(`xAI API error: ${error.message}`);
    }
  }
}

Vercel AI Gateway Provider Implementation

import { createOpenAI } from '@ai-sdk/openai';

class VercelGatewayProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.client = createOpenAI({
      baseURL: 'https://api.openai.com/v1',
      apiKey: this.apiKey,
    });
  }

  async chat(messages, options = {}) {
    try {
      const response = await this.client.chat.completions.create({
        model: this.model, // Format: provider/model-name
        messages: messages,
        ...options
      });
      return response.choices[0].message;
    } catch (error) {
      throw new Error(`Vercel AI Gateway error: ${error.message}`);
    }
  }

  async complete(prompt, options = {}) {
    try {
      const response = await this.client.chat.completions.create({
        model: this.model,
        messages: [{ role: 'user', content: prompt }],
        ...options
      });
      return response.choices[0].message.content;
    } catch (error) {
      throw new Error(`Vercel AI Gateway error: ${error.message}`);
    }
  }
}

Groq Provider Implementation

import Groq from 'groq-sdk';

class GroqProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.client = new Groq({
      apiKey: this.apiKey,
      timeout: this.timeout
    });
  }

  async chat(messages, options = {}) {
    try {
      const response = await this.client.chat.completions.create({
        model: this.model,
        messages: messages,
        ...options
      });
      return response.choices[0].message;
    } catch (error) {
      throw new Error(`Groq API error: ${error.message}`);
    }
  }

  async complete(prompt, options = {}) {
    try {
      const response = await this.client.chat.completions.create({
        model: this.model,
        messages: [{ role: 'user', content: prompt }],
        ...options
      });
      return response.choices[0].message.content;
    } catch (error) {
      throw new Error(`Groq API error: ${error.message}`);
    }
  }
}

Multi-Provider AI Manager

Provider Manager Class

class AIProviderManager {
  constructor() {
    this.providers = new Map();
    this.defaultProvider = null;
  }

  registerProvider(name, config) {
    switch (name) {
      case 'openai':
        this.providers.set(name, new OpenAIProvider(config));
        break;
      case 'anthropic':
        this.providers.set(name, new AnthropicProvider(config));
        break;
      case 'google':
        this.providers.set(name, new GoogleAIProvider(config));
        break;
      case 'mistral':
        this.providers.set(name, new MistralProvider(config));
        break;
      case 'xai':
        this.providers.set(name, new XAIProvider(config));
        break;
      case 'vercel':
        this.providers.set(name, new VercelGatewayProvider(config));
        break;
      case 'groq':
        this.providers.set(name, new GroqProvider(config));
        break;
      default:
        throw new Error(`Unknown provider: ${name}`);
    }
  }

  setDefaultProvider(name) {
    if (!this.providers.has(name)) {
      throw new Error(`Provider ${name} not registered`);
    }
    this.defaultProvider = name;
  }

  getProvider(name) {
    const providerName = name || this.defaultProvider;
    const provider = this.providers.get(providerName);
    if (!provider) {
      throw new Error(`Provider ${providerName} not found`);
    }
    return provider;
  }

  async chat(messages, options = {}) {
    const provider = this.getProvider(options.provider);
    return await provider.chat(messages, options);
  }

  async complete(prompt, options = {}) {
    const provider = this.getProvider(options.provider);
    return await provider.complete(prompt, options);
  }
}

Usage Example

const manager = new AIProviderManager();

// Register providers with latest models
manager.registerProvider('openai', {
  apiKey: process.env.OPENAI_API_KEY,
  model: 'gpt-5.5'
});

manager.registerProvider('anthropic', {
  apiKey: process.env.ANTHROPIC_API_KEY,
  model: 'claude-opus-4.7'
});

manager.registerProvider('google', {
  apiKey: process.env.GOOGLE_API_KEY,
  model: 'gemini-3.1-pro'
});

manager.registerProvider('mistral', {
  apiKey: process.env.MISTRAL_API_KEY,
  model: 'mistral-large-3'
});

manager.registerProvider('xai', {
  apiKey: process.env.XAI_API_KEY,
  model: 'grok-4.20'
});

manager.registerProvider('vercel', {
  apiKey: process.env.VERCEL_AI_API_KEY,
  model: 'openai/gpt-5.5' // Format: provider/model-name
});

manager.registerProvider('groq', {
  apiKey: process.env.GROQ_API_KEY,
  model: 'llama-3.3-70b-versatile'
});

// Set default
manager.setDefaultProvider('openai');

// Use default provider
const response1 = await manager.chat([
  { role: 'user', content: 'Hello!' }
]);

// Use specific provider
const response2 = await manager.chat([
  { role: 'user', content: 'Hello!' }
], { provider: 'anthropic' });

// Use Vercel AI Gateway for automatic fallbacks
const response3 = await manager.chat([
  { role: 'user', content: 'Hello!' }
], { provider: 'vercel' });

// Use Groq for ultra-low latency
const response4 = await manager.chat([
  { role: 'user', content: 'Hello!' }
], { provider: 'groq' });

Provider Switching and Fallback

Fallback Strategy

class AIProviderWithFallback {
  constructor(manager) {
    this.manager = manager;
    this.fallbackOrder = ['openai', 'anthropic', 'google', 'mistral', 'xai'];
  }

  async chatWithFallback(messages, options = {}) {
    for (const providerName of this.fallbackOrder) {
      try {
        const response = await this.manager.chat(messages, {
          ...options,
          provider: providerName
        });
        return { provider: providerName, response };
      } catch (error) {
        console.warn(`${providerName} failed: ${error.message}`);
        continue;
      }
    }
    throw new Error('All AI providers failed');
  }
}

Cost-Based Provider Selection

class CostOptimizedProvider {
  constructor(manager) {
    this.manager = manager;
    this.costs = {
      'openai': { 'gpt-5.4-mini': 0.0025, 'gpt-5.4': 0.025, 'gpt-5.5': 0.15 },
      'anthropic': { 'claude-haiku-4.5': 0.00025, 'claude-sonnet-4.6': 0.003, 'claude-opus-4.7': 0.015 },
      'google': { 'gemini-3.1-flash-lite': 0.0001, 'gemini-3-flash': 0.0005, 'gemini-3.1-pro': 0.01 },
      'mistral': { 'mistral-medium-3.5': 0.002, 'mistral-large-3': 0.004 },
      'xai': { 'grok-4.20': 0.02 }
    };
  }

  getCheapestProvider(task) {
    let cheapest = null;
    let lowestCost = Infinity;

    for (const [provider, models] of Object.entries(this.costs)) {
      for (const [model, cost] of Object.entries(models)) {
        if (cost < lowestCost) {
          lowestCost = cost;
          cheapest = { provider, model, cost };
        }
      }
    }

    return cheapest;
  }

  async chat(messages, options = {}) {
    const cheapest = this.getCheapestProvider();
    return await this.manager.chat(messages, {
      ...options,
      provider: cheapest.provider
    });
  }
}

Model-Specific Configurations

OpenAI Models (2025/2026)

const openaiModels = {
  'gpt-5.5': { context: 1000000, cost: 0.15 }, // Flagship
  'gpt-5.4': { context: 128000, cost: 0.025 }, // Affordable
  'gpt-5.4-mini': { context: 128000, cost: 0.0025 }, // Mini
  'gpt-image-2': { context: 0, cost: 0.015 }, // Image generation
  'gpt-realtime-1.5': { context: 0, cost: 0.01 }, // Voice
};

Anthropic Models (2025/2026)

const anthropicModels = {
  'claude-opus-4.7': { context: 200000, cost: 0.015 }, // Flagship
  'claude-sonnet-4.6': { context: 200000, cost: 0.003 }, // Balanced
  'claude-haiku-4.5': { context: 200000, cost: 0.00025 }, // Fast
};

Google AI Models (2025/2026)

const googleModels = {
  'gemini-3.1-pro': { context: 1000000, cost: 0.01 }, // Advanced
  'gemini-3-flash': { context: 1000000, cost: 0.0005 }, // Fast
  'gemini-3.1-flash-lite': { context: 1000000, cost: 0.0001 }, // Lite
  'gemini-2.5-pro': { context: 1000000, cost: 0.005 }, // Pro
  'gemini-2.5-flash': { context: 1000000, cost: 0.0005 }, // Flash
  'nano-banana-2': { context: 0, cost: 0.002 }, // Image
};

Mistral AI Models (2025/2026)

const mistralModels = {
  'mistral-large-3': { context: 128000, cost: 0.004 },
  'devstral-2': { context: 128000, cost: 0.003 },
  'mistral-medium-3.5': { context: 128000, cost: 0.002 },
};

xAI (Grok) Models (2025/2026)

const xaiModels = {
  'grok-4.20': { context: 128000, cost: 0.02 },
  'grok-4.20-reasoning': { context: 128000, cost: 0.025 },
};

Rate Limiting and Quotas

Implementing Rate Limits

class RateLimitedAIProvider extends AIProvider {
  constructor(config) {
    super(config);
    this.rateLimiter = new RateLimiter(config.rateLimit);
  }

  async chat(messages, options = {}) {
    await this.rateLimiter.check(this.apiKey);
    return await super.chat(messages, options);
  }
}

class RateLimiter {
  constructor({ requestsPerMinute, requestsPerHour }) {
    this.rpm = requestsPerMinute;
    this.rph = requestsPerHour;
    this.requests = new Map();
  }

  async check(apiKey) {
    const now = Date.now();
    const minuteWindow = 60000;
    const hourWindow = 3600000;

    if (!this.requests.has(apiKey)) {
      this.requests.set(apiKey, []);
    }

    const requests = this.requests.get(apiKey);
    const minuteRequests = requests.filter(t => now - t < minuteWindow);
    const hourRequests = requests.filter(t => now - t < hourWindow);

    if (minuteRequests.length >= this.rpm) {
      throw new Error('Rate limit exceeded (per minute)');
    }
    if (hourRequests.length >= this.rph) {
      throw new Error('Rate limit exceeded (per hour)');
    }

    requests.push(now);
  }
}

Best Practices

Key Security

• Never commit AI API keys to version control
• Use environment variables or secret managers
• Rotate keys regularly (every 90 days)
• Use different keys for different environments
• Monitor usage for unusual patterns
• Implement IP restrictions when available

Provider Selection

• Choose provider based on task requirements
• Consider cost vs performance trade-offs
• Implement fallback mechanisms
• Test with multiple providers before production
• Monitor provider uptime and reliability

Error Handling

• Implement retry logic with exponential backoff
• Handle rate limit errors gracefully
• Log errors for debugging
• Provide meaningful error messages to users
• Implement circuit breakers for failing providers

Cost Management

• Track token usage and costs
• Use cheaper models for non-critical tasks
• Implement caching for repeated requests
• Set budget limits and alerts
• Monitor spending regularly

Performance

• Use streaming responses for long generations
• Implement request batching when possible
• Cache model responses for identical inputs
• Use appropriate model for task complexity
• Monitor latency and optimize bottlenecks

Common Gotchas

Model Context Limits

• Check context window before sending large prompts
• Implement context window management
• Truncate or summarize long inputs
• Use models with larger context for complex tasks

Rate Limiting

• Implement proper rate limiting
• Handle 429 errors with backoff
• Distribute load across multiple keys
• Monitor rate limit usage

API Key Format

• OpenAI: sk-proj-... or sk-...
• Anthropic: sk-ant-...
• Google: AIza...
• Cohere: Various formats

Streaming Responses

• Different providers handle streaming differently
• Implement streaming for real-time responses
• Handle streaming errors gracefully
• Consider timeout for streaming

Model Availability

• Not all models are available in all regions
• Check model availability before use
• Implement fallback to available models
• Handle model deprecation

When to Use Different Providers

Use OpenAI when:

• You need strong reasoning capabilities
• You need wide model selection
• You need image generation (DALL-E)
• You need function calling

Use Anthropic when:

• You need constitutional AI safety
• You need large context windows
• You need strong coding capabilities
• You value safety and alignment

Use Google AI when:

• You need multimodal capabilities
• You need free tier availability
• You need Google ecosystem integration
• You need vision capabilities

Use Cohere when:

• You need RAG-focused models
• You need enterprise support
• You need custom fine-tuning
• You need embedding models

Use Open-Source (Together, Mistral) when:

• You need cost-effective solutions
• You want to self-host models
• You need data privacy
• You want to customize models