Get started with Blazing Gateway and deploy your first edge gateway

Getting Started


Blazing Gateway is a global edge gateway that provides VoIP capabilities, intelligent traffic routing, and low-latency connectivity for real-time communication workloads within Blazing Core.

<Alert type="warning">
  <div className="flex flex-col gap-2">
    <div className="font-semibold">Coming Soon</div>
    <div>
      Blazing Gateway is currently in development. Get in touch for priority access and early-bird pricing.
    </div>
  </div>
</Alert>

## Overview

Blazing Gateway provides a global edge network for:

- **VoIP Infrastructure**: Deploy SIP servers, media gateways, and voice routing
- **Real-Time Communications**: WebRTC, SIP trunking, and call routing
- **Edge Computing**: Process traffic at the edge for ultra-low latency
- **Global Connectivity**: Multi-region deployment with intelligent failover

### Key Features

- **Global Edge Network**: Deploy across 100+ edge locations worldwide
- **VoIP Native**: Built-in SIP proxy, media gateway, and call routing
- **Low Latency**: < 50ms latency to 95% of internet users
- **Auto-Scaling**: Automatically scale based on traffic patterns
- **DDoS Protection**: Built-in protection against volumetric attacks

## Use Cases

### VoIP Infrastructure

Deploy production-ready VoIP infrastructure:

- **SIP Proxy**: Route SIP signaling traffic globally
- **Media Gateway**: Transcode and relay RTP/SRTP media streams
- **Call Routing**: Intelligent routing based on cost, quality, and location
- **Number Portability**: Support for local and toll-free numbers globally

### Real-Time Communications

Power real-time communication applications:

- **WebRTC Gateway**: Connect WebRTC clients to SIP networks
- **Video Conferencing**: Multi-party video with selective forwarding
- **Screen Sharing**: Low-latency screen sharing infrastructure
- **File Transfer**: P2P file transfer with fallback relay

### Edge Computing

Process traffic at the edge:

- **Request Routing**: Route requests to optimal backend locations
- **Protocol Translation**: Convert between protocols (SIP ↔ WebRTC)
- **Media Processing**: Transcode, mix, and record media streams
- **Analytics**: Real-time call quality metrics and analytics

## Architecture

Blazing Gateway runs at the edge of Blazing Core's global network:

```mermaid
graph LR
    Client[VoIP Client] --> Gateway[Blazing Gateway]
    Gateway --> Core[Blazing Core]
    Gateway --> PSTN[PSTN Network]
    Gateway --> Trunk[SIP Trunk]

    Core --> Services[Your Services]

    style Gateway fill:#FA4F1D,stroke:#FA4F1D,color:#fff
    style Core fill:#1a1a1a,stroke:#FA4F1D
    style Services fill:#1a1a1a,stroke:#555
    style PSTN fill:#1a1a1a,stroke:#555
    style Trunk fill:#1a1a1a,stroke:#555
```

### Components

1. **SIP Proxy**: Handle SIP signaling (INVITE, BYE, REGISTER)
2. **Media Gateway**: Process RTP/SRTP media streams
3. **Call Router**: Route calls based on policies and rules
4. **Load Balancer**: Distribute traffic across edge locations
5. **DDoS Protection**: Filter malicious traffic before it reaches infrastructure

## VoIP Features

### SIP Support

Full SIP stack implementation:

- **SIP/2.0**: RFC 3261 compliant
- **Authentication**: Digest authentication, TLS certificates
- **Encryption**: TLS for signaling, SRTP for media
- **NAT Traversal**: STUN, TURN, and ICE support
- **Codecs**: G.711, G.722, Opus, and more

### Call Routing

Intelligent call routing:

```yaml
# gateway.yaml
version: 1

routing:
  - match:
      prefix: "+1"
    route:
      - provider: "us-carrier-1"
        priority: 1
      - provider: "us-carrier-2"
        priority: 2

  - match:
      prefix: "+44"
    route:
      - provider: "uk-carrier-1"
        priority: 1
```

### Media Processing

Handle media streams:

- **Transcoding**: Convert between codecs
- **Recording**: Record calls for compliance or analytics
- **Mixing**: Mix multiple audio streams for conferencing
- **DTMF**: Detect and generate DTMF tones

## Deployment

### Edge Locations

Deploy across global edge network:

```bash
# Deploy to multiple regions
blazing gateway deploy \
  --regions us-east,us-west,eu-west,ap-south \
  --config gateway.yaml
```

### Configuration

Configure gateway behavior:

```yaml
# gateway.yaml
version: 1

gateway:
  name: voip-gateway

  sip:
    port: 5060
    tls_port: 5061
    domain: sip.example.com

  media:
    rtp_port_range: 10000-20000
    codecs:
      - opus
      - g722
      - pcmu

  routing:
    strategy: least-cost
    failover: true

  security:
    ddos_protection: true
    rate_limit: 1000
    whitelist:
      - 192.0.2.0/24
```

### Monitoring

Monitor gateway health:

- **Call Metrics**: Call volume, duration, completion rate
- **Quality Metrics**: Jitter, packet loss, MOS scores
- **System Metrics**: CPU, memory, network bandwidth
- **Alerts**: Automated alerts for anomalies

## Integration with Blazing Core

Blazing Gateway seamlessly integrates with Blazing Core:

### Service Integration

Connect gateway to Blazing Core services:

```yaml
# gateway.yaml
version: 1

integration:
  core:
    enabled: true
    services:
      - name: call-handler
        endpoint: https://call-handler.blazing.run
      - name: voicemail
        endpoint: https://voicemail.blazing.run
```

### Event Webhooks

Receive gateway events:

```python
# call-handler service
@app.route('/webhook/call-started')
async def call_started(event):
    call_id = event['call_id']
    caller = event['from']
    callee = event['to']

    # Handle call started event
    await log_call(call_id, caller, callee)

    return {'status': 'ok'}
```

## Security

### Network Security

- **DDoS Protection**: Volumetric attack mitigation
- **IP Whitelisting**: Restrict access by IP
- **Rate Limiting**: Prevent abuse and fraud
- **TLS/SRTP**: End-to-end encryption

### Fraud Prevention

- **Call Pattern Analysis**: Detect unusual call patterns
- **Cost Thresholds**: Automatic limits on high-cost calls
- **Blacklisting**: Block known fraudulent numbers
- **Authentication**: Require authentication for outbound calls

## Pricing

Blazing Gateway pricing will be based on usage:

- **Call Minutes**: Pay per minute of calling
- **Data Transfer**: Pay for RTP/SRTP traffic
- **Edge Compute**: Pay for media processing
- **No Base Fee**: Only pay for what you use

**Coming Soon**: Detailed pricing will be announced with product launch.

## Getting Started

<Alert type="info">
  <div className="flex flex-col gap-2">
    <div className="font-semibold">Priority Access Available</div>
    <div>
      Blazing Gateway is coming soon. Contact us to get priority access and early-bird pricing.
    </div>
  </div>
</Alert>

### Prerequisites

- Blazing Core account
- VoIP or real-time communication requirements
- SIP trunk or PSTN connectivity (optional)

### Quick Start

1. **Request Access**: Contact us for Blazing Gateway early access
2. **Configure Gateway**: Define your gateway configuration
3. **Deploy**: Deploy gateway to edge locations
4. **Test**: Make test calls to verify connectivity
5. **Go Live**: Route production traffic through gateway

## Support

Need help with Blazing Gateway?

- **Documentation**: Browse our comprehensive guides (coming soon)
- **Community**: Join our Discord for peer support
- **Priority Access**: Contact us for early access and dedicated support

## Next Steps

- **Contact Us**: Get priority access to Blazing Gateway
- **Learn More**: Read about Blazing Core capabilities
- **Explore**: Check out VoIP best practices


Global edge gateway with VoIP capabilities and intelligent traffic routing

Blazing Gateway Introduction


Get your first Blazing Gateway instance up and running in minutes.

## Prerequisites

Before you begin, ensure you have:

- A Blazing Core account with active subscription
- Blazing CLI installed (`npm install -g @blazing/cli`)
- Basic understanding of VoIP or edge networking concepts
- A SIP trunk provider (optional, for PSTN connectivity)

## Installation

### Install Blazing CLI

```bash
npm install -g @blazing/cli
```

### Authenticate

```bash
blazing login
```

Follow the prompts to authenticate with your Blazing Core account.

## Your First Gateway

### 1. Initialize Gateway Configuration

Create a new gateway configuration file:

```bash
blazing gateway init
```

This creates a `gateway.yaml` file with default configuration:

```yaml
version: 1

gateway:
  name: my-first-gateway

  sip:
    port: 5060
    tls_port: 5061
    domain: gateway.example.com

  media:
    rtp_port_range: 10000-20000
    codecs:
      - opus
      - g722
      - pcmu

  regions:
    - us-east-1
    - eu-west-1

  routing:
    strategy: least-cost
    failover: true
```

### 2. Deploy Gateway

Deploy your gateway to the edge:

```bash
blazing gateway deploy --config gateway.yaml
```

The CLI will:
1. Validate your configuration
2. Provision edge infrastructure
3. Configure routing and networking
4. Deploy your gateway instances

### 3. Verify Deployment

Check gateway status:

```bash
blazing gateway status my-first-gateway
```

You should see output like:

```
Gateway: my-first-gateway
Status: RUNNING
Regions: us-east-1, eu-west-1
Endpoints:
  - sip.us-east-1.gateway.blazing.run:5060
  - sip.eu-west-1.gateway.blazing.run:5060
Health: OK
Uptime: 2m 34s
```

## Test Your Gateway

### Make a Test Call

Use a SIP client to test connectivity:

```bash
# Using sipml5 or similar SIP client
sip:test@sip.us-east-1.gateway.blazing.run:5060
```

### Monitor Call Metrics

View real-time metrics:

```bash
blazing gateway metrics my-first-gateway --live
```

## Configure Routing

### Add SIP Trunk

Connect a SIP trunk for PSTN calling:

```yaml
# gateway.yaml
routing:
  - match:
      prefix: "+1"  # North America
    route:
      - provider: "twilio"
        trunk_uri: "sip:trunk.twilio.com"
        credentials:
          username: "ACxxxxxx"
          password: "your-auth-token"
        priority: 1
```

Apply the changes:

```bash
blazing gateway update my-first-gateway --config gateway.yaml
```

## Next Steps

Now that you have a basic gateway running:

- [Review configuration options](/docs/configuration-reference)
- [Explore use cases and examples](/docs/use-cases-examples)
- [Learn about Blazing Core](/docs/introduction)

## Troubleshooting

### Gateway won't start

Check logs for errors:

```bash
blazing gateway logs my-first-gateway --tail 100
```

### Can't connect via SIP

Verify firewall rules allow SIP traffic:
- Port 5060 (UDP/TCP) for SIP
- Port 5061 (TCP) for SIP over TLS
- Ports 10000-20000 (UDP) for RTP media

### Poor call quality

Check network metrics:

```bash
blazing gateway metrics my-first-gateway --filter network
```

Look for high jitter or packet loss.

## Getting Help

- Join our [Discord community](https://discord.gg/blazing)
- Check the [Gateway documentation](/docs/introduction)
- Contact support at support@blazing.run


Get started with Blazing Gateway in minutes

Quick Start Guide

Configure Blazing Gateway routing, security, and advanced features

Configuration


Complete reference for configuring Blazing Gateway, including SIP settings, routing rules, security policies, and integration options.

## Configuration File Structure

The `gateway.yaml` file defines all aspects of your gateway:

```yaml
version: 1

gateway:
  name: string
  sip: {}
  media: {}
  routing: []
  security: {}
  monitoring: {}
  integration: {}
```

## Gateway Settings

### Basic Configuration

```yaml
gateway:
  name: production-gateway  # Gateway identifier
  description: "Production VoIP gateway for customer calls"

  # Geographic regions for deployment
  regions:
    - us-east-1
    - us-west-2
    - eu-west-1
    - ap-south-1

  # High availability settings
  ha:
    enabled: true
    min_instances: 2
    max_instances: 10
```

## SIP Configuration

### SIP Server Settings

```yaml
sip:
  # SIP server ports
  port: 5060           # UDP/TCP port
  tls_port: 5061       # TLS port
  ws_port: 8080        # WebSocket port
  wss_port: 8443       # WebSocket Secure port

  # SIP domain
  domain: sip.example.com

  # Transport protocols
  transports:
    - udp
    - tcp
    - tls
    - ws
    - wss

  # SIP timers (RFC 3261)
  timers:
    t1: 500ms          # RTT estimate
    t2: 4s             # Max retransmit interval
    t4: 5s             # Max duration message remains in network
```

### Authentication

```yaml
sip:
  authentication:
    enabled: true
    realm: "blazing.run"

    # Authentication methods
    methods:
      - digest          # RFC 2617
      - tls-cert        # Certificate-based

    # User database
    users:
      - username: "user1"
        password: "hashed-password"
        display_name: "User One"

      - username: "user2"
        password: "hashed-password"
        display_name: "User Two"

    # External authentication
    external_auth:
      enabled: true
      endpoint: "https://auth.example.com/sip-auth"
      timeout: 2s
```

### TLS/Encryption

```yaml
sip:
  tls:
    enabled: true

    # Certificate configuration
    certificate:
      cert_file: "/path/to/cert.pem"
      key_file: "/path/to/key.pem"
      ca_file: "/path/to/ca.pem"

    # TLS version
    min_version: "1.2"

    # Cipher suites
    ciphers:
      - "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"
      - "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
```

## Media Configuration

### RTP/SRTP Settings

```yaml
media:
  # RTP port range
  rtp_port_range: 10000-20000

  # Supported codecs (in preference order)
  codecs:
    - opus            # 48kHz wideband
    - g722            # 16kHz wideband
    - pcmu            # G.711 μ-law
    - pcma            # G.711 A-law
    - g729            # 8kbit/s compressed

  # SRTP encryption
  srtp:
    enabled: true
    crypto_suites:
      - AES_CM_128_HMAC_SHA1_80
      - AES_CM_128_HMAC_SHA1_32

  # DTMF handling
  dtmf:
    methods:
      - rfc2833       # RTP telephone events
      - info          # SIP INFO
      - inband        # Audio tone detection
```

### Media Processing

```yaml
media:
  processing:
    # Transcoding
    transcoding:
      enabled: true
      max_channels: 100

    # Recording
    recording:
      enabled: false
      format: wav
      storage: s3://my-bucket/recordings

    # Mixing (for conferencing)
    mixing:
      enabled: true
      max_participants: 50

    # Noise suppression
    noise_suppression:
      enabled: true
      level: moderate  # low, moderate, aggressive
```

### NAT Traversal

```yaml
media:
  nat_traversal:
    # STUN server
    stun:
      enabled: true
      servers:
        - "stun:stun.l.google.com:19302"

    # TURN relay
    turn:
      enabled: true
      servers:
        - "turn:turn.example.com:3478"
      credentials:
        username: "turnuser"
        password: "turnpass"

    # ICE
    ice:
      enabled: true
      lite: false
```

## Routing Configuration

### Call Routing

```yaml
routing:
  # Default routing strategy
  strategy: least-cost  # least-cost, round-robin, priority

  # Routing rules
  rules:
    # US calls
    - name: "US Domestic"
      match:
        prefix: "+1"
        exclude:
          - "+1900"  # Premium rate
      route:
        - provider: "twilio"
          trunk: "sip:trunk.twilio.com"
          priority: 1
          weight: 70
        - provider: "bandwidth"
          trunk: "sip:trunk.bandwidth.com"
          priority: 1
          weight: 30
        - provider: "voxbone"
          trunk: "sip:trunk.voxbone.com"
          priority: 2  # Failover
      cost_per_minute: 0.01

    # UK calls
    - name: "UK Domestic"
      match:
        prefix: "+44"
      route:
        - provider: "uk-carrier"
          trunk: "sip:trunk.uk-carrier.com"
          priority: 1
      cost_per_minute: 0.02

    # International calls
    - name: "International"
      match:
        prefix: "+"
      route:
        - provider: "global-carrier"
          trunk: "sip:trunk.global.com"
          priority: 1
      cost_per_minute: 0.15
```

### Load Balancing

```yaml
routing:
  load_balancing:
    # Load balancing algorithm
    algorithm: weighted-round-robin  # round-robin, least-connections, ip-hash

    # Health checks
    health_checks:
      enabled: true
      interval: 30s
      timeout: 5s
      unhealthy_threshold: 3
      healthy_threshold: 2

      # SIP OPTIONS ping
      method: options
      uri: "sip:healthcheck@trunk.example.com"
```

### Failover

```yaml
routing:
  failover:
    enabled: true

    # Automatic failover conditions
    triggers:
      - error_rate_threshold: 0.1  # 10% error rate
      - latency_threshold: 500ms
      - consecutive_failures: 3

    # Failback settings
    failback:
      enabled: true
      delay: 5m  # Wait 5 minutes before failing back
```

## Security Configuration

### DDoS Protection

```yaml
security:
  ddos_protection:
    enabled: true

    # Rate limiting
    rate_limits:
      # Per IP limits
      per_ip:
        requests_per_second: 10
        burst: 20

      # Per user limits
      per_user:
        calls_per_minute: 30
        concurrent_calls: 5

      # Global limits
      global:
        calls_per_second: 1000
```

### Access Control

```yaml
security:
  access_control:
    # IP whitelist
    whitelist:
      enabled: true
      ips:
        - 192.0.2.0/24
        - 198.51.100.0/24

      # Whitelist mode
      mode: strict  # strict, permissive

    # IP blacklist
    blacklist:
      enabled: true
      ips:
        - 203.0.113.0/24

      # Automatic blacklisting
      auto_blacklist:
        enabled: true
        threshold: 10  # Failed auth attempts
        duration: 1h
```

### Fraud Prevention

```yaml
security:
  fraud_prevention:
    enabled: true

    # Cost thresholds
    cost_limits:
      per_call: 10.00      # Max $10 per call
      per_hour: 100.00     # Max $100 per hour
      per_day: 1000.00     # Max $1000 per day

    # Pattern detection
    pattern_detection:
      enabled: true

      # Unusual call patterns
      alerts:
        - rapid_sequential_calls: 10  # 10+ calls in quick succession
        - long_duration: 2h           # Calls > 2 hours
        - premium_rate: true          # Calls to premium numbers

    # Number blacklist
    number_blacklist:
      - prefix: "+1900"  # Premium rate
      - prefix: "+882"   # International premium
```

## Monitoring Configuration

### Metrics

```yaml
monitoring:
  metrics:
    enabled: true

    # Prometheus export
    prometheus:
      enabled: true
      port: 9090
      path: /metrics

    # Custom metrics
    custom_metrics:
      - name: call_volume
        type: counter
      - name: call_duration
        type: histogram
      - name: call_quality_mos
        type: gauge
```

### Logging

```yaml
monitoring:
  logging:
    # Log level
    level: info  # debug, info, warn, error

    # Log format
    format: json  # json, text

    # Log destinations
    destinations:
      - type: stdout
      - type: file
        path: /var/log/gateway.log
        rotation:
          max_size: 100MB
          max_age: 30d
          max_backups: 10
      - type: syslog
        address: "syslog.example.com:514"
      - type: s3
        bucket: "s3://logs-bucket"
        prefix: "gateway-logs/"
```

### Alerts

```yaml
monitoring:
  alerts:
    enabled: true

    # Alert rules
    rules:
      - name: high_error_rate
        condition: error_rate > 0.05
        duration: 5m
        severity: critical

      - name: high_latency
        condition: p95_latency > 500ms
        duration: 10m
        severity: warning

      - name: low_call_quality
        condition: avg_mos < 3.5
        duration: 5m
        severity: warning

    # Notification channels
    notifications:
      - type: email
        addresses:
          - ops@example.com
      - type: slack
        webhook: "https://hooks.slack.com/services/xxx"
      - type: pagerduty
        integration_key: "xxx"
```

## Integration Configuration

### Blazing Core Integration

```yaml
integration:
  core:
    enabled: true

    # Connected services
    services:
      - name: call-handler
        endpoint: "https://call-handler.blazing.run"
        events:
          - call.started
          - call.ended
          - call.failed

      - name: voicemail
        endpoint: "https://voicemail.blazing.run"
        events:
          - call.no_answer
```

### Webhooks

```yaml
integration:
  webhooks:
    enabled: true

    # Webhook endpoints
    endpoints:
      - url: "https://example.com/webhook"
        events:
          - call.started
          - call.ended
        headers:
          Authorization: "Bearer token123"
        retry:
          max_attempts: 3
          backoff: exponential
```

## Environment Variables

Override configuration with environment variables:

```bash
# Gateway settings
GATEWAY_NAME=production-gateway
GATEWAY_REGIONS=us-east-1,eu-west-1

# SIP settings
SIP_DOMAIN=sip.example.com
SIP_PORT=5060
SIP_TLS_PORT=5061

# Security
SECURITY_DDOS_ENABLED=true
SECURITY_RATE_LIMIT=1000

# Authentication
AUTH_ENDPOINT=https://auth.example.com
AUTH_TIMEOUT=2s
```

## Configuration Validation

Validate your configuration before deployment:

```bash
blazing gateway validate --config gateway.yaml
```

This will check:
- YAML syntax
- Required fields
- Value ranges
- Conflicting settings
- Security best practices

## Complete Example

Here's a complete production-ready configuration:

```yaml
version: 1

gateway:
  name: production-gateway
  description: "Production VoIP gateway"
  regions:
    - us-east-1
    - eu-west-1
  ha:
    enabled: true
    min_instances: 2
    max_instances: 10

sip:
  port: 5060
  tls_port: 5061
  domain: sip.example.com
  transports:
    - udp
    - tcp
    - tls
  authentication:
    enabled: true
    external_auth:
      endpoint: "https://auth.example.com"
  tls:
    enabled: true
    min_version: "1.2"

media:
  rtp_port_range: 10000-20000
  codecs:
    - opus
    - g722
    - pcmu
  srtp:
    enabled: true

routing:
  strategy: least-cost
  rules:
    - name: "US Domestic"
      match:
        prefix: "+1"
      route:
        - provider: "twilio"
          trunk: "sip:trunk.twilio.com"
          priority: 1

security:
  ddos_protection:
    enabled: true
  rate_limits:
    per_ip:
      requests_per_second: 10
  fraud_prevention:
    enabled: true
    cost_limits:
      per_day: 1000.00

monitoring:
  metrics:
    enabled: true
    prometheus:
      enabled: true
  logging:
    level: info
    format: json
  alerts:
    enabled: true
    notifications:
      - type: email
        addresses:
          - ops@example.com

integration:
  core:
    enabled: true
  webhooks:
    enabled: true
```

## Next Steps

- [Get started with a quick start guide](/docs/quick-start)
- [Explore use cases and examples](/docs/use-cases-examples)
- [Learn about Blazing Core deployment](/docs/deployment-lifecycle)


Complete reference for Blazing Gateway configuration

Configuration Reference

Real-world use cases and implementation examples for Blazing Gateway

Use Cases


Explore real-world use cases and implementation examples for Blazing Gateway across different industries and scenarios.

## Call Center Infrastructure

Build scalable call center infrastructure with Blazing Gateway.

### Requirements

- Handle 1000+ concurrent calls
- Route calls to available agents
- Record calls for quality assurance
- Provide real-time analytics

### Implementation

```yaml
# callcenter-gateway.yaml
version: 1

gateway:
  name: callcenter-gateway
  regions:
    - us-east-1
    - us-west-2
  ha:
    enabled: true
    min_instances: 5
    max_instances: 50

sip:
  domain: calls.callcenter.com
  authentication:
    enabled: true
    external_auth:
      endpoint: "https://api.callcenter.com/auth"

media:
  codecs:
    - opus
    - g722
  processing:
    recording:
      enabled: true
      storage: s3://callcenter-recordings
    mixing:
      enabled: true
      max_participants: 10

routing:
  rules:
    - name: "Inbound Calls"
      match:
        direction: inbound
      route:
        - service: agent-router
          endpoint: "https://router.callcenter.com"

integration:
  core:
    enabled: true
    services:
      - name: agent-router
        endpoint: "https://router.callcenter.com"
        events:
          - call.started
          - call.queued

monitoring:
  metrics:
    enabled: true
  alerts:
    rules:
      - name: queue_time_high
        condition: avg_queue_time > 120s
        severity: warning
```

### Agent Router Service

```python
from blazing import Flow

@Flow.task
async def route_to_available_agent(call):
    """Find and route to available agent"""

    # Find available agent
    agent = await find_available_agent(
        skills=call.required_skills,
        language=call.language
    )

    if not agent:
        # Queue the call
        position = await queue_call(call)
        await play_hold_music(call, position)
        return

    # Route to agent
    await transfer_call(call, agent.sip_uri)

    # Track metrics
    await log_metrics({
        'call_id': call.id,
        'agent_id': agent.id,
        'queue_time': call.queue_duration
    })
```

### Benefits

- **Scalability**: Auto-scale from 0 to 1000+ concurrent calls
- **Reliability**: Multi-region deployment with automatic failover
- **Analytics**: Real-time metrics on queue times, agent performance
- **Cost**: Pay only for actual call minutes

---

## SIP Trunking Provider

Build a SIP trunking service with Blazing Gateway.

### Requirements

- Provide SIP trunking to customers
- Support multiple carriers for redundancy
- Implement least-cost routing
- Bill customers accurately

### Implementation

```yaml
# trunking-gateway.yaml
version: 1

gateway:
  name: trunking-gateway
  regions:
    - us-east-1
    - us-west-2
    - eu-west-1
    - ap-south-1

routing:
  strategy: least-cost

  rules:
    # US Domestic
    - name: "US Domestic"
      match:
        prefix: "+1"
        exclude:
          - "+1900"  # Block premium
      route:
        - provider: "carrier-a"
          trunk: "sip:trunk-a.com"
          priority: 1
          cost_per_minute: 0.008
        - provider: "carrier-b"
          trunk: "sip:trunk-b.com"
          priority: 1
          cost_per_minute: 0.009
        - provider: "carrier-c"
          trunk: "sip:trunk-c.com"
          priority: 2  # Failover
          cost_per_minute: 0.012

    # UK Domestic
    - name: "UK Domestic"
      match:
        prefix: "+44"
      route:
        - provider: "uk-carrier"
          trunk: "sip:uk-trunk.com"
          cost_per_minute: 0.015

security:
  fraud_prevention:
    enabled: true
    cost_limits:
      per_customer:
        per_hour: 50.00
        per_day: 500.00
    pattern_detection:
      enabled: true

integration:
  webhooks:
    endpoints:
      - url: "https://billing.example.com/cdr"
        events:
          - call.ended
        retry:
          max_attempts: 5
```

### Billing Integration

```python
from blazing import Webhook

@Webhook.handler("call.ended")
async def process_call_billing(event):
    """Process call for billing"""

    call = event.call
    customer = await get_customer(call.customer_id)

    # Calculate cost
    duration_minutes = call.duration / 60
    cost = call.cost_per_minute * duration_minutes
    markup = cost * customer.markup_percentage

    # Create invoice line item
    await create_invoice_item(
        customer_id=customer.id,
        description=f"Call to {call.destination}",
        quantity=duration_minutes,
        unit_price=call.cost_per_minute + markup,
        total=cost + markup,
        metadata={
            'call_id': call.id,
            'duration': call.duration,
            'destination': call.destination
        }
    )
```

### Benefits

- **Multi-Carrier**: Automatic failover between carriers
- **Cost Optimization**: Intelligent least-cost routing
- **Global Reach**: Support calls to 200+ countries
- **Fraud Protection**: Built-in fraud detection and limits

---

## WebRTC Communication Platform

Build a WebRTC-based communication platform with Blazing Gateway.

### Requirements

- WebRTC to SIP calling
- Video conferencing
- Screen sharing
- PSTN connectivity

### Implementation

```yaml
# webrtc-gateway.yaml
version: 1

gateway:
  name: webrtc-gateway

sip:
  # WebSocket support for WebRTC
  ws_port: 8080
  wss_port: 8443
  transports:
    - wss  # WebSocket Secure

media:
  codecs:
    - opus      # Audio
    - vp8       # Video
    - vp9       # Video
    - h264      # Video

  srtp:
    enabled: true

  nat_traversal:
    stun:
      enabled: true
    turn:
      enabled: true
      servers:
        - "turn:turn.example.com:3478"
    ice:
      enabled: true

  processing:
    # Video mixing for conferencing
    mixing:
      enabled: true
      max_participants: 50
      layouts:
        - grid
        - speaker
        - custom

routing:
  rules:
    # WebRTC to PSTN
    - name: "WebRTC to PSTN"
      match:
        source: webrtc
        destination_prefix: "+"
      route:
        - provider: "pstn-carrier"
          trunk: "sip:trunk.carrier.com"
```

### WebRTC Client Integration

```javascript
// WebRTC client
import { BlazingWebRTC } from '@blazing/webrtc-sdk';

const client = new BlazingWebRTC({
  gateway: 'wss://gateway.example.com:8443',
  credentials: {
    username: 'user@example.com',
    password: 'password'
  }
});

// Make a call to PSTN
const call = await client.call('+14155551234', {
  audio: true,
  video: false
});

// Join a video conference
const conference = await client.joinConference('meeting-123', {
  audio: true,
  video: true,
  screen: false
});

// Share screen
await conference.shareScreen();
```

### Benefits

- **WebRTC Native**: Built-in WebRTC support
- **Video Conferencing**: Multi-party video with SFU
- **PSTN Integration**: Call regular phones from WebRTC
- **Global Edge**: Low-latency connections worldwide

---

## IoT Device Connectivity

Enable IoT devices to make voice calls with Blazing Gateway.

### Requirements

- Connect IoT devices (doorbells, security systems)
- Low bandwidth audio codecs
- Push notifications for incoming calls
- Emergency calling (E911)

### Implementation

```yaml
# iot-gateway.yaml
version: 1

gateway:
  name: iot-gateway

sip:
  authentication:
    enabled: true
    # Device authentication
    external_auth:
      endpoint: "https://api.iot.com/device-auth"

media:
  codecs:
    - opus  # Efficient compression
    - g729  # Low bandwidth

  processing:
    # Noise suppression for outdoor devices
    noise_suppression:
      enabled: true
      level: aggressive

routing:
  rules:
    # Emergency calls
    - name: "Emergency Services"
      match:
        destination: "911"
      route:
        - provider: "e911-provider"
          trunk: "sip:e911.carrier.com"
          priority: 1
          # Send device location
          headers:
            X-Location: "${device.location}"

    # Regular calls
    - name: "Regular Calls"
      match:
        destination_prefix: "+"
      route:
        - provider: "carrier"
          trunk: "sip:trunk.carrier.com"

integration:
  webhooks:
    endpoints:
      - url: "https://api.iot.com/call-event"
        events:
          - call.started
        # Trigger push notification to mobile app
```

### Device Integration

```python
# IoT device code
from blazing_iot import SIPClient

# Initialize SIP client on device
client = SIPClient(
    gateway="sip:gateway.example.com",
    device_id="doorbell-12345",
    credentials=get_device_credentials()
)

# Make call when doorbell pressed
async def on_doorbell_press():
    # Get registered mobile numbers
    numbers = await get_owner_numbers()

    # Call owner's mobile
    call = await client.call(
        destination=numbers[0],
        metadata={
            'device_id': 'doorbell-12345',
            'location': get_gps_location(),
            'video_stream': get_camera_url()
        }
    )
```

### Benefits

- **Device-Optimized**: Low-bandwidth codecs for IoT
- **Reliable**: Multi-region deployment for high availability
- **E911 Support**: Emergency calling with location
- **Scale**: Support millions of connected devices

---

## UCaaS (Unified Communications)

Build a unified communications platform with Blazing Gateway.

### Requirements

- PBX functionality
- Call forwarding and routing
- Voicemail
- Presence and status
- Integration with Slack, Teams, etc.

### Implementation

```yaml
# ucaas-gateway.yaml
version: 1

gateway:
  name: ucaas-gateway

sip:
  domain: pbx.company.com
  authentication:
    enabled: true
    users:
      # Define users and extensions
      - username: "alice"
        extension: "1001"
        display_name: "Alice Smith"
      - username: "bob"
        extension: "1002"
        display_name: "Bob Jones"

routing:
  rules:
    # Call forwarding
    - name: "Call Forwarding"
      match:
        destination: "${user.extension}"
      route:
        - action: check_presence
          if_available: ring_user
          if_busy: send_to_voicemail
          if_away: forward_to_mobile

    # Voicemail
    - name: "Voicemail"
      match:
        destination: "voicemail"
      route:
        - service: voicemail
          endpoint: "https://voicemail.company.com"

integration:
  core:
    enabled: true
    services:
      # Presence service
      - name: presence
        endpoint: "https://presence.company.com"
        events:
          - user.available
          - user.busy
          - user.away

      # Slack integration
      - name: slack
        endpoint: "https://slack-integration.company.com"
        events:
          - call.missed
          - voicemail.new
```

### Features Implementation

```python
from blazing import Flow

@Flow.task
async def handle_incoming_call(call):
    """Intelligent call routing based on presence"""

    user = await get_user_by_extension(call.destination)

    # Check user presence
    presence = await check_presence(user.id)

    if presence == 'available':
        # Ring user's devices
        await ring_devices(user.devices)

    elif presence == 'busy':
        # Check if user allows interruptions
        if call.priority == 'urgent':
            await ring_with_notification(user, 'Urgent call')
        else:
            await send_to_voicemail(call)

    elif presence == 'away':
        # Forward to mobile
        if user.forward_to_mobile:
            await forward_call(call, user.mobile_number)
        else:
            await send_to_voicemail(call)

@Flow.task
async def notify_missed_call(call):
    """Notify user of missed call via Slack"""

    await send_slack_message(
        user=call.destination_user,
        message=f"Missed call from {call.caller_id}",
        actions=[
            {'label': 'Call back', 'action': 'call_back'},
            {'label': 'Send SMS', 'action': 'send_sms'}
        ]
    )
```

### Benefits

- **Feature-Rich**: Full PBX features without hardware
- **Integrations**: Connect with Slack, Teams, CRM systems
- **Mobile**: Works on desk phones, softphones, mobile apps
- **Analytics**: Detailed call analytics and reporting

---

## Compliance Recording

Implement compliant call recording for regulated industries.

### Requirements

- Record all calls for compliance
- Store recordings securely with encryption
- Retention policies
- Audit logs

### Implementation

```yaml
# compliance-gateway.yaml
version: 1

gateway:
  name: compliance-gateway

media:
  processing:
    recording:
      enabled: true
      # Record all calls
      policy: all
      format: wav
      sample_rate: 16000

      # Encrypted storage
      storage: s3://compliance-recordings
      encryption:
        enabled: true
        key_id: "aws:kms:key-id"

      # Metadata
      metadata:
        - caller_id
        - destination
        - duration
        - agent_id
        - customer_id

security:
  access_control:
    # Strict access control
    recording_access:
      roles:
        - compliance_officer
        - supervisor
      require_mfa: true
      audit_log: true

monitoring:
  logging:
    # Detailed audit logs
    audit_logs:
      enabled: true
      events:
        - recording.accessed
        - recording.downloaded
        - recording.deleted
      storage: s3://audit-logs
      retention: 7y
```

### Retention Policy

```python
from blazing import Flow
from datetime import datetime, timedelta

@Flow.schedule("daily")
async def apply_retention_policy():
    """Apply recording retention policy"""

    # Get recordings older than retention period
    cutoff_date = datetime.now() - timedelta(days=2555)  # 7 years

    recordings = await get_recordings(before=cutoff_date)

    for recording in recordings:
        # Archive to glacier storage
        await archive_recording(
            recording_id=recording.id,
            storage='glacier://long-term-archive'
        )

        # Delete from active storage
        await delete_recording(recording.id)

        # Log retention action
        await log_audit_event(
            event='recording.archived',
            recording_id=recording.id,
            reason='retention_policy',
            retention_period='7years'
        )
```

### Benefits

- **Compliance**: Meet regulatory requirements (MiFID II, GDPR, etc.)
- **Secure**: Encrypted storage with strict access controls
- **Auditable**: Complete audit trail of all access
- **Automated**: Automated retention and archival policies

---

## Next Steps

- [Get started with Blazing Gateway](/docs/quick-start)
- [Review configuration options](/docs/configuration-reference)
- [Join our community](https://discord.gg/blazing)


Real-world examples of Blazing Gateway implementations