Common Errors & Troubleshooting

# Correct format
Authorization: Bearer YOUR_API_KEY

# Test your API key
curl -X GET "https://api.taxo.co/v1/health" \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "error": {
    "code": "INVALID_CREDENTIALS",
    "message": "The provided CIEC password is incorrect",
    "details": {
      "field": "credentials.password"
    }
  }
}

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

curl -X GET "https://api.taxo.co/v1/extractions/{jobId}" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Test with smaller date range
{
  "period": {
    "from": "2024-01-01",
    "to": "2024-01-07"  # 1 week instead of full month
  }
}

{
  "options": {
    "informationType": "INVOICE",
    // Remove direction to get both INBOUND and OUTBOUND
    "period": {
      "from": "2024-01-01",
      "to": "2024-01-31"
    }
  }
  // Remove filters object entirely
}

// Split by month
const months = [
  { from: '2024-01-01', to: '2024-01-31' },
  { from: '2024-02-01', to: '2024-02-29' },
  { from: '2024-03-01', to: '2024-03-31' }
];

for (const period of months) {
  const extraction = await createExtraction({ ...options, period });
  await waitForCompletion(extraction.publicId);
}

async function monitorExtraction(jobId, timeoutMs = 3600000) { // 1 hour
  const startTime = Date.now();
  
  while (Date.now() - startTime < timeoutMs) {
    const status = await getExtractionStatus(jobId);
    
    if (status.status === 'COMPLETED' || status.status === 'FAILED') {
      return status;
    }
    
    console.log(`Progress: ${status.completedCount}/${status.discoveryCount}`);
    await new Promise(resolve => setTimeout(resolve, 30000)); // 30s
  }
  
  throw new Error('Extraction timeout');
}

curl -X GET "https://api.taxo.co/v1/extractions/{jobId}" \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "documents": [
    {
      "id": "doc_123456",
      "type": "INVOICE",
      "status": "AVAILABLE"
    }
  ]
}

# Check available types first
curl -X GET "https://api.taxo.co/v1/extractions/{jobId}/documents/{docId}" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Response shows available types
{
  "availableFormats": ["XML", "PDF"]
}

// Increase timeout for downloads
const response = await axios.get(downloadUrl, {
  timeout: 60000, // 60 seconds
  responseType: 'arraybuffer'
});

// Implement retry for failed downloads
async function downloadWithRetry(url, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await axios.get(url, { timeout: 60000 });
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 5000));
    }
  }
}

# Test webhook endpoint manually
curl -X POST "https://your-domain.com/webhook" \
  -H "Content-Type: application/json" \
  -d '{"test": "webhook"}'

const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(signature, 'hex'),
    Buffer.from(expectedSignature, 'hex')
  );
}

// Express.js middleware
app.post('/webhook', (req, res) => {
  const signature = req.headers['x-taxo-signature'];
  const payload = JSON.stringify(req.body);
  
  if (!verifyWebhookSignature(payload, signature, WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }
  
  // Process webhook
  res.status(200).send('OK');
});

const processedEvents = new Set();

app.post('/webhook', (req, res) => {
  const eventId = req.body.event.id;
  
  // Check if already processed
  if (processedEvents.has(eventId)) {
    return res.status(200).send('Already processed');
  }
  
  try {
    // Process event
    processWebhookEvent(req.body);
    processedEvents.add(eventId);
    res.status(200).send('OK');
  } catch (error) {
    // Don't add to processed set on failure
    res.status(500).send('Processing failed');
  }
});

const startTime = Date.now();
const response = await makeAPICall();
const responseTime = Date.now() - startTime;
console.log(`API response time: ${responseTime}ms`);

const fs = require('fs');
const axios = require('axios');

async function downloadLargeFile(url, filename) {
  const response = await axios({
    method: 'GET',
    url: url,
    responseType: 'stream'
  });
  
  const writer = fs.createWriteStream(filename);
  response.data.pipe(writer);
  
  return new Promise((resolve, reject) => {
    writer.on('finish', resolve);
    writer.on('error', reject);
  });
}

curl -X GET "https://api.taxo.co/v1/extractions/{jobId}/documents/{docId}/download?type=XML" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  --output document.xml

const { DOMParser } = require('xmldom');

function validateXML(xmlString) {
  try {
    const parser = new DOMParser();
    const doc = parser.parseFromString(xmlString, 'text/xml');
    
    // Check for parsing errors
    const errors = doc.getElementsByTagName('parsererror');
    return errors.length === 0;
  } catch (error) {
    return false;
  }
}

// Ensure UTF-8 encoding
const response = await axios.get(url, {
  responseType: 'arraybuffer'
});

const decoder = new TextDecoder('utf-8');
const xmlContent = decoder.decode(response.data);

// For Node.js
const content = Buffer.from(response.data).toString('utf-8');