What is Zirzir?

Zirzir is an open-source payment stack for Africa.

Not just an SDK. Not just a wrapper around gateway APIs. A full payment infrastructure — the kind that used to take a funded fintech company 18 months and a team of engineers to build. Open-sourced, self-hostable, and designed from the ground up for the African payment landscape.

The Problem

Africa has a payment fragmentation problem unlike anywhere else in the world.

Each country has its own gateways. Each gateway has its own API, its own auth flow, its own webhook format, its own error codes, its own quirks. Integrating Telebirr in Ethiopia is a completely different experience from integrating M-Pesa in Kenya, which is completely different from integrating Paystack in Nigeria.

But the fragmentation goes deeper than just API differences.

When you’re building a payment-enabled product in Ethiopia right now, you don’t just need to write integration code. You need to:

Manage API credentials for each provider separately
Build your own webhook infrastructure (with retries, deduplication, signature verification)
Build your own transaction database and reconciliation logic
Build dashboards for your finance team to see what’s happening
Handle multiple environments (test vs. live) per provider
Support multiple projects or clients if you’re an agency or platform
Implement RBAC so your developers don’t have access to production keys
Figure out why a transaction is stuck in pending at 11 PM

Every company building in African fintech solves these problems independently. Expensively. Repeatedly. That’s what Zirzir replaces.

What Zirzir Actually Is

Zirzir is three things that work together:

1. The SDK (Open Source)

A unified, provider-agnostic SDK available in TypeScript, Python, and Go. One interface for every supported gateway.

// Works the same regardless of which gateway is underneath
const tx = await zirzir.charge({
  amount: 500,
  currency: 'ETB',
  email: 'customer@example.com',
  txRef: 'order_001',
})

Adding a new payment provider to your product goes from weeks of integration work to changing one line of configuration.

The SDK is genuinely open source — MIT licensed, no strings attached. You can use it standalone, directly against gateway APIs, with no other part of Zirzir involved.

2. The Server (Self-Hostable)

A Go-based server that is the operational backbone of the stack. This is what turns Zirzir from “a useful library” into “a complete payment infrastructure.”

The server handles everything your product needs around payments but doesn’t want to build:

Project & credential management

Multiple projects, each with isolated credentials
Separate test and live environments per project
API key issuance and rotation
RBAC — control who on your team can see what

Webhook infrastructure

Receives raw webhooks from every provider
Normalizes them into a single consistent format
Stores and retries on failure (5-attempt exponential backoff)
Delivers to your application with a unified signature scheme
Logs every delivery attempt

Transaction management

Unified transaction ledger across all providers
Reconciliation tools
Transaction search and filtering
Export to CSV/Excel for your finance team

Dashboard

Real-time transaction monitoring
Webhook delivery logs and replay
Pending and failing transaction alerts
Profit reporting (transaction amount minus provider fees)

The server is what makes Zirzir suitable for production — for real businesses handling real money.

3. The Cloud (Managed Hosting)

Don’t want to run your own server? We run it for you at zirzir.dev.

Same server, same features, zero ops. Point your SDK at our cloud endpoint, get API keys from the dashboard, and you’re live.

This is the sustainable business that funds Zirzir’s continued open-source development.

The Design Philosophy

Open Core, Not Open Bait

The SDK is open source because it should be. It’s the layer that developers interact with, that the community contributes to, that makes African payment integration accessible to anyone.

The server is self-hostable. You can run it yourself — you don’t need us. We offer the cloud version because running infrastructure is a pain and most people would rather not.

This isn’t a trick. It’s the same model as Supabase, Plausible, Gitea, and dozens of other tools that have proven you can build a real business without holding your open-source users hostage.

One Normalized Interface

Every provider returns different data. Different field names, different status codes, different date formats, different error structures. Zirzir eats that complexity and outputs a single normalized Transaction object — every time, for every provider.

Your application code doesn’t change when you add a new provider. It doesn’t even know.

Africa First

Zirzir is not a global payments library that added some African providers. It’s built for African payment infrastructure first.

That means:

USSD-based payment flows are first-class citizens, not afterthoughts
Settlement timelines and fee structures reflect African realities
The documentation covers the things nobody else documents — the sandbox quirks, the bureaucratic onboarding processes, the real-world settlement delays
Provider support starts with Ethiopia and expands across the continent

Who Zirzir Is For

Startups building payment-enabled products in Africa — you shouldn’t spend 3 months building payment infrastructure before you can ship your actual product. Zirzir is that infrastructure, already built.

Agencies building for African clients — one Zirzir server, multiple projects. Each client gets isolated credentials, their own dashboard view, their own webhook endpoints. You manage it all from one place.

Platforms and marketplaces — split payments, multi-party payouts, reconciliation across providers — the server layer handles the complexity your platform would otherwise have to build.

Developers exploring African fintech — the SDK is open source and the sandbox works on day one. No approvals, no waiting. Clone it, run it, understand how African payment APIs actually work.

How It Compares

	Zirzir	Direct Integration	Global SDK (Stripe etc.)
African gateway support	Native	Painful	Limited
Webhook infrastructure	Built in	Build it yourself	Built in
Self-hostable	Yes	N/A	No
Open source SDK	Yes	N/A	No
Multi-project support	Yes	No	Yes
USSD flow support	First-class	Painful	No
Cost	Free / Cloud tier	Provider fees only	% per transaction

The Bigger Picture

The fragmentation problem Zirzir solves in Ethiopia exists in Kenya, Nigeria, Ghana, Tanzania, and across the continent. The providers are different. The APIs are different. The regulatory environments are different.

But the underlying problem — that every developer building in African fintech has to solve the same infrastructure problems from scratch — is the same everywhere.

Zirzir starts in Ethiopia because that’s where the team is from and where the problem is most personal. But the architecture is built to expand. Adding Kenya means adding M-Pesa and Airtel Money adapters. Adding Nigeria means adding Paystack and Flutterwave. The abstraction layer doesn’t change. The application code doesn’t change.

That’s the goal: one payment stack for the continent.

Get Started

Installation — install the SDK in under 2 minutes
Your First Payment — charge a customer in 10 lines of code
Cloud Hosting — skip the ops, go straight to building
GitHub — contribute, fork, or just read the code