> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ondb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Error Handling

> Comprehensive error handling with specific error types

OnDB SDKs provide specific error types for comprehensive error handling.

## Error Types

| Error Type                 | Description                         |
| -------------------------- | ----------------------------------- |
| `OnDBError`                | Base error class for all SDK errors |
| `ValidationError`          | Data validation failed              |
| `TransactionError`         | Blockchain transaction failed       |
| `PaymentRequiredError`     | Payment required (HTTP 402)         |
| `PaymentVerificationError` | Payment verification failed         |

## Basic Error Handling

```typescript TypeScript theme={null}
import {
  OnDBError,
  TransactionError,
  ValidationError,
  PaymentRequiredError,
  PaymentVerificationError,
} from '@ondb/sdk';

try {
  await client.store(
    { collection: 'test', data: [{ test: 'data' }] },
    paymentCallback
  );
} catch (error) {
  if (error instanceof ValidationError) {
    console.log('Validation failed:', error.message);
    console.log('Details:', error.details);
  } else if (error instanceof TransactionError) {
    console.log('Transaction failed:', error.transactionId);
  } else if (error instanceof PaymentRequiredError) {
    console.log('Payment required');
    console.log('Error:', error.paymentRequired.error);
    console.log('Options:', error.paymentRequired.accepts.length);
  } else if (error instanceof PaymentVerificationError) {
    console.log('Payment verification failed:', error.txHash);
  } else if (error instanceof OnDBError) {
    console.log('OnDB error:', error.code, error.statusCode);
  }
}
```

## Validation Errors

Thrown when data validation fails:

```typescript TypeScript theme={null}
try {
  await client.store(
    { collection: 'users', data: [{ email: 'invalid-email', age: -5 }] },
    paymentCallback, true
  );
} catch (error) {
  if (error instanceof ValidationError) {
    console.log('Validation errors:');
    Object.entries(error.details).forEach(([field, messages]) => {
      console.log(`  ${field}: ${messages.join(', ')}`);
    });
  }
}
```

## Payment Required Handling

Handle payment required errors:

```typescript TypeScript theme={null}
try {
  const result = await client.queryBuilder()
    .collection('premium_data')
    .selectAll()
    .execute();
} catch (error) {
  if (error instanceof PaymentRequiredError) {
    const paymentInfo = error.paymentRequired;
    console.log('Payment required');
    console.log('Error:', paymentInfo.error);
    console.log('Payment options:', paymentInfo.accepts.length);

    // Handle payment flow
    const txHash = await processPayment(quote);
    // Retry with payment proof
  }
}
```

## Retry Pattern with Exponential Backoff

```typescript TypeScript theme={null}
async function storeWithRetry(
  data: any,
  maxRetries: number = 3,
  delay: number = 1000
) {
  let lastError: Error;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await client.store(data, paymentCallback, true);
    } catch (error) {
      lastError = error;

      // Don't retry validation errors
      if (error instanceof ValidationError) {
        throw error;
      }

      // Don't retry payment required (needs user action)
      if (error instanceof PaymentRequiredError) {
        throw error;
      }

      // Retry transient errors
      if (error instanceof TransactionError || error instanceof OnDBError) {
        console.log(`Attempt ${attempt} failed, retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        delay *= 2; // Exponential backoff
        continue;
      }

      throw error;
    }
  }

  throw lastError;
}
```

## Error Logging

```typescript TypeScript theme={null}
function logError(error: Error) {
  const timestamp = new Date().toISOString();

  if (error instanceof ValidationError) {
    console.error(`[${timestamp}] Validation Error:`, {
      message: error.message,
      details: error.details,
      code: error.code
    });
  } else if (error instanceof TransactionError) {
    console.error(`[${timestamp}] Transaction Error:`, {
      message: error.message,
      transactionId: error.transactionId
    });
  } else if (error instanceof PaymentRequiredError) {
    console.error(`[${timestamp}] Payment Required:`, {
      error: error.paymentRequired.error,
      options: error.paymentRequired.accepts.length
    });
  } else {
    console.error(`[${timestamp}] Error:`, error.message);
  }
}
```

## Next Steps

<CardGroup cols={2}>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Complete SDK reference
  </Card>

  <Card title="Best Practices" icon="star" href="/resources/best-practices">
    Recommended patterns
  </Card>
</CardGroup>