API Guides

Authentication Guide

All API Codex APIs use RapidAPI's authentication system for secure access. This guide covers everything you need to know about authenticating your requests.

Overview

API Codex APIs are accessed through RapidAPI's infrastructure, which provides:

Unified Authentication: Single API key for all services
Automatic Key Management: Built-in rotation and security
Usage Tracking: Real-time monitoring and analytics
Enhanced Security: Enterprise-grade protection

Getting Your API Key

Step 1: Create RapidAPI Account

Visit RapidAPI.com
Click "Sign Up" and create your free account
Verify your email address
Complete your profile setup

Navigate to API Codex Organization
Choose the API you want to use
Click "Subscribe" and select a plan (free tier available)
Your API key is automatically generated

Step 3: Find Your API Key

Your RapidAPI key can be found in multiple locations:

RapidAPI Dashboard: Navigate to "My Apps" → "Security"
API Endpoint Page: Your key is included in code snippets
Developer Dashboard: Under "Default Application"

Authentication Headers

All API requests require two headers:

Code
 
x-rapidapi-key: YOUR_RAPIDAPI_KEY
x-rapidapi-host: API_HOST_NAME

Header Requirements

Header	Description	Example
`x-rapidapi-key`	Your unique RapidAPI key	`a1b2c3d4e5f6g7h8i9j0`
`x-rapidapi-host`	The API host endpoint	`advanced-dns-lookup-api.p.rapidapi.com`

Implementation Examples

JavaScript/Node.js

Code
 
const axios = require('axios');

// Store your key securely
const RAPIDAPI_KEY = process.env.RAPIDAPI_KEY;

// Configuration object
const config = {
  headers: {
    'x-rapidapi-key': RAPIDAPI_KEY,
    'x-rapidapi-host': 'advanced-dns-lookup-api.p.rapidapi.com'
  }
};

// Make authenticated request
async function makeAuthenticatedRequest() {
  try {
    const response = await axios.get(
      'https://advanced-dns-lookup-api.p.rapidapi.com/v1/check?name=example.com',
      config
    );
    console.log(response.data);
  } catch (error) {
    console.error('Authentication failed:', error.response?.data);
  }
}

Python

Code
 
import os
import requests
from typing import Dict, Any

class APICodexClient:
    def __init__(self):
        self.api_key = os.environ.get('RAPIDAPI_KEY')
        if not self.api_key:
            raise ValueError("RAPIDAPI_KEY environment variable not set")
        
        self.headers = {
            'x-rapidapi-key': self.api_key,
            'x-rapidapi-host': 'advanced-dns-lookup-api.p.rapidapi.com'
        }
    
    def make_request(self, endpoint: str, params: Dict[str, Any] = None):
        """Make authenticated API request"""
        try:
            response = requests.get(
                f"https://advanced-dns-lookup-api.p.rapidapi.com{endpoint}",
                headers=self.headers,
                params=params
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.HTTPError as e:
            print(f"Authentication error: {e}")
            return None

# Usage
client = APICodexClient()
result = client.make_request('/v1/check', {'name': 'example.com'})

PHP

Code
 
<?php

class APICodexAuth {
    private $apiKey;
    private $headers;
    
    public function __construct() {
        $this->apiKey = $_ENV['RAPIDAPI_KEY'] ?? getenv('RAPIDAPI_KEY');
        
        if (empty($this->apiKey)) {
            throw new Exception('RAPIDAPI_KEY not configured');
        }
        
        $this->headers = [
            'x-rapidapi-key: ' . $this->apiKey,
            'x-rapidapi-host: advanced-dns-lookup-api.p.rapidapi.com'
        ];
    }
    
    public function request($endpoint, $params = []) {
        $url = 'https://advanced-dns-lookup-api.p.rapidapi.com' . $endpoint;
        
        if (!empty($params)) {
            $url .= '?' . http_build_query($params);
        }
        
        $curl = curl_init();
        curl_setopt_array($curl, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => $this->headers,
            CURLOPT_SSL_VERIFYPEER => true,
            CURLOPT_SSL_VERIFYHOST => 2
        ]);
        
        $response = curl_exec($curl);
        $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
        curl_close($curl);
        
        if ($httpCode !== 200) {
            throw new Exception('Authentication failed: HTTP ' . $httpCode);
        }
        
        return json_decode($response, true);
    }
}

// Usage
$client = new APICodexAuth();
$result = $client->request('/v1/check', ['name' => 'example.com']);

Security Best Practices

1. Never Expose Keys in Client-Side Code

❌ Bad Practice:

Code
 
// Never do this in frontend code
const API_KEY = 'a1b2c3d4e5f6g7h8i9j0'; // Exposed to users!

✅ Good Practice:

Code
 
// Backend proxy endpoint
app.post('/api/dns-lookup', async (req, res) => {
  const response = await fetch(apiUrl, {
    headers: {
      'x-rapidapi-key': process.env.RAPIDAPI_KEY, // Server-side only
      'x-rapidapi-host': 'advanced-dns-lookup-api.p.rapidapi.com'
    }
  });
  res.json(await response.json());
});

2. Use Environment Variables

.env file:

Code
 
RAPIDAPI_KEY=your_actual_api_key_here
RAPIDAPI_HOST=advanced-dns-lookup-api.p.rapidapi.com

Node.js:

Code
 
require('dotenv').config();

const headers = {
  'x-rapidapi-key': process.env.RAPIDAPI_KEY,
  'x-rapidapi-host': process.env.RAPIDAPI_HOST
};

Python:

Code
 
import os
from dotenv import load_dotenv

load_dotenv()

headers = {
    'x-rapidapi-key': os.getenv('RAPIDAPI_KEY'),
    'x-rapidapi-host': os.getenv('RAPIDAPI_HOST')
}

3. Implement Key Rotation

Code
 
class APIKeyManager {
  constructor() {
    this.primaryKey = process.env.RAPIDAPI_KEY_PRIMARY;
    this.secondaryKey = process.env.RAPIDAPI_KEY_SECONDARY;
    this.useSecondary = false;
  }
  
  getCurrentKey() {
    return this.useSecondary ? this.secondaryKey : this.primaryKey;
  }
  
  rotateKey() {
    this.useSecondary = !this.useSecondary;
    console.log(`Switched to ${this.useSecondary ? 'secondary' : 'primary'} key`);
  }
  
  async makeRequest(url, options = {}) {
    options.headers = {
      ...options.headers,
      'x-rapidapi-key': this.getCurrentKey()
    };
    
    try {
      const response = await fetch(url, options);
      
      if (response.status === 403) {
        // Try with alternate key
        this.rotateKey();
        options.headers['x-rapidapi-key'] = this.getCurrentKey();
        return fetch(url, options);
      }
      
      return response;
    } catch (error) {
      console.error('Request failed:', error);
      throw error;
    }
  }
}

4. Secure Storage Options

Development Environment

Use .env files (never commit to version control)
Add .env to .gitignore

Production Environment

AWS: AWS Secrets Manager or Parameter Store
Azure: Azure Key Vault
Google Cloud: Secret Manager
Heroku: Config Vars
Vercel: Environment Variables
Docker: Docker Secrets

Example with AWS Secrets Manager:

Code
 
const AWS = require('aws-sdk');
const secretsManager = new AWS.SecretsManager();

async function getAPIKey() {
  try {
    const secret = await secretsManager.getSecretValue({
      SecretId: 'rapidapi-key'
    }).promise();
    
    return JSON.parse(secret.SecretString).apiKey;
  } catch (error) {
    console.error('Failed to retrieve API key:', error);
    throw error;
  }
}

5. Implement Request Signing (Optional)

For additional security, implement request signing:

Code
 
const crypto = require('crypto');

function signRequest(apiKey, timestamp, body = '') {
  const message = `${timestamp}${body}`;
  const signature = crypto
    .createHmac('sha256', apiKey)
    .update(message)
    .digest('hex');
  
  return signature;
}

function makeSignedRequest(url, apiKey) {
  const timestamp = Date.now();
  const signature = signRequest(apiKey, timestamp);
  
  return fetch(url, {
    headers: {
      'x-rapidapi-key': apiKey,
      'x-rapidapi-host': 'advanced-dns-lookup-api.p.rapidapi.com',
      'x-timestamp': timestamp,
      'x-signature': signature
    }
  });
}

Authentication Errors

Common Authentication Issues

Error Code	Description	Solution
401	Invalid or missing API key	Check your API key is correct
403	Forbidden - Key not authorized	Verify subscription status
429	Too many requests	Implement rate limiting
503	Service temporarily unavailable	Retry with exponential backoff

Error Handling Example

Code
 
async function handleAuthErrors(response) {
  if (!response.ok) {
    switch (response.status) {
      case 401:
        throw new Error('Invalid API key. Please check your credentials.');
      case 403:
        throw new Error('Access forbidden. Check your subscription status.');
      case 429:
        const retryAfter = response.headers.get('Retry-After');
        throw new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds.`);
      case 503:
        throw new Error('Service unavailable. Please try again later.');
      default:
        throw new Error(`Authentication failed: ${response.statusText}`);
    }
  }
  return response;
}

// Usage
fetch(apiUrl, { headers })
  .then(handleAuthErrors)
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error(error));

Testing Authentication

Quick Test Script

Code
 
# Test your API key with curl
curl -X GET "https://advanced-dns-lookup-api.p.rapidapi.com/v1/check?name=test.com" \
  -H "x-rapidapi-key: YOUR_API_KEY" \
  -H "x-rapidapi-host: advanced-dns-lookup-api.p.rapidapi.com"

Node.js Test Script

Code
 
const https = require('https');

function testAuthentication(apiKey) {
  const options = {
    hostname: 'advanced-dns-lookup-api.p.rapidapi.com',
    path: '/v1/check?name=test.com',
    method: 'GET',
    headers: {
      'x-rapidapi-key': apiKey,
      'x-rapidapi-host': 'advanced-dns-lookup-api.p.rapidapi.com'
    }
  };
  
  return new Promise((resolve, reject) => {
    const req = https.request(options, (res) => {
      let data = '';
      
      res.on('data', (chunk) => {
        data += chunk;
      });
      
      res.on('end', () => {
        if (res.statusCode === 200) {
          console.log('✅ Authentication successful!');
          resolve(JSON.parse(data));
        } else {
          console.error('❌ Authentication failed:', res.statusCode);
          reject(new Error(`HTTP ${res.statusCode}: ${data}`));
        }
      });
    });
    
    req.on('error', reject);
    req.end();
  });
}

// Test your key
testAuthentication(process.env.RAPIDAPI_KEY)
  .then(result => console.log('Test result:', result))
  .catch(error => console.error('Test failed:', error));

Multi-API Authentication

When using multiple API Codex APIs, you can reuse the same RapidAPI key:

Code
 
class APICodexMultiClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.apis = {
      dns: 'advanced-dns-lookup-api.p.rapidapi.com',
      email: 'email-intelligence-api.p.rapidapi.com',
      text: 'text-analysis-api.p.rapidapi.com'
    };
  }
  
  async request(service, endpoint, params = {}) {
    const host = this.apis[service];
    if (!host) {
      throw new Error(`Unknown service: ${service}`);
    }
    
    const url = new URL(`https://${host}${endpoint}`);
    Object.keys(params).forEach(key => 
      url.searchParams.append(key, params[key])
    );
    
    const response = await fetch(url, {
      headers: {
        'x-rapidapi-key': this.apiKey,
        'x-rapidapi-host': host
      }
    });
    
    return response.json();
  }
}

// Usage
const client = new APICodexMultiClient(process.env.RAPIDAPI_KEY);

// DNS lookup
const dnsResult = await client.request('dns', '/v1/check', { name: 'example.com' });

// Email validation
const emailResult = await client.request('email', '/v1/validate', { email: '[email protected]' });

// Text analysis
const textResult = await client.request('text', '/v1/analyze', { text: 'Sample text' });

Troubleshooting

Checklist for Authentication Issues

✓ Verify API key is correct (no extra spaces or characters)
✓ Check subscription status on RapidAPI dashboard
✓ Ensure headers are properly formatted
✓ Verify API endpoint URL is correct
✓ Check if API key has proper permissions
✓ Ensure you're not exceeding rate limits
✓ Verify network connectivity and firewall settings

Debug Mode

Enable debug logging to troubleshoot authentication:

Code
 
const debug = process.env.NODE_ENV === 'development';

function debugRequest(url, headers) {
  if (debug) {
    console.log('🔍 API Request Debug:');
    console.log('URL:', url);
    console.log('Headers:', {
      ...headers,
      'x-rapidapi-key': headers['x-rapidapi-key'].substr(0, 5) + '...' // Partial key only
    });
  }
}

Next Steps

Review Rate Limiting to understand usage limits
Learn about Error Handling for robust applications
Check Best Practices for production deployments
Explore our API Catalog to start building

Need Help?

RapidAPI Support: Available through your RapidAPI dashboard
API Codex Support: Contact us for API-specific questions
Community: Join discussions on RapidAPI forums
Documentation: Browse our comprehensive guides

Last modified on August 3, 2025

Platform Overview Rate Limiting