Cold Email API: Build Custom Infrastructure Programmatically

Updated on: July 13, 2025

Stop manually setting up email accounts one by one. Modern businesses are building scalable email infrastructure through APIs that create unlimited inboxes on demand. Here's how to automate what used to take weeks of manual work.

The Manual Email Setup Problem

Picture this scenario: You're a lead generation agency that just signed 5 new clients. Each client needs:

• 20 dedicated email accounts
• 4 domains for proper distribution
• Custom SMTP configuration
• Proper DNS authentication setup
• Individual warmup schedules

Traditional approach:

• Week 1: Manually register 20 domains
• Week 2: Configure DNS records for each domain
• Week 3: Create 100 email accounts across various providers
• Week 4-6: Warm up each account individually
• Total time: 6+ weeks of setup before sending a single email

Modern API approach:

• Hour 1: Write script to generate all infrastructure
• Hour 2: Execute API calls to create domains and inboxes
• Hour 3: Start sending campaigns
• Total time: 3 hours from concept to campaign

This isn't theoretical — businesses are doing this right now.

What Cold Email APIs Actually Enable

Beyond Simple Email Sending

Most developers think "email API" means SendGrid or Mailgun for transactional emails. Cold email APIs are fundamentally different — they create and manage the infrastructure itself, not just send through existing accounts.

Traditional Email APIs (SendGrid, Mailgun):

• Send emails through their infrastructure
• Limited customization and control
• Shared reputation across all users
• Not designed for cold outreach volume or patterns

Cold Email Infrastructure APIs:

• Create unlimited email accounts programmatically
• Generate SMTP credentials for each account
• Manage domains and DNS configuration
• Provide complete infrastructure control

Real-World API Capabilities

Dynamic Infrastructure Creation:

# Create 50 inboxes across 5 domains in seconds
for domain in domains:
    for i in range(10):
        inbox = api.create_inbox(
            domain=domain,
            username=f"sales{i}"
        )
        print(f"Created: {inbox.email} | Password: {inbox.password}")

Instant SMTP Access:

# Get SMTP credentials for any platform
inbox_details = api.get_inbox("sales1@yourdomain.com")
smtp_config = {
    "host": inbox_details.smtp_host,
    "port": inbox_details.smtp_port,
    "username": inbox_details.email,
    "password": inbox_details.password
}
# Use with Smartlead, Instantly, or any platform

Scalable Domain Management:

# Add unlimited domains and configure automatically
new_domain = api.add_domain("newclient-outreach.com")
api.configure_dns(new_domain)  # Automatic SPF, DKIM, DMARC
api.verify_domain(new_domain)  # Real-time verification

Current API Landscape: ColdInbox Leading the Way

The cold email API space is rapidly evolving, with different providers taking distinct approaches:

ColdInbox API: Available Now

Available Today - The most comprehensive cold email infrastructure API currently in market.

Core Philosophy: Provide programmatic control over every aspect of email infrastructure with usage-based pricing.

Key Features:

• ✅ Complete API control over infrastructure creation
• ✅ Usage-based pricing ($25/month base + storage + sending)
• ✅ Unlimited scaling with granular control
• ✅ Custom warmup strategies via API
• ✅ Advanced monitoring and optimization
• ✅ Full REST API with comprehensive documentation

API Example:

# ColdInbox API - Custom infrastructure management
coldinbox_api = ColdInboxAPI("api-key")

# Create custom infrastructure with full control
domain = coldinbox_api.create_domain("client-outreach.com")
coldinbox_api.configure_dns(domain.id, {
    'spf': 'custom-spf-record',
    'dkim': 'custom-dkim-key',
    'dmarc': 'custom-dmarc-policy'
})

# Create inboxes with specific configurations
for i in range(100):
    inbox = coldinbox_api.create_inbox({
        'domain_id': domain.id,
        'username': f'sales{i}',
        'storage': '50MB',
        'warmup_schedule': 'aggressive'
    })

# Implement custom warmup strategy
coldinbox_api.start_warmup_sequence(inbox.id, {
    'initial_volume': 5,
    'daily_increase': 3,
    'target_volume': 50,
    'duration_weeks': 3
})

API Documentation: ColdInbox API Docs

Ideal For:

• Developers requiring maximum customization
• Enterprises with specific compliance requirements
• Agencies managing complex multi-client setups
• Businesses optimizing for cost efficiency at scale

ColdSend.pro: API Coming Soon

Platform: ColdSend.pro offers superior no-warmup infrastructure through their web platform, with API capabilities planned for release.

Current Offering:

• ✅ Web-based platform with immediate deployment
• ✅ No warmup required - send immediately
• ✅ Flat-rate pricing - $50/month
• ✅ 100+ inboxes included with 10K emails
• ✅ 90%+ deliverability from day one

Planned API Features:

• 🔄 Simple deployment API for instant infrastructure
• 🔄 No-warmup automation via programmatic access
• 🔄 Flat-rate API pricing aligned with platform model
• 🔄 Integration-focused endpoints for existing tools

Current Alternative: While waiting for the ColdSend API, businesses can use:

1. ColdSend.pro web platform for immediate no-warmup infrastructure
2. ColdInbox API for programmatic control with traditional warmup
3. Hybrid approach combining both platforms as needed

Why the Wait is Worth It:
The upcoming ColdSend API will be the first to offer immediate deployment capabilities programmatically—no warmup required through API calls.

Comparison: Current State

Use Cases That Transform Businesses

Current API Implementation: ColdInbox

Lead Generation Agencies: Multi-Client Infrastructure

The Challenge: Agency managing 20+ clients with different requirements and budgets.

ColdInbox API Solution:

def manage_multi_client_infrastructure(clients):
    client_infrastructure = {}
    
    for client in clients:
        # Create client-specific domain
        domain = coldinbox_api.create_domain(f"{client.name}-outreach.com")
        
        # Custom inbox allocation based on client package
        inboxes = []
        for i in range(client.inbox_count):
            inbox = coldinbox_api.create_inbox({
                'domain_id': domain.id,
                'username': f'rep{i}',
                'storage': client.storage_per_inbox,
                'warmup_profile': client.warmup_strategy
            })
            inboxes.append(inbox)
        
        # Implement client-specific warmup
        for inbox in inboxes:
            coldinbox_api.configure_warmup(inbox.id, {
                'schedule': client.warmup_schedule,
                'volume_targets': client.volume_goals
            })
        
        client_infrastructure[client.id] = {
            'domain': domain,
            'inboxes': inboxes,
            'monthly_cost': calculate_usage_cost(client)
        }
    
    return client_infrastructure

# Benefits: Full programmatic control available today

SaaS Companies: Custom Market Testing

The Challenge: SaaS company wants to test 10 different market segments with optimized infrastructure.

ColdInbox API Solution:

def create_optimized_market_tests(segments):
    optimized_campaigns = {}
    
    for segment in segments:
        # Create segment-specific infrastructure
        domain = coldinbox_api.create_domain(f"{segment}-test.company.com")
        
        # Optimize infrastructure for segment characteristics
        inbox_config = optimize_for_segment(segment)
        inboxes = []
        
        for config in inbox_config:
            inbox = coldinbox_api.create_inbox({
                'domain_id': domain.id,
                'username': config['username'],
                'warmup_strategy': config['warmup_type'],
                'volume_target': config['volume']
            })
            inboxes.append(inbox)
        
        optimized_campaigns[segment] = {
            'infrastructure': inboxes,
            'cost_optimization': calculate_segment_costs(segment),
            'launch_timeline': '3_weeks'
        }
    
    return optimized_campaigns

Future API Implementation: ColdSend (When Available)

Rapid Client Onboarding (Future Capability)

The Vision: When ColdSend API launches, same-day client onboarding will be possible programmatically.

Planned ColdSend API Solution:

# Future capability - when ColdSend API is released
def rapid_client_onboarding(client_name):
    # Instant infrastructure creation (no warmup)
    campaign = coldsend_api.create_campaign({
        'client': client_name,
        'inboxes': 50,
        'volume': 5000,
        'start_date': 'immediate'  # No warmup needed
    })
    
    # Same-day deployment
    smtp_configs = coldsend_api.get_smtp_configs(campaign.id)
    
    return {
        "status": "ready_to_send",
        "deployment_time": "same_day",
        "smtp_configs": smtp_configs
    }

# Benefits: Immediate deployment via API (when available)

Technical Implementation Guide

Current Implementation: ColdInbox API

Custom Infrastructure Management

class ColdInboxInfrastructureManager:
    def __init__(self, api_key):
        self.api = ColdInboxAPI(api_key)
    
    def build_custom_infrastructure(self, spec):
        """Build infrastructure according to detailed specifications"""
        infrastructure = {
            'domains': [],
            'inboxes': [],
            'warmup_schedules': [],
            'cost_tracking': {}
        }
        
        # Create custom domains
        for domain_spec in spec['domains']:
            domain = self.api.create_domain(domain_spec['name'])
            self.api.configure_dns(domain.id, domain_spec['dns_config'])
            infrastructure['domains'].append(domain)
        
        # Create custom inboxes
        for inbox_spec in spec['inboxes']:
            inbox = self.api.create_inbox({
                'domain_id': inbox_spec['domain_id'],
                'username': inbox_spec['username'],
                'storage_mb': inbox_spec['storage'],
                'custom_settings': inbox_spec.get('settings', {})
            })
            
            # Configure custom warmup
            warmup = self.api.create_warmup_schedule(inbox.id, {
                'strategy': inbox_spec['warmup_strategy'],
                'duration_weeks': inbox_spec['warmup_duration'],
                'volume_progression': inbox_spec['volume_schedule']
            })
            
            infrastructure['inboxes'].append(inbox)
            infrastructure['warmup_schedules'].append(warmup)
        
        # Track usage costs
        infrastructure['cost_tracking'] = self._setup_cost_monitoring(infrastructure)
        
        return infrastructure
    
    def optimize_infrastructure_costs(self, infrastructure_id):
        """Optimize infrastructure for cost efficiency"""
        usage_data = self.api.get_usage_metrics(infrastructure_id)
        
        recommendations = {
            'storage_optimization': self._analyze_storage_usage(usage_data),
            'sending_optimization': self._analyze_sending_patterns(usage_data),
            'scaling_recommendations': self._suggest_scaling_strategy(usage_data)
        }
        
        return recommendations

Advanced Warmup Management

class SmartWarmupManager:
    def __init__(self, coldinbox_api):
        self.api = coldinbox_api
    
    def create_adaptive_warmup(self, inbox_id, target_volume):
        """Create warmup strategy that adapts to performance"""
        
        # Initial conservative warmup
        warmup_config = {
            'week_1': {'daily_volume': 5, 'target_opens': 60},
            'week_2': {'daily_volume': 15, 'target_opens': 55},
            'week_3': {'daily_volume': 30, 'target_opens': 50},
            'week_4': {'daily_volume': target_volume, 'target_opens': 45}
        }
        
        # Create warmup schedule
        schedule = self.api.create_warmup_schedule(inbox_id, warmup_config)
        
        # Monitor and adapt
        self._monitor_warmup_performance(inbox_id, schedule.id)
        
        return schedule
    
    def _monitor_warmup_performance(self, inbox_id, schedule_id):
        """Monitor warmup and adjust strategy based on performance"""
        
        def daily_check():
            metrics = self.api.get_inbox_metrics(inbox_id)
            
            if metrics.deliverability_score < 85:
                # Slow down warmup
                self.api.adjust_warmup_pace(schedule_id, 'conservative')
            elif metrics.deliverability_score > 95:
                # Accelerate warmup
                self.api.adjust_warmup_pace(schedule_id, 'aggressive')
        
        # Schedule daily monitoring
        return daily_check

Future Implementation: ColdSend API Integration

Hybrid Approach (Current + Future)

class HybridEmailInfrastructure:
    def __init__(self):
        self.coldinbox_api = ColdInboxAPI()
        # self.coldsend_api = ColdSendAPI()  # When available
    
    def choose_optimal_infrastructure(self, requirements):
        """Choose best infrastructure approach based on requirements"""
        
        # Current logic - only ColdInbox available
        if requirements.get('api_needed') and requirements.get('immediate_deployment'):
            return {
                'recommendation': 'Wait for ColdSend API or use ColdSend platform + ColdInbox API hybrid',
                'current_option': 'coldinbox_api_with_platform_supplement',
                'future_option': 'coldsend_api_when_available'
            }
        
        elif requirements.get('api_needed') and requirements.get('cost_optimization'):
            return self._deploy_with_coldinbox(requirements)
        
        elif requirements.get('immediate_deployment') and not requirements.get('api_needed'):
            return {
                'recommendation': 'Use ColdSend.pro web platform now',
                'platform': 'coldsend_web',
                'migration_path': 'Switch to ColdSend API when released'
            }
        
        else:
            return self._deploy_with_coldinbox(requirements)
    
    def _deploy_with_coldinbox(self, requirements):
        """Deploy using ColdInbox API (available now)"""
        infrastructure = self.coldinbox_api.build_infrastructure(requirements)
        
        estimated_cost = self._calculate_coldinbox_costs(requirements)
        
        return {
            'provider': 'coldinbox_api',
            'deployment_time': '2-3 weeks',
            'monthly_cost': estimated_cost,
            'infrastructure': infrastructure,
            'status': 'available_now'
        }
    
    # Future method when ColdSend API is available
    def _deploy_with_coldsend_api(self, requirements):
        """Deploy using ColdSend API (when available)"""
        # campaign = self.coldsend_api.create_campaign(requirements)
        
        return {
            'provider': 'coldsend_api',
            'deployment_time': 'immediate',
            'monthly_cost': 50,
            'status': 'coming_soon'
        }

API vs. Traditional Setup: The Economics

Cost Analysis: 100 Email Accounts

Traditional Manual Setup:

• Domain registration: $1,200/year (100 domains × $12)
• Email accounts: $600/month (100 accounts × $6 Google Workspace)
• Setup labor: $2,000 (40 hours × $50/hour)
• Warmup management: $800/month (20 hours × $40/hour)
• Total first year: $19,000

ColdInbox API Infrastructure (Available Now):

• Base platform: $25/month
• Storage (3GB): $30/month
• Sending (100K emails): $5/month
• Setup automation: $800 one-time development
• Ongoing management: $150/month (3 hours × $50/hour)
• Total first year: $2,520

ColdSend Platform (No API Yet):

• Platform subscription: $50/month
• 100 inboxes included + 10K emails
• No automation (manual platform use)
• Ongoing management: $200/month (4 hours × $50/hour)
• Total first year: $3,000

ColdSend API (When Available):

• Platform subscription: $50/month (estimated)
• 100 inboxes included + 10K emails
• Setup automation: $500 one-time development
• Ongoing management: $100/month (2 hours × $50/hour)
• Total first year: $2,300 (estimated)

Savings Analysis

Choosing the Right Cold Email API

Current Decision Matrix

Since ColdSend API isn't available yet, here's how to choose your current approach:

Option 1: ColdInbox API (For Immediate API Needs)

Choose ColdInbox API when:

• ✅ Need programmatic control today
• ✅ Cost optimization is critical
• ✅ Complex multi-client management required
• ✅ Team has technical expertise
• ✅ Can work with warmup requirements

Getting Started:

# Available today
from coldinbox import ColdInboxAPI
api = ColdInboxAPI("your-api-key")

# Full programmatic control
domain = api.create_domain("my-outreach.com")
inbox = api.create_inbox({'domain_id': domain.id, 'username': 'sales1'})

Documentation: ColdInbox API Docs

Option 2: ColdSend Platform + Future API Migration

Choose ColdSend Platform when:

• ✅ Need immediate deployment (no warmup)
• ✅ Prefer simplicity over API control
• ✅ Can wait for API capabilities
• ✅ Budget allows flat-rate pricing

Current Approach:

1. Use ColdSend.pro web platform for immediate needs
2. Plan migration to ColdSend API when released
3. Supplement with ColdInbox API for custom requirements

Option 3: Hybrid Approach

Choose Hybrid when:

• ✅ Need both immediate deployment AND API control
• ✅ Different requirements for different clients
• ✅ Can manage multiple platforms

Implementation:

class HybridInfrastructure:
    def route_client_needs(self, client_requirements):
        if client_requirements.immediate_deployment:
            return "coldsend_platform"  # Web interface
        elif client_requirements.api_control:
            return "coldinbox_api"      # Programmatic
        else:
            return "evaluate_case_by_case"

Common Implementation Challenges

Challenge 1: Rate Limiting and Bulk Operations

Problem: Creating 1000 inboxes hits API rate limits

Solution:

import asyncio
from asyncio import Semaphore

async def create_inboxes_with_rate_limiting(inbox_configs, max_concurrent=10):
    """Create inboxes respecting rate limits"""
    semaphore = Semaphore(max_concurrent)
    
    async def create_single_inbox(config):
        async with semaphore:
            try:
                inbox = await api.create_inbox_async(config)
                await asyncio.sleep(0.1)  # Rate limiting
                return inbox
            except RateLimitError:
                await asyncio.sleep(1)  # Backoff
                return await create_single_inbox(config)
    
    tasks = [create_single_inbox(config) for config in inbox_configs]
    return await asyncio.gather(*tasks)

Challenge 2: Error Handling and Retry Logic

Problem: Network issues cause partial infrastructure creation

Solution:

class InfrastructureManager:
    def __init__(self, api):
        self.api = api
        self.retry_config = {'max_attempts': 3, 'backoff': 2}
    
    async def create_infrastructure_with_retry(self, config):
        """Create infrastructure with automatic retry"""
        created_resources = {'domains': [], 'inboxes': []}
        
        # Track what's created for cleanup on failure
        try:
            # Create domains with retry
            for domain_config in config['domains']:
                domain = await self._retry_operation(
                    self.api.create_domain, domain_config
                )
                created_resources['domains'].append(domain)
            
            # Create inboxes with retry
            for inbox_config in config['inboxes']:
                inbox = await self._retry_operation(
                    self.api.create_inbox, inbox_config
                )
                created_resources['inboxes'].append(inbox)
            
            return created_resources
            
        except Exception as e:
            # Cleanup on failure
            await self._cleanup_resources(created_resources)
            raise InfrastructureCreationError(f"Failed to create infrastructure: {e}")
    
    async def _retry_operation(self, operation, *args, **kwargs):
        """Retry operation with exponential backoff"""
        for attempt in range(self.retry_config['max_attempts']):
            try:
                return await operation(*args, **kwargs)
            except RetryableError as e:
                if attempt == self.retry_config['max_attempts'] - 1:
                    raise e
                await asyncio.sleep(self.retry_config['backoff'] ** attempt)

Challenge 3: Infrastructure State Management

Problem: Tracking infrastructure across multiple clients and campaigns

Solution:

class InfrastructureState:
    def __init__(self, database):
        self.db = database
    
    def track_infrastructure_creation(self, client_id, infrastructure):
        """Track created infrastructure for management"""
        state = {
            'client_id': client_id,
            'domains': [domain.id for domain in infrastructure['domains']],
            'inboxes': [inbox.id for inbox in infrastructure['inboxes']],
            'created_at': datetime.now(),
            'status': 'active'
        }
        return self.db.save_infrastructure_state(state)
    
    def get_client_infrastructure(self, client_id):
        """Retrieve all infrastructure for a client"""
        return self.db.get_infrastructure_by_client(client_id)
    
    def cleanup_client_infrastructure(self, client_id):
        """Remove all infrastructure for a client"""
        infrastructure = self.get_client_infrastructure(client_id)
        
        # Delete inboxes
        for inbox_id in infrastructure['inboxes']:
            api.delete_inbox(inbox_id)
        
        # Delete domains
        for domain_id in infrastructure['domains']:
            api.delete_domain(domain_id)
        
        # Update state
        self.db.mark_infrastructure_deleted(client_id)

The Future of Email Infrastructure APIs

What's Coming: ColdSend API

Planned Features (Based on Platform Capabilities):

• 🔄 Immediate deployment API - no warmup required
• 🔄 Simple endpoint structure focused on speed
• 🔄 Flat-rate API pricing aligned with platform
• 🔄 Integration-first design for existing tools
• 🔄 90%+ deliverability through API calls

Expected Impact:
The ColdSend API will be the first to offer immediate deployment capabilities programmatically, potentially reshaping how developers approach cold email infrastructure.

Industry Evolution

Current State:

• ColdInbox API leads with comprehensive features
• Traditional providers lag in API capabilities
• Warmup requirements still standard in API space

Future Direction:

• No-warmup APIs will become the new standard
• Immediate deployment will be expected, not exceptional
• APIs will focus on simplicity over complexity

Timeline Expectations:

• 2025 Q1-Q2: ColdSend API likely release window
• 2025 H2: Competitive response from traditional providers
• 2026: No-warmup becomes API standard

Getting Started with Cold Email APIs

Current Recommendations

For Immediate API Needs: Start with ColdInbox

# Quick start with ColdInbox API (available now)
from coldinbox import ColdInboxAPI

# 1. Setup
api = ColdInboxAPI("your-api-key")

# 2. Create infrastructure
domain = api.create_domain("my-outreach.com")
api.configure_dns(domain.id)

# 3. Create inboxes
inboxes = []
for i in range(20):
    inbox = api.create_inbox({
        'domain_id': domain.id,
        'username': f'sales{i}',
        'storage': '100MB'
    })
    inboxes.append(inbox)

# 4. Start warmup
for inbox in inboxes:
    api.start_warmup(inbox.id, {'strategy': 'gradual'})

print("Infrastructure created - warmup in progress")

For Immediate Deployment: Use ColdSend Platform

# Current approach for immediate deployment
1. Sign up at ColdSend.pro
2. Access 100 inboxes immediately
3. Start campaigns same day (no warmup)
4. Plan API migration when available

Future-Proofing Strategy

# Prepare for ColdSend API release
class FutureReadyInfrastructure:
    def __init__(self):
        self.coldinbox_api = ColdInboxAPI()
        # self.coldsend_api = None  # Will add when available
    
    def current_deployment(self, requirements):
        """Use best available option today"""
        if requirements.get('immediate_needed'):
            return "Use ColdSend.pro platform + plan API migration"
        else:
            return self.coldinbox_api.deploy(requirements)
    
    def future_migration_plan(self):
        """Prepare for ColdSend API"""
        return {
            'step_1': 'Monitor ColdSend API release announcements',
            'step_2': 'Test ColdSend API in parallel with existing setup',
            'step_3': 'Migrate immediate-deployment needs to ColdSend API',
            'step_4': 'Keep ColdInbox API for custom/cost-optimized needs'
        }

Implementation Checklist

Current Options:

For ColdInbox API:

• Account setup and API key from ColdInbox
• Domain creation and DNS configuration
• Inbox creation workflow implementation
• Warmup strategy configuration
• Cost monitoring and optimization
• Integration with email platforms

For ColdSend Platform (while waiting for API):

• ColdSend.pro account setup
• Immediate campaign deployment testing
• Integration with existing tools via SMTP
• Performance monitoring setup
• API migration planning

The Bottom Line

The cold email API landscape is in a transition period, offering immediate opportunities with a clear path to future enhancement:

Current Reality

ColdInbox API (Available Now):

• ✅ Most comprehensive API currently available
• ✅ Complete programmatic control over infrastructure
• ✅ Usage-based pricing starting at $25/month
• ✅ Custom warmup strategies and optimization
• ⚠️ Warmup required (2-3 weeks deployment)

ColdSend Platform (No API Yet):

• ✅ Immediate deployment (no warmup needed)
• ✅ 90%+ deliverability from day one
• ✅ Flat $50/month pricing
• ⚠️ No API (web platform only)
• 🔄 API planned for future release

The question isn't whether APIs will replace manual infrastructure management — it's whether your business will be among the early adopters gaining maximum advantage, or among the late adopters struggling to catch up.

For businesses needing APIs today:
Use ColdInbox API for comprehensive programmatic control, accepting warmup requirements.

For businesses prioritizing speed:
Use ColdSend.pro platform for immediate deployment, plan API migration when available.

For maximum flexibility:
Consider hybrid approach using both platforms for different use cases.

For future-focused development:
Build with ColdInbox API now, prepare migration path to ColdSend API when released.

The Opportunity

First-mover advantage: When ColdSend API launches, it will be the first to offer immediate deployment programmatically—a significant competitive advantage for early adopters.

Ready to start building with cold email APIs?

Current Options:

🔧 For API control today:

• ColdInbox API - Complete API documentation
• Start building now - Comprehensive programmatic control

🚀 For immediate deployment:

• ColdSend.pro Platform - No-warmup infrastructure
• Sign up now - Start sending campaigns today

📈 Stay informed:

• API roadmap updates - Follow ColdSend API development
• Best practices guide - Current landscape analysis

The API revolution in cold email is here. Start building today with available tools, and be ready to leverage breakthrough capabilities when they arrive.

The future of cold email infrastructure is programmatic. The question isn't whether to adopt APIs—it's how to position your business for both current opportunities and future breakthroughs.

Transform your email infrastructure with the APIs available today, while preparing for the no-warmup API revolution coming soon.