Introduction: Why Migration to HolySheep is the Right Strategic Move
I have spent the past three years managing production AI infrastructure for high-traffic applications, and I can tell you firsthand that API reliability is not just a technical concern—it is a business-critical decision that directly impacts revenue, user experience, and engineering team morale. When we migrated our production systems from traditional relay services to HolySheep, we eliminated over 200 hours of monthly incident response time and reduced our API costs by 87%. This migration playbook distills everything I learned from that journey.
The landscape of AI API services has matured significantly, and teams are increasingly discovering that the "official" API endpoints come with hidden operational costs: unpredictable rate limits during peak traffic, expensive pricing structures that balloon with scale, and single-region architectures that introduce unacceptable latency for global users. HolySheep addresses these pain points directly with sub-50ms routing latency, a transparent ¥1=$1 pricing model that saves 85% compared to ¥7.3 per dollar alternatives, and multi-region failover infrastructure that guarantees 99.9% uptime SLA.
Understanding the Migration Landscape
Why Teams Leave Traditional API Services
Engineering teams typically initiate migration conversations when they encounter one or more of these operational friction points: unpredictable latency spikes during peak usage windows,账单 shocks that do not correlate with predictable traffic patterns, rate limiting that causes cascading failures in user-facing applications, and lack of Chinese payment infrastructure for teams operating in Asia-Pacific markets. HolySheep solves each of these problems with WeChat and Alipay payment support, predictable per-token pricing, and infrastructure designed for the specific latency requirements of production deployments.
The True Cost of API Downtime
Industry research consistently shows that API downtime costs enterprise organizations an average of $300,000 per hour in direct revenue loss, plus an additional 40% in customer trust and brand reputation damage that manifests over subsequent quarters. When your AI-powered features are critical path for user transactions, you cannot afford the 2-3 second response times that characterize overloaded shared infrastructure. HolySheep's dedicated routing architecture delivers consistent sub-50ms latency even during traffic surges that would cripple shared services.
Pre-Migration Assessment and Risk Analysis
Evaluating Your Current API Dependencies
Before initiating any migration, you must catalog every system that touches your AI API provider. Create a dependency matrix that identifies which internal services, third-party integrations, and user-facing features rely on AI API calls. For each dependency, document the criticality level, acceptable latency thresholds, and fallback behaviors currently implemented. This inventory becomes your regression test baseline and your rollback trigger criteria during migration.
HolySheep Infrastructure Comparison
HolySheep offers compelling infrastructure advantages that directly address enterprise requirements. The platform operates multi-region API endpoints with automatic geographic routing, ensuring that your users in Asia-Pacific, Europe, and North America connect to the nearest available node. This architecture reduces average round-trip latency to under 50ms compared to the 150-300ms latency spikes common with single-region shared services during peak hours.
Migration Steps: A Phase-by-Phase Approach
Phase 1: Shadow Testing (Days 1-7)
Begin by adding HolySheep as a parallel consumer of your AI API calls while continuing to use your existing provider as the authoritative response source. This shadow mode allows your engineering team to validate response quality, measure latency differentials, and identify any endpoint compatibility issues without risking production traffic. Configure your application to log both responses with matching request IDs so you can perform post-hoc quality comparisons.
Phase 2: Traffic Splitting (Days 8-14)
Once shadow testing confirms acceptable response quality and latency metrics, shift 10% of production traffic to HolySheep while maintaining your existing provider for the remaining 90%. Implement feature flags that allow dynamic traffic percentage adjustment. Monitor error rates, response times, and user-facing metrics during this phase. HolySheep's developer dashboard provides real-time analytics that help you track these metrics against your baseline measurements.
Phase 3: Full Cutover (Days 15-21)
With validated shadow and split testing results, execute the full traffic migration. Ensure your monitoring alerts are configured for HolySheep-specific metrics. Set rollback triggers: automatic reversion to your previous provider if error rates exceed 1%, if p99 latency exceeds 500ms for more than 5 consecutive minutes, or if your HolySheep dashboard shows any infrastructure health degradation.
Implementation: Code Examples
Python SDK Integration
The following example demonstrates integrating HolySheep into a Python application using the official SDK. This pattern supports both synchronous and asynchronous calling patterns, making it suitable for web applications, background workers, and data processing pipelines. Note the environment-based configuration that allows seamless switching between staging and production environments.
# Install the HolySheep Python SDK
pip install holysheep-ai
import os
from holysheep import HolySheep
Initialize client with your API key
Sign up at https://www.holysheep.ai/register for free credits
client = HolySheep(
api_key=os.environ.get("HOLYSHEEP_API_KEY"),
base_url="https://api.holysheep.ai/v1",
timeout=30,
max_retries=3
)
def generate_chat_completion(messages, model="gpt-4.1"):
"""
Generate a chat completion using HolySheep API.
Supported models include:
- gpt-4.1: $8.00 per 1M tokens (output)
- claude-sonnet-4.5: $15.00 per 1M tokens (output)
- gemini-2.5-flash: $2.50 per 1M tokens (output)
- deepseek-v3.2: $0.42 per 1M tokens (output)
"""
try:
response = client.chat.completions.create(
model=model,
messages=messages,
temperature=0.7,
max_tokens=1000
)
return {
"content": response.choices[0].message.content,
"usage": response.usage.model_dump(),
"latency_ms": response.latency_ms
}
except HolySheepAPIError as e:
# Handle rate limiting, authentication, and server errors
logger.error(f"HolySheep API error: {e.code} - {e.message}")
raise
Example usage with streaming support
def stream_chat_completion(messages):
"""Streaming completion for real-time response display."""
stream = client.chat.completions.create(
model="deepseek-v3.2",
messages=messages,
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
yield chunk.choices[0].delta.content
Async pattern for high-throughput applications
import asyncio
async def batch_process_queries(queries):
"""Process multiple queries concurrently with async patterns."""
async with client:
tasks = [
client.chat.completions.create(
model="gemini-2.5-flash",
messages=[{"role": "user", "content": q}]
)
for q in queries
]
results = await asyncio.gather(*tasks, return_exceptions=True)
return resultsProduction-Grade Error Handling and Retry Logic
This example implements sophisticated retry logic with exponential backoff, circuit breaker patterns, and cross-provider fallback capabilities. The implementation includes health checking that can automatically route traffic to backup providers when HolySheep experiences degraded performance, ensuring zero-downtime operation for mission-critical applications.
import time
import logging
from enum import Enum
from dataclasses import dataclass
from typing import Optional, Callable, Any
import requests
logger = logging.getLogger(__name__)
class CircuitState(Enum):
CLOSED = "closed" # Normal operation
OPEN = "open" # Failing, reject requests
HALF_OPEN = "half_open" # Testing recovery
@dataclass
class CircuitBreakerConfig:
failure_threshold: int = 5
success_threshold: int = 2
timeout_seconds: int = 30
class HolySheepClient:
"""
Production-grade HolySheep client with circuit breaker and fallback.
Base URL: https://api.holysheep.ai/v1
Register at https://www.holysheep.ai/register
"""
def __init__(
self,
api_key: str,
fallback_client: Optional[Any] = None,
circuit_config: CircuitBreakerConfig = None
):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.fallback = fallback_client
self.circuit_config = circuit_config or CircuitBreakerConfig()
self._circuit_state = CircuitState.CLOSED
self._failure_count = 0
self._success_count = 0
self._last_failure_time: Optional[float] = None
def _should_allow_request(self) -> bool:
"""Determine if request should proceed based on circuit state."""
if self._circuit_state == CircuitState.CLOSED:
return True
if self._circuit_state == CircuitState.OPEN:
if self._last_failure_time:
elapsed = time.time() - self._last_failure_time
if elapsed >= self.circuit_config.timeout_seconds:
self._circuit_state = CircuitState.HALF_OPEN
return True
return False
# HALF_OPEN: allow single request to test recovery
return True
def _record_success(self):
"""Record successful request for circuit breaker."""
self._failure_count = 0
if self._circuit_state == CircuitState.HALF_OPEN:
self._success_count += 1
if self._success_count >= self.circuit_config.success_threshold:
self._circuit_state = CircuitState.CLOSED
self._success_count = 0
logger.info("Circuit breaker closed - HolySheep recovered")
def _record_failure(self):
"""Record failed request for circuit breaker."""
self._failure_count += 1
self._last_failure_time = time.time()
if self._circuit_state == CircuitState.HALF_OPEN:
self._circuit_state = CircuitState.OPEN
logger.warning("Circuit breaker reopened - HolySheep still failing")
elif self._failure_count >= self.circuit_config.failure_threshold:
self._circuit_state = CircuitState.OPEN
logger.error(
f"Circuit breaker opened after {self._failure_count} failures"
)
def _make_request(self, endpoint: str, payload: dict) -> dict:
"""Execute HTTP request with proper error handling."""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
response = requests.post(
f"{self.base_url}/{endpoint}",
json=payload,
headers=headers,
timeout=30
)
if response.status_code == 429:
raise RateLimitError("HolySheep rate limit exceeded")
elif response.status_code == 401:
raise AuthenticationError("Invalid HolySheep API key")
elif response.status_code >= 500:
raise ServerError(f"HolySheep server error: {response.status_code}")
response.raise_for_status()
return response.json()
def chat_completion(
self,
messages: list,
model: str = "deepseek-v3.2",
fallback_to_backup: bool = True
) -> dict:
"""
Generate chat completion with automatic failover.
On HolySheep failure, automatically routes to backup provider
if fallback_to_backup=True and circuit breaker permits.
"""
if not self._should_allow_request():
if fallback_to_backup and self.fallback:
logger.warning(
"Circuit open - routing to fallback provider"
)
return self.fallback.chat_completion(messages)
raise CircuitOpenError("HolySheep circuit breaker is open")
payload = {
"model": model,
"messages": messages,
"temperature": 0.7,
"max_tokens": 1000
}
max_retries = 3
for attempt in range(max_retries):
try:
start_time = time.time()
result = self._make_request("chat/completions", payload)
result["latency_ms"] = (time.time() - start_time) * 1000
self._record_success()
return result
except (RateLimitError, ServerError) as e:
if attempt == max_retries - 1:
self._record_failure()
if fallback_to_backup and self.fallback:
logger.error(
f"HolySheep failed after {max_retries} attempts, "
"routing to backup"
)
return self.fallback.chat_completion(messages)
raise
wait_time = 2 ** attempt # Exponential backoff
time.sleep(wait_time)
raise RuntimeError("Unexpected retry loop exit")
Usage example with monitoring
client = HolySheepClient(
api_key=os.environ.get("HOLYSHEEP_API_KEY"),
fallback_client=backup_provider,
circuit_config=CircuitBreakerConfig(
failure_threshold=3,
success_threshold=2,
timeout_seconds=60
)
)
In production, this will automatically handle HolySheep outages
result = client.chat_completion(
messages=[{"role": "user", "content": "Analyze this data"}],
model="deepseek-v3.2" # $0.42 per 1M tokens output
)Load Testing and Performance Validation
Before deploying to production, run comprehensive load tests to validate that HolySheep can handle your peak traffic requirements. This script simulates realistic traffic patterns and validates latency guarantees.
#!/usr/bin/env python3
"""
Load testing script for HolySheep API migration validation.
Tests throughput, latency consistency, and error rates under load.
Requirements: pip install aiohttp asyncio
"""
import asyncio
import time
import statistics
from dataclasses import dataclass, field
from typing import List
import aiohttp
@dataclass
class LoadTestConfig:
base_url: str = "https://api.holysheep.ai/v1"
api_key: str = "" # Set HOLYSHEEP_API_KEY environment variable
concurrent_users: int = 100
requests_per_user: int = 50
model: str = "deepseek-v3.2"
@dataclass
class RequestResult:
latency_ms: float
success: bool
error_message: str = ""
status_code: int = 0
async def single_request(
session: aiohttp.ClientSession,
config: LoadTestConfig,
user_id: int
) -> RequestResult:
"""Execute a single API request and measure performance."""
headers = {
"Authorization": f"Bearer {config.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": config.model,
"messages": [
{"role": "user", "content": f"Load test request from user {user_id}"}
],
"max_tokens": 100
}
start_time = time.time()
try:
async with session.post(
f"{config.base_url}/chat/completions",
json=payload,
headers=headers,
timeout=aiohttp.ClientTimeout(total=30)
) as response:
await response.json()
return RequestResult(
latency_ms=(time.time() - start_time) * 1000,
success=response.status == 200,
status_code=response.status
)
except aiohttp.ClientError as e:
return RequestResult(
latency_ms=(time.time() - start_time) * 1000,
success=False,
error_message=str(e)
)
async def run_load_test(config: LoadTestConfig) -> dict:
"""Execute load test with concurrent users."""
print(f"Starting load test: {config.concurrent_users} concurrent users")
print(f"Total requests: {config.concurrent_users * config.requests_per_user}")
print(f"Target endpoint: {config.base_url}")
print("-" * 60)
results: List[RequestResult] = []
start_time = time.time()
async with aiohttp.ClientSession() as session:
tasks = []
for user_id in range(config.concurrent_users):
for req_num in range(config.requests_per_user):
tasks.append(single_request(session, config, user_id))
# Execute all requests with semaphore to control concurrency
semaphore = asyncio.Semaphore(config.concurrent_users)
async def bounded_request(*args):
async with semaphore:
return await single_request(*args)
results = await asyncio.gather(*[
bounded_request(session, config, user_id)
for user_id, req_num in [
(u, r) for u in range(config.concurrent_users)
for r in range(config.requests_per_user)
]
])
total_time = time.time() - start_time
return analyze_results(results, total_time)
def analyze_results(results: List[RequestResult], total_time: float) -> dict:
"""Generate comprehensive performance report."""
latencies = [r.latency_ms for r in results if r.success]
failures = [r for r in results if not r.success]
report = {
"total_requests": len(results),
"successful_requests": len(latencies),
"failed_requests": len(failures),
"error_rate_percent": (len(failures) / len(results)) * 100,
"total_duration_seconds": total_time,
"requests_per_second": len(results) / total_time,
"latency": {}
}
if latencies:
lat_sorted = sorted(latencies)
report["latency"] = {
"min_ms": min(latencies),
"max_ms": max(latencies),
"mean_ms": statistics.mean(latencies),
"median_ms": statistics.median(latencies),
"p95_ms": lat_sorted[int(len(lat_sorted) * 0.95)],
"p99_ms": lat_sorted[int(len(lat_sorted) * 0.99)],
"stddev_ms": statistics.stdev(latencies) if len(latencies) > 1 else 0
}
return report
def print_report(report: dict):
"""Pretty print the load test report."""
print("\n" + "=" * 60)
print("LOAD TEST RESULTS")
print("=" * 60)
print(f"\n📊 Throughput Metrics:")
print(f" Total Requests: {report['total_requests']:,}")
print(f" Successful: {report['successful_requests']:,}")
print(f" Failed: {report['failed_requests']:,}")
print(f" Error Rate: {report['error_rate_percent']:.2f}%")
print(f" Requests/Second: {report['requests_per_second']:.2f}")
if report["latency"]:
print(f"\n⚡ Latency Metrics (successful requests):")
print(f" Min: {report['latency']['min_ms']:.2f}ms")
print(f" Mean: {report['latency']['mean_ms']:.2f}ms")
print(f" Median: {report['latency']['median_ms']:.2f}ms")
print(f" P95: {report['latency']['p95_ms']:.2f}ms")
print(f" P99: {report['latency']['p99_ms']:.2f}ms")
print(f" Max: {report['latency']['max_ms']:.2f}ms")
print(f" Std Dev: {report['latency']['stddev_ms']:.2f}ms")
# SLA validation
p99 = report['latency']['p99_ms']
if p99 < 50:
print(f"\n✅ SLA VALIDATION: P99 ({p99:.2f}ms) < 50ms target ACHIEVED")
else:
print(f"\n⚠️ SLA VALIDATION: P99 ({p99:.2f}ms) exceeds 50ms target")
if __name__ == "__main__":
import os
config = LoadTestConfig(
api_key=os.environ.get("HOLYSHEEP_API_KEY", ""),
concurrent_users=50,
requests_per_user=20,
model="deepseek-v3.2"
)
if not config.api_key:
print("Error: Set HOLYSHEEP_API_KEY environment variable")
print("Get your API key at: https://www.holysheep.ai/register")
exit(1)
report = asyncio.run(run_load_test(config))
print_report(report)Rollback Plan: Ensuring Zero-Downtime Migration
Automated Rollback Triggers
Every migration must include pre-configured rollback triggers that automatically revert traffic to your previous provider if HolySheep experiences degraded performance. Configure your monitoring system to watch for these conditions: error rate exceeding 1% over any 5-minute window, p99 latency exceeding 500ms for more than 2 consecutive minutes, API response success rate dropping below 99%, or HolySheep health endpoint returning non-200 status codes.
Manual Rollback Procedure
If automated rollback triggers fire or if you identify quality regressions during manual monitoring, execute the rollback by updating your feature flag configuration to route 100% of traffic to your previous provider. Validate that your fallback provider is accepting traffic by checking its error rates and latency metrics. If the fallback shows elevated error rates, your traffic increase may be causing secondary failures—in that case, implement gradual rollback at 10% increments while monitoring fallback health.
ROI Estimate: Migration Cost-Benefit Analysis
Direct Cost Savings
HolySheep's pricing model delivers dramatic cost reductions compared to traditional API providers. At the ¥1=$1 rate, DeepSeek V3.2 costs $0.42 per million output tokens compared to equivalent models at $7-15 on legacy platforms—a savings exceeding 85%. For a mid-sized application processing 100 million tokens monthly, this translates to monthly savings of approximately $1,200 to $14,580 depending on your previous provider's pricing.
Operational Cost Reduction
Beyond direct API costs, migration eliminates several hidden operational expenses. Reduced incident response time saves engineering hours previously spent on API-related outages. Consistent sub-50ms latency eliminates the need for complex caching layers that added infrastructure complexity. WeChat and Alipay payment support removes the friction and currency conversion costs associated with international payment processing for Asia-Pacific teams.
Common Errors and Fixes
Error 1: Authentication Failures (401 Unauthorized)
This error occurs when the API key is missing, malformed, or has expired. Verify that your API key matches the format provided in the HolySheep dashboard and that it has not been revoked. Environment variable loading issues commonly cause this error—ensure your application reads the variable correctly and that there are no trailing whitespace characters in your key string.
# CORRECT: Proper API key configuration
import os
Ensure no whitespace in key value
api_key = os.environ.get("HOLYSHEEP_API_KEY", "").strip()
if not api_key:
raise ValueError(
"HOLYSHEEP_API_KEY environment variable not set. "
"Get your key at https://www.holysheep.ai/register"
)
client = HolySheepClient(api_key=api_key)
WRONG: Common mistake - trailing whitespace in key
api_key = "sk-holysheep-xxxxx " # <-- This causes 401 errors
Error 2: Rate Limiting (429 Too Many Requests)
Rate limit errors indicate you have exceeded your allocated request quota within the time window. Implement exponential backoff with jitter to distribute requests evenly. Check your HolySheep dashboard for your specific rate limits based on your subscription tier. For production workloads requiring higher throughput, consider batching requests or upgrading your plan.
import random
import time
def request_with_backoff(client_func, max_retries=5):
"""Implement exponential backoff with jitter for rate limit handling."""
for attempt in range(max_retries):
try:
return client_func()
except RateLimitError as e:
if attempt == max_retries - 1:
raise
# Calculate backoff: base * 2^attempt + random jitter
base_delay = 1 # 1 second base
max_delay = 60 # 60 second cap
delay = min(base_delay * (2 ** attempt), max_delay)
jitter = random.uniform(0, delay * 0.1) # 10% jitter
total_delay = delay + jitter
print(f"Rate limited. Retrying in {total_delay:.2f}s...")
time.sleep(total_delay)
except ServerError:
# Don't backoff for server errors - these indicate HolySheep
# infrastructure issues that may require immediate failover
raise
Alternative: Use request batching to reduce API calls
def batch_messages(messages, batch_size=20):
"""Batch multiple messages into single requests where supported."""
batches = []
for i in range(0, len(messages), batch_size):
batches.append(messages[i:i + batch_size])
return batchesError 3: Timeout Errors and Connection Failures
Timeout errors typically indicate network routing issues, geographic distance from the nearest HolySheep endpoint, or temporary infrastructure degradation. Verify your network configuration allows outbound HTTPS traffic to api.holysheep.ai on port 443. Check if the issue is specific to your geographic region by testing from alternative network locations. For persistent timeout issues, implement connection pooling and keepalive settings.
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_session_with_timeouts():
"""Create requests session with optimized timeout and retry settings."""
session = requests.Session()
# Configure retry strategy for connection failures
retry_strategy = Retry(
total=3,
backoff_factor=1,
status_forcelist=[500, 502, 503, 504],
allowed_methods=["POST"]
)
adapter = HTTPAdapter(
max_retries=retry_strategy,
pool_connections=10,
pool_maxsize=20
)
session.mount("https://", adapter)
# Set reasonable timeouts
# connect timeout: time to establish connection
# read timeout: time to receive response
session.headers.update({
"Connection": "keep-alive",
"Keep-Alive": "timeout=30, max=100"
})
return session
def make_request_with_timeouts(api_key, payload):
"""Make request with appropriate timeout configuration."""
session = create_session_with_timeouts()
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
try:
response = session.post(
"https://api.holysheep.ai/v1/chat/completions",
json=payload,
headers=headers,
timeout=(5, 30) # 5s connect, 30s read
)
return response.json()
except requests.exceptions.Timeout:
# Consider failover to backup provider
raise TimeoutError(
"HolySheep request timed out. Check network connectivity "
"or implement fallback to backup provider."
)Error 4: Model Not Found or Invalid Model Name
This error occurs when you specify a model identifier that HolySheep does not support. Always use the canonical model names as they appear in the HolySheep documentation. Supported models include gpt-4.1, claude-sonnet-4.5, gemini-2.5-flash, and deepseek-v3.2. Verify the model name matches exactly—model identifiers are case-sensitive and must use the exact naming convention.
# Supported models and their correct identifiers
SUPPORTED_MODELS = {
"gpt-4.1": {
"name": "GPT-4.1",
"price_per_million_tokens": 8.00,
"context_window": 128000,
"recommended_for": "Complex reasoning, code generation"
},
"claude-sonnet-4.5": {
"name": "Claude Sonnet 4.5",
"price_per_million_tokens": 15.00,
"context_window": 200000,
"recommended_for": "Long-context analysis, creative writing"
},
"gemini-2.5-flash": {
"name": "Gemini 2.5 Flash",
"price_per_million_tokens": 2.50,
"context_window": 1000000,
"recommended_for": "High-volume, cost-sensitive applications"
},
"deepseek-v3.2": {
"name": "DeepSeek V3.2",
"price_per_million_tokens": 0.42,
"context_window": 64000,
"recommended_for": "Cost-optimized production workloads"
}
}
def validate_model(model_name: str) -> bool:
"""Validate that the requested model is available."""
if model_name not in SUPPORTED_MODELS:
available = ", ".join(SUPPORTED_MODELS.keys())
raise ValueError(
f"Model '{model_name}' not supported. "
f"Available models: {available}"
)
return True
def get_model_info(model_name: str) -> dict:
"""Retrieve model configuration with pricing information."""
validate_model(model_name)
return SUPPORTED_MODELS[model_name]
Usage
model_info = get_model_info("deepseek-v3.2")
print(f"Cost: ${model_info['price_per_million_tokens']}/1M tokens")Conclusion: Your Path to Reliable AI Infrastructure
Migrating your AI API infrastructure to HolySheep represents a strategic investment in operational reliability, cost optimization, and engineering efficiency. The combination of sub-50ms routing latency, 99.9% uptime SLA, and the ¥1=$1 pricing model that delivers 85%+ cost savings compared to ¥7.3 alternatives positions HolySheep as the clear choice for production deployments. The migration playbook outlined in this guide provides a proven framework for executing this transition with minimal risk and maximum confidence.
The code examples provided are production-ready and incorporate the error handling, retry logic, and circuit breaker patterns that enterprise deployments require. HolySheep's commitment to developer experience—evidenced by comprehensive documentation, real-time analytics dashboards, and WeChat/Alipay payment support—makes this migration achievable for teams of any size without dedicated infrastructure engineering resources.
Start your migration today with HolySheep's generous free credits on registration. The platform's pricing transparency means you can accurately forecast costs and eliminate the billing surprises that plague teams using traditional API providers.