Build Zoom Rest API App

{
  "code": 300,
  "message": "Request Body should be a valid JSON object."
}

{
  "code": 201,
  "message": "Access token is expired."
}

async function apiCallWithRetry(url, options) {
  try {
    const response = await fetch(url, options);

    if (response.status === 401) {
      const error = await response.json();

      if (error.code === 201) {
        // Token expired - refresh and retry
        const newToken = await refreshAccessToken();
        options.headers['Authorization'] = `Bearer ${newToken}`;
        return await fetch(url, options);
      }
    }

    return response;
  } catch (error) {
    console.error('API call failed:', error);
    throw error;
  }
}

{
  "code": 200,
  "message": "Invalid credentials."
}

{
  "code": 4700,
  "message": "Invalid access token, does not contain scopes."
}

{
  "code": 3001,
  "message": "This user is not allowed to access this resource."
}

{
  "code": 3001,
  "message": "Authenticated user has not permitted access to the targeted resource."
}

{
  "code": 1001,
  "message": "User does not exist: [email protected]"
}

// WRONG (User OAuth app)
fetch('https://api.zoom.us/v2/users/[email protected]', {
  headers: { 'Authorization': `Bearer ${userToken}` }
});

// CORRECT (User OAuth app)
fetch('https://api.zoom.us/v2/users/me', {
  headers: { 'Authorization': `Bearer ${userToken}` }
});

{
  "code": 300,
  "message": "Meeting not found."
}

// UUID starts with / or contains // → double-encode
const uuid = '/xyzAbC123==';
const encoded = encodeURIComponent(encodeURIComponent(uuid));
fetch(`https://api.zoom.us/v2/meetings/${encoded}`, { headers });

{
  "code": 200,
  "message": "You have reached the maximum per-second rate limit for this API."
}

async function apiCallWithBackoff(url, options, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    const response = await fetch(url, options);

    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After') || Math.pow(2, attempt);
      console.log(`Rate limited. Retrying after ${retryAfter}s`);
      await sleep(retryAfter * 1000);
      continue;
    }

    return response;
  }

  throw new Error('Max retries exceeded');
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

const remaining = response.headers.get('X-RateLimit-Remaining');
const type = response.headers.get('X-RateLimit-Type');

console.log(`Rate limit remaining: ${remaining} (${type})`);

{
  "code": 300,
  "message": "Validation Failed.",
  "errors": [
    {
      "field": "start_time",
      "message": "Invalid field."
    },
    {
      "field": "type",
      "message": "Invalid field."
    }
  ]
}

{
  "code": 300,
  "message": "Descriptive error message"
}

{
  "code": 300,
  "message": "Validation Failed.",
  "errors": [
    {
      "field": "field_name",
      "message": "Error description"
    }
  ]
}

async function handleApiResponse(response) {
  if (!response.ok) {
    const error = await response.json();

    console.error(`API Error ${response.status}:`, error);

    // Check for validation errors
    if (error.errors && Array.isArray(error.errors)) {
      error.errors.forEach(err => {
        console.error(`- Field "${err.field}": ${err.message}`);
      });
    }

    throw new Error(`${error.code}: ${error.message}`);
  }

  return await response.json();
}

async function retryWithBackoff(fn, maxRetries = 3, baseDelay = 1000) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      const isRetryable = error.status >= 500 || error.status === 429;

      if (!isRetryable || attempt === maxRetries) {
        throw error;
      }

      const delay = baseDelay * Math.pow(2, attempt - 1);
      const jitter = Math.random() * 1000;  // Add randomness

      console.log(`Retry attempt ${attempt} after ${delay + jitter}ms`);
      await sleep(delay + jitter);
    }
  }
}

function logApiError(error, context) {
  const logEntry = {
    timestamp: new Date().toISOString(),
    status: error.status,
    code: error.code,
    message: error.message,
    context: {
      endpoint: context.endpoint,
      method: context.method,
      userId: context.userId
    }
  };

  console.error('API Error:', JSON.stringify(logEntry, null, 2));

  // Send to monitoring service
  // monitoring.track(logEntry);
}

function getUserFriendlyError(error) {
  const errorMap = {
    1001: 'User not found. Please check the email address.',
    300: 'Invalid request. Please check your input.',
    201: 'Your session has expired. Please sign in again.',
    4700: 'Permission denied. Please contact your administrator.',
    200: 'Too many requests. Please try again in a few moments.'
  };

  return errorMap[error.code] || 'An unexpected error occurred. Please try again.';
}