Skip to content

INAP (Intelligent Network Application Part)

Overview

INAP is a signaling protocol used in Intelligent Networks (IN) to enable advanced service logic and control. It provides a framework for implementing complex telecommunications services.

Key Features

  • Service switching and control
  • Number translation services
  • Advanced call routing
  • Toll-free services
  • Premium rate services
  • Virtual private networks

Protocol Capabilities

Capability Set Features Applications
CS-1 Basic call control Number translation
CS-2 Enhanced services Call screening
CS-3 Advanced routing VPN services
CS-4 Multimedia support Unified messaging

Common Operations

Initial DP Operation

# Send Initial Detection Point
response = client.inap.send_initial_dp(
    service_key=100,
    called_party_number="18001234567",
    calling_party_number="441234567890",
    call_reference="CR123456"
)

Number Translation

# Perform number translation
response = client.inap.translate_number(
    original_number="18001234567",
    service_type="TOLLFREE",
    location_info={
        "country": "US",
        "state": "CA"
    }
)

Vendor Integration

Nokia Siemens SSP

  • Product Line: Nokia NetAct IN Platform
  • Core Components:
  • Service Switching Function (SSF)
  • Call Control Function (CCF)
  • Specialized Resource Function (SRF)
  • Key Features:
  • Complete IN CS-1/2/3/4 support
  • High-performance call processing
  • Advanced service triggering
  • Real-time monitoring
  • Configuration Example: 
    nokia_ssp_config:
  ssf:
    trigger_detection_points: ["collected_info", "analyzed_info"]
    max_triggers_per_call: 5
  ccf:
    max_concurrent_calls: 10000
    call_context_timeout: 300
  srf:
    announcement_path: "/var/nokia/announcements"
    recording_enabled: true

Ericsson Service Control Point

  • Product Line: Ericsson IN Solutions
  • Platform Capabilities:
  • Service Data Point integration
  • Number portability support
  • Toll-free services
  • Premium rate services
  • Advanced Features:
  • Load balancing with active-active setup
  • Geographic redundancy
  • Real-time statistics
  • Service creation toolkit
  • Configuration Example: 
    ericsson_scp_config:
  platform:
    redundancy_mode: active_active
    geo_redundancy: true
  services:
    number_portability:
      cache_size: 1000000
      refresh_interval: 3600
    toll_free:
      lookup_timeout: 500
      fallback_enabled: true

Huawei IN Services

  • Product Line: Huawei IN Solution
  • Architecture:
  • Distributed microservices
  • Container-based deployment
  • Cloud-native design
  • API-first approach
  • Service Features:
  • Flexible service composition
  • Real-time charging
  • Advanced routing
  • Analytics dashboard
  • Configuration Example: 
    huawei_in_config:
  deployment:
    mode: kubernetes
    replicas: 3
    auto_scaling:
      min_pods: 2
      max_pods: 10
  services:
    charging:
      mode: real_time
      timeout: 500
    routing:
      strategy: least_cost
      fallback_routes: 2

ZTE IN Platform

  • Product Line: ZTE IMS/IN Solution
  • Platform Features:
  • Service Logic Program Environment
  • Integrated Service Creation
  • Performance Analytics
  • Multi-protocol Support
  • Integration Options:
  • SIGTRAN/SS7
  • Diameter
  • REST APIs
  • SOAP Web Services
  • Configuration Example: 
    zte_in_config:
  service_logic:
    max_instances: 5000
    script_path: "/opt/zte/scripts"
  protocols:
    sigtran_enabled: true
    diameter_enabled: true
  monitoring:
    metrics_interval: 60
    alert_threshold: 90

Integration Best Practices

Nokia Integration

  1. SSF Configuration 

    # Configure Service Switching Function
ssf_config = nokia_client.configure_ssf(
    trigger_criteria=[
        {
            "type": "collected_info",
            "service_key": 100,
            "criteria": {
                "prefix": "800",
                "min_digits": 10
            }
        }
    ],
    monitoring={
        "enable_stats": True,
        "log_level": "INFO"
    }
)

  2. Service Resource Setup 

    # Configure Specialized Resource Function
srf_config = nokia_client.configure_srf(
    announcements={
        "welcome": "/var/nokia/ann/welcome.wav",
        "goodbye": "/var/nokia/ann/goodbye.wav"
    },
    recording={
        "enabled": True,
        "format": "wav",
        "path": "/var/recordings"
    }
)

Ericsson Integration

  1. Number Portability 

    # Configure number portability service
np_service = ericsson_client.setup_number_portability(
    database_config={
        "type": "redis",
        "host": "localhost",
        "port": 6379
    },
    cache_config={
        "size": 1000000,
        "ttl": 3600
    }
)

  2. Load Balancing 

    # Configure load balancing
lb_config = ericsson_client.configure_load_balancing(
    nodes=[
        {"host": "scp1.example.com", "weight": 100},
        {"host": "scp2.example.com", "weight": 100}
    ],
    health_check={
        "interval": 30,
        "timeout": 5,
        "retries": 3
    }
)

Huawei Integration

  1. Service Deployment 

    # Deploy IN service to Kubernetes
deployment = huawei_client.deploy_service(
    service_name="toll_free_service",
    kubernetes_config={
        "namespace": "in-services",
        "replicas": 3,
        "resources": {
            "cpu": "2",
            "memory": "4Gi"
        }
    }
)

  2. Charging Integration 

    # Configure real-time charging
charging_config = huawei_client.setup_charging(
    mode="real_time",
    rating_rules=[
        {
            "service_key": 100,
            "rate": 0.5,
            "interval": 60
        }
    ],
    fallback={
        "enabled": True,
        "grace_period": 30
    }
)

ZTE Integration

  1. Service Logic 

    # Deploy service logic
service = zte_client.deploy_service_logic(
    script_file="premium_service.sl",
    config={
        "max_instances": 1000,
        "timeout": 30,
        "debug_mode": False
    }
)

  2. Protocol Configuration 

    # Configure protocol stack
protocol_config = zte_client.configure_protocols(
    sigtran={
        "local_point_code": "1-1-1",
        "remote_point_code": "2-1-1",
        "network_indicator": "international"
    },
    diameter={
        "host": "zte.example.com",
        "realm": "example.com",
        "applications": ["Ro", "Rf"]
    }
)

Service Examples

Toll-Free Service

# Toll-free call handling
def handle_tollfree_call(session):
    # Initial processing
    idp_response = session.send_initial_dp(
        service_key=TOLLFREE_SERVICE_KEY,
        called_party_number=session.called_number,
        calling_party_number=session.calling_number
    )

    # Translate number
    if idp_response.success:
        routing = session.connect_to_resource(
            translated_number=session.translate_number(
                session.called_number,
                service_type="TOLLFREE"
            )
        )

Premium Rate Service

# Premium rate service implementation
def handle_premium_call(session):
    # Check service availability
    if session.check_service_availability():
        # Apply charging
        charging = session.apply_charging(
            rate_type="PREMIUM",
            initial_charge=100,
            per_minute_rate=50
        )

        # Connect call if charging successful
        if charging.success:
            session.connect_to_destination(
                destination_number=session.get_service_endpoint()
            )

Best Practices

  1. Service Implementation
  2. Define clear trigger criteria
  3. Implement proper error handling
  4. Monitor service performance

  5. Plan for scalability

  6. Number Translation

  7. Cache frequently used translations
  8. Implement fallback routing
  9. Monitor translation accuracy

  10. Regular database updates

  11. Call Control

  12. Handle timeouts properly
  13. Implement call supervision
  14. Monitor call quality
  15. Record detailed CDRs

Error Handling

Error Code Description Resolution
1 Missing Parameter Check mandatory fields
2 Invalid Number Format Validate number format
3 Service Unavailable Try alternate service
4 Resource Limitation Implement throttling

Monitoring

Key metrics to track:

  • Service invocation rate
  • Translation success rate
  • Call completion ratio
  • Average handling time
  • Resource utilization

Configuration Examples

Basic Setup

inap_config:
  capability_set: 2
  service_key: 100
  default_timeout: 30
  translation:
    cache_enabled: true
    cache_timeout: 3600

Advanced Configuration

inap_config:
  capability_set: 3
  service_key: 100
  default_timeout: 30
  translation:
    cache_enabled: true
    cache_timeout: 3600
  performance:
    max_sessions: 5000
    session_timeout: 1800
  monitoring:
    enable_alerts: true
    metrics_interval: 60
  fallback:
    enable: true
    alternate_routing: true
    retry_attempts: 3

Service Creation

  1. Define service logic
  2. Configure trigger detection points
  3. Set up number translations
  4. Implement charging rules
  5. Deploy and test
  6. Monitor and optimize