From 4G Session-Based OCS to 5G Event-Based OCS: Unlocking OCNCC’s Potential with a RESTful API Layer

The telecom industry’s shift from 4G’s session-based Online Charging System (OCS) to 5G’s event-driven architecture demands a fundamental rethink of how charging systems integrate with core networks. For operators using Oracle Communications Network Charging and Control (OCNCC), this transition presents both a challenge and an opportunity: How can a traditionally session-oriented platform like OCNCC evolve to support the agility and real-time demands of 5G?

Over the recent weeks, I’ve been exploring this question, not just theoretically, but by building a proof-of-concept API layer that abstracts OCNCC’s proprietary Escher protocol into a modern, RESTful interface. The goal? To transform OCNCC from a session-based OCS into an event-based powerhouse, capable of seamless integration with 5G control planes, MVNO setups, and cloud-native architectures.

The Problem: Session-Based OCS in a 4G World

In 4G networks, OCS typically operates in a session-based model:

• Charging decisions are tied to active sessions (e.g., data, voice, or messaging).
• The Escher protocol (Oracle’s proprietary interface for OCNCC) handles real-time interactions between the Billing Engine (VWS) and other network elements.
• Limitations:
  • Tight coupling with session state makes it difficult to scale or integrate with modern, stateless systems.
  • Direct protocol handling (e.g., via SDKs) is complex, error-prone, and lacks flexibility for dynamic use cases like 5G’s event-driven charging.
  • Limited observability into protocol-level interactions, making troubleshooting and optimisation difficult.

For operators looking to modernise their charging infrastructure, these constraints can feel like a roadblock—especially when aiming to adopt 5G’s service-based architecture (SBA), where event-driven interactions (e.g., HTTP/2, JSON) replace traditional session-based protocols.

The Solution: Decoding Escher to Build an Event-Based API Layer

Step 1: Gaining Visibility with a Wireshark Dissector

The first hurdle is understanding Escher’s message flows. Without visibility into the protocol, it’s nearly impossible to design a robust abstraction layer. To solve this, I developed:

• A custom Wireshark dissector for Escher, enabling deep packet inspection of OCNCC interactions.
• A Javascript PCAP-to-JSON decoder to convert captured network traffic into structured, analysable data.

Result: A blueprint of Escher message sequences, including:

• Session establishment/teardown flows.
• Balance deduction and reservation logic.
• Error handling and retry mechanisms.

This step was critical, in order to reverse-engineer the protocol’s behaviour and identify which operations could (and should) be exposed via a RESTful API.

Step 2: Abstracting Escher into a RESTful API

With the decoded flows in hand, we can, and have built a cloud supported JavaScript-based API server that:

• Interfaces directly with OCNCC’s billing engines (VWS) via Escher.
• Exposes every key operation as a RESTful endpoint, effectively decoupling the protocol from the application layer.

Key Features of the API Layer:

Example Endpoints:

POST /api/sessions/{sessionId}/charge      # Deduct balance for a session event
GET  /api/subscribers/{msisdn}/balance     # Retrieve subscriber balance
PUT  /api/subscribers/{msisdn}/profile     # Update subscriber profile
GET  /api/statistics                       # Observability metrics (e.g., QPS, latency)

Step 3: Enabling Event-Based OCS for 5G

By exposing OCNCC’s charging logic via RESTful APIs, the system can now:

1. Integrate with 5G’s Service-Based Architecture (SBA):
   • Replace session-based Escher interactions with event-driven HTTP/2 calls (e.g., from the 5G PCF or CHF).
   • Support stateless charging decisions, aligning with 5G’s microservices approach.
2. Support MVNO and Multi-Tenant Scenarios:
   • Client-level access control allows different MVNOs or partners to interact with only their permitted endpoints.
   • JWT tokens ensure secure, auditable access.
3. Improve Observability and Debugging:
   • Built-in statistics and logging provide visibility into charging operations, a major improvement over opaque protocol interactions.
4. Simplify Monthly Bundle Resets:
   • Previously required custom SDK scripts; now handled via a single API call (e.g., POST /api/bundles/reset).

Why This Matters for OCNCC Operators

1. Future-Proofing for 5G

5G’s event-based charging requires systems that can:

• Handle high-volume, low-latency interactions (e.g., for IoT or URLLC use cases).
• Support dynamic policy control (e.g., real-time QOS adjustments).
• Integrate with cloud-native functions (e.g., Kubernetes-based NFs).

An API layer abstracting OCNCC’s Escher protocol bridges the gap between legacy OCS and modern 5G architectures.

2. Reducing Integration Complexity

Traditional OCNCC integrations often require:

• Custom SDK development for each use case.
• Deep protocol knowledge (Escher is proprietary and poorly documented).
• Tight coupling with session state.

With a RESTful API:

• Developers interact with familiar HTTP endpoints instead of raw Escher messages.
• New services can be onboarded faster (e.g., a new MVNO or 5G network slice).

3. Unlocking New Use Cases

Potential applications include:

• Real-time charging for 5G slicing: Dynamically adjust charging based on slice SLA.
• Convergent charging: Unify prepaid/postpaid logic across 4G/5G.
• AI-driven policy control: Use API hooks to inject ML-based charging decisions.

The Road Ahead: From Proof-of-Concept to Production

While the current implementation is a personal proof-of-concept, the framework is already functional for several key OCS operations. To move this toward a production-ready solution, the next steps include:

1. Extending Endpoint Coverage:
   • Add support for all critical Escher operations (e.g., session termination, refunds, shared balance groups).
   • Implement idempotency keys for retry safety.
2. Enhancing Security:
   • Rate limiting to prevent abuse.
   • Field-level encryption for sensitive subscriber data.
   • Audit logs for compliance (e.g., GDPR).
3. Performance Optimisdation:
   • Connection pooling for Escher protocol sessions.
   • Asynchronous processing for non-blocking operations.
4. QA and Validation:
   • Load testing to ensure scalability (e.g., 10K+ TPS).
   • Failure mode testing (e.g., billing engine timeouts).
5. Documentation and SDKs:
   • OpenAPI/Swagger specs for easy integration.
   • Client libraries (e.g., Python, Java) to simplify adoption.

A Call to Collaborate

This project started as a way to scratch an itch, gaining visibility into OCNCC’s Escher protocol, but it’s evolved into something with far broader potential. By abstracting OCNCC’s charging logic into a modern API, we can:

• Modernise legacy OCS platforms without rip-and-replace.
• Enable 5G-ready charging architectures today.
• Open new integration possibilities for MVNOs, IoT, and cloud-native networks.

If you’re an OCNCC operator or telecom architect exploring ways to transition from session-based to event-based charging, I’d love to discuss how this approach could work for your use case. Whether it’s a pilot project, a specific integration challenge, or just a brainstorming session, let’s connect and explore the possibilities.