Documentation
That Makes Sense

client = new DevAPI({
  apiKey: process.env.DEVAPI_KEY
});

// Or use Bearer token directly
const response = await fetch( 'https://api.devapi.io/v1/generate' , {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY' ,
    'Content-Type': 'application/json'
  }
}];

// Generate AI completions
POST https://api.devapi.io/v1/generate
‍
// Request body
{ 
  "prompt": "Your prompt here",
  "model": "gpt-4",
  "maxTokens": 500 ,
  "temperature": 0.7
}

// List available models
GET https://api.devapi.io/v1/models

// Response
{ "models": [
   { "id": "gpt-4", "name": "GPT-4" },
   { "id": "claude-3", "name": "Claude 3" }
  ]
}

// Check your usage statistics
GET https://api.devapi.io/v1/usage
‍
// Response
{ 
  "requests": 1247 ,
  "tokens": 45632 ,
  "cost": "$12.45"
}

import { DevAPI } from '@devapi/node';

const client = new DevAPI({ apiKey: 'YOUR_KEY' });

const response = await client.generate({
   prompt: "Hello, World!",
   model: "gpt-4" 
});

from devapi import Client

client = Client(apiKey="YOUR_KEY")

response = client.generate({
   prompt: "Hello, World!",
   model: "gpt-4" 
});

import "github.com/devapi/go-sdk"

client =: devapi.NewClient ("YOUR_KEY")

response, err := client.generate(&devapi.Request{
   prompt: "Hello, World!",
   model: "gpt-4" 
});

const stream = await client.generateStream({
   prompt: "Hello, World!",
   model: "gpt-4" 
});

for await (const chunk of stream) {
  process.stdout.write(chunk.text);
}

const prompts = ["Query 1", "Query 2", "Query 3"];

‍const results = await Promise.all(
  prompts.map(prompt =>
    client.generate({ prompt, model: "gpt-4" })
  )
);

async function generateWithRetry(prompt, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      return await client.generate({ prompt });
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(r => setTimeout(r, 1000 * (i + 1)));
    }
  }
}

// Express.js example
app.post('/webhook', express.json(), (req, res) => {
  const event = req.body;
 
  console.log('Event received:', event.type);
 
  res.status(200).send('OK');
});

const crypto = require('crypto');

function verifyWebhook(payload, signature, secret) {
  const hash = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
‍
  return hash === signature;
}

switch (event.type) {
  case 'request.completed':
    console.log('Request completed:', event.data);
    break;
  case 'request.failed':
    console.log('Request failed:', event.data);
    break;
  default:
    console.log('Unknown event type:', event.type);
}

X-RateLimit-Limit: 10000
X-RateLimit-Remaining: 9847
X-RateLimit-Reset: 1714089600
X-RateLimit-Retry-After: 3600

async function generateWithRetry(prompt, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch('https://api.devapi.com/v1/generate', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ prompt })
      });

      if (response.status === 429) {
        const retryAfter = response.headers.get('X-RateLimit-Retry-After');
        const delay = (retryAfter || Math.pow(2, attempt)) * 1000;
‍
        console.log(`Rate limited. Retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
‍
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
‍
      return await response.json();
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
    }
  }
}

try {
  const response = await client.generate({
    prompt: "Hello",
    model: "gpt-4"
  });
  console.log(response.data);
} catch (error) {
  if (error.status === 429) {
    console.error('Rate limit exceeded');
  } else if (error.status === 401) {
    console.error('Invalid API key');
  } else {
    console.error('Error:', error.message);
  }
}

// Common error status codes
// 400 - Bad Request (invalid parameters)
// 401 - Unauthorized (invalid API key)
// 429 - Rate Limit Exceeded
// 500 - Internal Server Error

if (error.status === 429) {
  // Wait and retry
  const retryAfter = error.headers['retry-after'];
  await sleep(retryAfter * 1000);
}

class APIError extends Error {
  constructor(message, status, code) {
    super(message);
    this.status = status;
    this.code = code;
  }
}

‍// Usage
if (!response.ok) {
  throw new APIError(
    'Request failed',
    response.status,
    response.data.code
  );
}

// ✅ Good - Use environment variables
const client = new DevAPI({
  apiKey: process.env.DEVAPI_KEY
});

// ❌ Bad - Hardcoded API key
const client = new DevAPI({
  apiKey: 'sk_live_abc123...'
});

import { RateLimiter } from 'limiter';

const limiter = new RateLimiter({
  tokensPerInterval: 10,
  interval: 'second'
});

async function makeRequest(prompt) {
  await limiter.removeTokens(1);
  return client.generate({ prompt });
}

const cache = new Map();

async function generateWithCache(prompt) {
  if (cache.has(prompt)) {
    return cache.get(prompt);
  }
 
  const response = await client.generate({ prompt });
  cache.set(prompt, response);
 
  return response;
}