# Replace YOUR_API_KEY with your actual key
curl -X POST https://api.audit1.info/api/v1/payroll/reports \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "employer_id": "EMP_TEST_001",
    "period_start": "2024-01-01",
    "period_end": "2024-03-31",
    "employees": [
      {
        "employee_id": "EE_001",
        "name": "Test Employee",
        "classification_code": "8810",
        "hours_worked": 520,
        "gross_wages": 26000
      }
    ],
    "payroll_data": {
      "total_payroll": 26000,
      "total_hours": 520,
      "officer_payroll": 0,
      "subcontractor_payments": 0
    }
  }'

{
  "message": "Payroll report submitted successfully",
  "report_id": "PR_TEST_1234567890",
  "status": "processing",
  "environment": "sandbox",
  "employee_count": 1,
  "estimated_processing_time": "1-2 minutes"
}

# Submit payroll data for workers' comp audit
curl -X POST https://api.audit1.info/api/v1/payroll/reports \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "employer_id": "EMP_12345",
    "period_start": "2024-01-01",
    "period_end": "2024-03-31",
    "employees": [
      {
        "employee_id": "EE_001",
        "name": "John Doe",
        "classification_code": "8810",
        "hours_worked": 520,
        "gross_wages": 15600
      }
    ],
    "payroll_data": {
      "total_payroll": 15600,
      "total_hours": 520,
      "officer_payroll": 0,
      "subcontractor_payments": 0
    }
  }'

{
  "message": "Payroll report submitted successfully",
  "report_id": "PR_1234567890",
  "status": "processing",
  "employer_id": "EMP_12345",
  "period": {
    "start": "2024-01-01",
    "end": "2024-03-31"
  },
  "employee_count": 1,
  "estimated_processing_time": "5-10 minutes"
}

{
  "event": "audit.completed",
  "timestamp": "2024-01-15T10:30:00.000Z",
  "data": {
    "audit_id": "AUD_123",
    "employer_id": "EMP_12345",
    "status": "completed",
    "premium_calculated": 15234.50
  }
}

const apiKey = 'audit1_live_sk_1234567890abcdef1234567890abcdef12';

const response = await fetch('https://api.audit1.info/api/v1/payroll/reports', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    employer_id: 'EMP_12345',
    period_start: '2024-01-01',
    period_end: '2024-03-31',
    employees: [...],
    payroll_data: {...}
  })
});

const data = await response.json();

import requests

api_key = 'audit1_live_sk_1234567890abcdef1234567890abcdef12'

headers = {
    'Authorization': f'Bearer {api_key}',
    'Content-Type': 'application/json'
}

payload = {
    'employer_id': 'EMP_12345',
    'period_start': '2024-01-01',
    'period_end': '2024-03-31',
    'employees': [...],
    'payroll_data': {...}
}

response = requests.post('https://api.audit1.info/api/v1/payroll/reports', 
                        headers=headers, 
                        json=payload)
data = response.json()

curl -X GET https://api.audit1.info/api/v1/policies \
  -H "Authorization: Bearer audit1_live_sk_1234567890abcdef1234567890abcdef12" \
  -H "Content-Type: application/json"

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1642291200

HTTP/1.1 429 Too Many Requests
Content-Type: application/json

{
  "error": {
    "type": "rate_limit_exceeded",
    "message": "Too many requests",
    "retry_after": 60
  }
}

async function apiCallWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get('Retry-After')) || 60;
        
        if (attempt < maxRetries) {
          await sleep(retryAfter * 1000);
          continue;
        }
      }
      
      return response;
    } catch (error) {
      if (attempt === maxRetries) throw error;
      await sleep(1000 * Math.pow(2, attempt)); // Exponential backoff
    }
  }
}

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

// Development
const apiKey = process.env.AUDIT1_TEST_KEY; // audit1_test_sk_...

// Production
const apiKey = process.env.AUDIT1_LIVE_KEY; // audit1_live_sk_...

# ✅ Correct
Authorization: Bearer audit1_test_sk_1234567890abcdef1234567890abcdef

# ❌ Wrong - extra spaces
Authorization: Bearer  audit1_test_sk_1234567890abcdef1234567890abcdef

# ❌ Wrong - missing "Bearer"
Authorization: audit1_test_sk_1234567890abcdef1234567890abcdef

{
  "employer_id": "required",
  "period_start": "required (YYYY-MM-DD)",
  "period_end": "required (YYYY-MM-DD)",
  "employees": "required (array with at least 1 employee)",
  "payroll_data": "required (object with totals)"
}

async function retryWithBackoff(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
}

npm install @audit1/node-sdk

const Audit1 = require('@audit1/node-sdk');

const audit1 = new Audit1('audit1_live_sk_...');

// Create a policy
const policy = await audit1.policies.create({
  employer_id: 'emp_1234567890',
  effective_date: '2024-02-01T00:00:00.000Z',
  premium: 1500.00
});

// List employees
const employees = await audit1.employees.list({
  employer_id: 'emp_1234567890'
});

pip install audit1-python

import audit1

audit1.api_key = 'audit1_live_sk_...'

# Create a policy
policy = audit1.Policy.create(
    employer_id='emp_1234567890',
    effective_date='2024-02-01T00:00:00.000Z',
    premium=1500.00
)

# List employees
employees = audit1.Employee.list(
    employer_id='emp_1234567890'
)

composer require audit1/audit1-php

<?php
require_once('vendor/autoload.php');

\Audit1\Audit1::setApiKey('audit1_live_sk_...');

// Create a policy
$policy = \Audit1\Policy::create([
    'employer_id' => 'emp_1234567890',
    'effective_date' => '2024-02-01T00:00:00.000Z',
    'premium' => 1500.00
]);

// List employees
$employees = \Audit1\Employee::all([
    'employer_id' => 'emp_1234567890'
]);
?>

GET /v1/policies?owner_id=emp_123&limit=25&starting_after=pol_456

POST /v1/policies
Content-Type: application/json

{
  "employer_id": "emp_1234567890",
  "effective_date": "2024-02-01T00:00:00.000Z"
}

GET /v1/policies/pol_1234567890?owner_id=emp_1234567890

PATCH /v1/policies/pol_1234567890
Content-Type: application/json

{
  "owner_id": "emp_1234567890",
  "premium": 1750.00
}

DELETE /v1/policies/pol_1234567890?owner_id=emp_1234567890

{
  "error": {
    "type": "invalid_request_error",
    "code": "missing_parameter",
    "message": "Missing required parameter: employer_id",
    "param": "employer_id",
    "request_id": "req_1234567890"
  }
}

async function handleApiCall(apiCall) {
  try {
    const response = await apiCall();
    return response;
    
  } catch (error) {
    switch (error.type) {
      case 'authentication_error':
        // Check API key, refresh if needed
        console.error('Authentication failed:', error.message);
        break;
        
      case 'rate_limit_error': 
        // Implement exponential backoff
        const retryAfter = error.retry_after || 60;
        await sleep(retryAfter * 1000);
        return handleApiCall(apiCall); // Retry
        
      case 'resource_not_found':
        // Handle missing resource gracefully
        return null;
        
      default:
        // Log for investigation
        console.error('API error:', error);
        throw error;
    }
  }
}

// Get first page
const firstPage = await audit1.policies.list({
  owner_id: 'emp_1234567890',
  limit: 25
});

// Get next page using last object's ID
if (firstPage.has_more) {
  const nextPage = await audit1.policies.list({
    owner_id: 'emp_1234567890',
    limit: 25,
    starting_after: firstPage.data[firstPage.data.length - 1].id
  });
}

async function* getAllPolicies(ownerId) {
  let startingAfter = null;
  
  do {
    const page = await audit1.policies.list({
      owner_id: ownerId,
      limit: 100,
      starting_after: startingAfter
    });
    
    for (const policy of page.data) {
      yield policy;
    }
    
    startingAfter = page.has_more ? 
      page.data[page.data.length - 1].id : null;
      
  } while (startingAfter);
}

// Usage
for await (const policy of getAllPolicies('emp_1234567890')) {
  console.log('Policy:', policy.policy_number);
}