An open-source project born from real-world integration challenges with the SMPP protocol.

Working with SMS infrastructure is not always as straightforward as it seems.

Behind a simple SMS notification lies an entire communication chain involving applications, message brokers, SMPP connections, SMS gateways, operators, delivery receipts, and failure-handling mechanisms.

While working on SMS messaging systems, I encountered several challenges when integrating the SMPP protocol into Node.js applications.

Rather than repeatedly implementing workarounds in individual projects, I decided to build something reusable.

That is how smpp-ts was born.

GitHub: https://github.com/AristideDongo/smpp-ts

1. The problem: Working with SMPP in Node.js

SMPP (Short Message Peer-to-Peer) is a protocol widely used by telecommunications providers, SMS aggregators, and messaging platforms to exchange SMS messages.

It provides mechanisms for:

  • Establishing sessions between messaging applications and SMSCs.
  • Submitting SMS messages.
  • Receiving delivery receipts (DLRs).
  • Managing connection states.
  • Handling asynchronous communication.
  • Controlling message throughput.

Although SMPP is a well-established protocol, implementing it reliably in an application requires careful attention to several details.

Some of the challenges I encountered included:

Connection management

SMPP sessions need to remain healthy. Network interruptions, timeouts, and unexpected disconnections can affect message processing.

Delivery receipt tracking

Submitting a message does not necessarily mean that it has been delivered. Applications need to correlate asynchronous delivery receipts with the original message submissions.

Scalability

As message volumes increase, managing multiple SMPP connections, submission windows, and throughput limits becomes increasingly important.

Reusability

I wanted a reusable TypeScript implementation that could be integrated into different Node.js applications without duplicating protocol-level logic.

These challenges motivated me to create a dedicated library.

2. Introducing smpp-ts

smpp-ts is an open-source SMPP library written in TypeScript for Node.js.

Its purpose is to provide a modern, reusable foundation for applications communicating with SMSC infrastructure through SMPP.

GitHub repository:

https://github.com/AristideDongo/smpp-ts

The project focuses on:

  • TypeScript-first development.
  • SMPP client communication.
  • Connection and session management.
  • SMS submission.
  • Delivery Receipt tracking.
  • Connection pooling.
  • Extensible delivery tracking persistence.
  • ESM and CommonJS compatibility.
  • Zero runtime dependencies.

The goal is to keep the library focused on SMPP communication while allowing applications to implement their own business logic and infrastructure.

3. What does smpp-ts provide?

Connection management

An SMPP application must establish and maintain a session with an SMSC.

smpp-ts provides connection and session management capabilities to help applications communicate with SMS infrastructure.

SMS submission

The library provides mechanisms for submitting SMS messages through SMPP.

This includes the protocol-level operations needed to send messages to an SMSC.

Delivery Receipt tracking

One important aspect of SMS messaging is knowing what happens after submission.

A successful submit_sm response does not necessarily indicate successful delivery to the recipient.

Delivery Receipts provide additional information about the message lifecycle.

smpp-ts includes a DeliveryTracker designed to associate message submissions with their delivery receipts.

The tracker also supports customizable persistence through a storage interface, allowing applications to integrate their own storage mechanisms.

Connection pooling

When working with higher message volumes, a single connection may not be sufficient.

The library includes pooling capabilities to manage multiple SMPP connections.

This provides a foundation for distributing message submissions across available connections.

Actual throughput must still be controlled according to SMSC and provider limits.

4. Designed to integrate with existing infrastructure

I do not see an SMPP library as a replacement for an SMS gateway.

For example, an architecture using NestJS, RabbitMQ, Jasmin SMS Gateway, and a telecommunications provider can use smpp-ts as its SMPP communication layer.

A simplified architecture looks like this:

Application | v NestJS API | v RabbitMQ | v SMS Worker | v smpp-ts | v Jasmin SMS Gateway | v SMS Provider | v Mobile Network

Delivery receipts follow the return path and can be processed by the application to update message statuses.

This separation allows each component to have a clear responsibility:

  • NestJS handles application logic.
  • RabbitMQ distributes asynchronous work.
  • The worker processes SMS jobs.
  • smpp-ts handles SMPP communication.
  • Jasmin handles gateway responsibilities and routing.
  • The application persists business and delivery states.

The library is intended to complement this architecture, not replace its other components.

5. Why open source?

I decided to make smpp-ts open source because I believe protocol implementations benefit from independent testing and contributions.

SMPP has been around for many years, and there is valuable experience within the telecommunications and messaging communities.

I am particularly interested in feedback from developers who operate:

  • Jasmin SMS Gateway.
  • Kannel.
  • SMPP aggregators.
  • SMS notification platforms.
  • Banking and fintech messaging systems.
  • High-volume messaging infrastructure.

There are many implementation details that deserve testing across different SMSCs and network conditions.

I would rather have experienced developers challenge the implementation and identify weaknesses than assume that everything is correct simply because the code works in my own environment.

6. What I want to improve

The project is evolving, and I am working toward making it more reliable and production-ready.

Some of the areas I want to focus on include:

Reliability

  • Better recovery after process restarts.
  • More robust delivery tracking.
  • Better handling of uncertain submission outcomes.

Interoperability

  • More integration tests with Jasmin.
  • Testing against additional SMPP implementations.
  • Better coverage of real-world SMSC behavior.

Performance

  • Improved throughput management.
  • Better backpressure handling.
  • Load and stress testing.

Security

  • Stronger production configuration guidance.
  • TLS verification.
  • Resource limits and protocol input validation.

Observability

  • Better diagnostics.
  • Structured events.
  • Metrics for connections, submissions, and delivery receipts.

These are important areas of development, and community feedback will help determine the most valuable improvements.

7. Looking for contributors and testers

This is an open invitation to anyone with SMPP experience.

I would particularly appreciate help from developers who have experience with:

  • SMPP protocol implementations.
  • Node.js and TypeScript.
  • Jasmin SMS Gateway.
  • SMSC interoperability.
  • Delivery Receipt processing.
  • High-throughput messaging systems.

If you are interested, you can:

  1. Explore the repository.
  2. Try the library in a test environment.
  3. Report bugs and compatibility issues.
  4. Suggest missing features.
  5. Contribute improvements through pull requests.

Repository:

https://github.com/AristideDongo/smpp-ts

Issues and feedback are welcome.

Conclusion

smpp-ts started as an attempt to solve practical problems I encountered while working with SMPP integrations.

It has since become an open-source project that I want to improve beyond my own use cases.

My ambition is to build a useful, well-tested, and maintainable TypeScript library for developers working with SMS infrastructure.

I am not claiming that it is perfect or production-certified. That is precisely why I am inviting the community to test it, review the implementation, and help identify what needs to improve.

If you work with SMPP, I would genuinely appreciate your feedback.

Let's make SMPP development in the Node.js ecosystem better.

Project: smpp-ts

Author: Aristide Dongo

GitHub: https://github.com/AristideDongo/smpp-ts

TypeScript #NodeJS #SMPP #OpenSource #Telecommunications #SMS #JasminSMS #BackendDevelopment