MTN Rwanda MoMo API 2026: How to Get API Access & Integrate Payments

Last updated: September 2026

Looking for the MTN Rwanda MoMo API to connect Mobile Money payments to your website, mobile application, e-commerce platform or business system?

MTN provides a developer platform that allows businesses and developers to build applications that communicate with supported MTN Mobile Money services. The platform provides a sandbox environment for testing and APIs for use cases including collections, disbursements and remittances.

This guide explains what the MTN Rwanda MoMo API is, what you can build with it, how the sandbox works, how authentication works, how payment callbacks work, what you need for production access and how to approach a professional integration.

Table of Contents

1. What Is the MTN Rwanda MoMo API?
2. What Can You Build With the MoMo API?
3. MTN MoMo API Products
4. How the MTN MoMo API Works
5. What You Need Before Starting
6. How to Create an MTN MoMo Developer Account
7. What Is the MTN MoMo Sandbox?
8. MTN MoMo API Authentication
9. What Is a Subscription Key?
10. Request to Pay and Collections
11. MTN MoMo Disbursements
12. MTN MoMo Remittance API
13. Payment and Transaction Status
14. Callbacks and Webhooks
15. How to Move From Sandbox to Production
16. How to Integrate MTN MoMo API Into a Website
17. Can You Use PHP?
18. Can You Use Node.js?
19. MTN MoMo API Security
20. Common API Problems
21. How Much Does the MTN MoMo API Cost?
22. Who Should Use the API?
23. Frequently Asked Questions

What Is the MTN Rwanda MoMo API?

The MTN Rwanda MoMo API is a set of web APIs that enables an application to communicate with supported MTN Mobile Money services.

In simple terms, an API allows your software to send requests to MTN's payment platform and receive responses that your application can process.

This means a developer can build a website or application where payment-related activities are connected directly to the business system instead of relying entirely on manual payment verification.

For example, an online shop could create an order, initiate a supported MoMo payment, monitor the transaction and update the order after receiving the appropriate confirmation.

MTN describes its MoMo API as a REST-based, JSON API designed to provide standardized interfaces for partner systems accessing services in its wallet platform.

What Can You Build With the MTN MoMo API?

The API can be useful whenever a business needs to connect software with supported Mobile Money payment workflows.

Potential applications include:

• E-commerce checkout systems
• Online marketplaces
• Mobile applications
• School payment platforms
• Subscription platforms
• Booking and ticketing systems
• Digital service platforms
• Fintech applications
• Business management systems
• Supplier payment systems
• Customer payout systems
• Supported remittance services

The actual services available to your application depend on the API products you subscribe to and the applicable MTN onboarding and business requirements.

MTN MoMo API Products

MTN's current developer platform lists several major API groups. The most relevant ones for developers and businesses are Collections, Disbursements, Remittance and Sandbox User Provisioning.

1. Collections

Collections allows supported partners to receive Mobile Money payments for goods and services.

MTN describes collections as supporting payment use cases that can take place through digital channels and other supported environments.

Examples include:

• Online shopping
• Service payments
• Bill collection
• Fees and institutional payments
• Digital subscriptions
• Online orders

2. Disbursements

Disbursements allow supported businesses to send funds to multiple recipients through an automated payment workflow.

Possible use cases include:

• Salary-related payments
• Benefits
• Supplier payments
• Customer payouts
• Rewards
• Other approved business payments

3. Remittance

The Remittance API supports eligible money-transfer use cases involving recipients and funds sent from the diaspora.

For businesses building remittance products, the applicable regulatory, contractual and onboarding requirements must be followed.

4. Sandbox User Provisioning

MTN also provides APIs and processes for provisioning users and resources in the sandbox environment so developers can test their integrations.

How the MTN MoMo API Works

A professional integration normally places your backend between the customer-facing application and MTN's API.

Customer
    ↓
Website / Mobile App
    ↓
Your Backend Server
    ↓
MTN MoMo API
    ↓
MTN Mobile Money
    ↓
Payment Result
    ↓
Your Backend
    ↓
Database / Order System

The customer should interact with your application, while sensitive API communication and credentials are handled by the appropriate backend services.

Example payment workflow

1. The customer selects a product or service.
2. Your system creates an order or invoice.
3. Your backend generates a unique transaction reference.
4. Your backend sends the appropriate payment request to MTN.
5. The customer authorizes the payment through the supported MoMo process.
6. The transaction is processed.
7. Your application receives or retrieves the transaction result.
8. Your database is updated.
9. The order or service is completed after successful confirmation.

The important point is that request accepted does not necessarily mean payment completed. Your system must correctly handle the transaction lifecycle.

What You Need Before Starting

You do not need to be a large company simply to begin learning and testing the API. Developers can start with the available sandbox environment.

For a serious integration, however, you should prepare:

• A clear payment use case
• An MTN MoMo developer account
• Basic REST API knowledge
• A backend programming environment
• A secure server
• A database
• A domain or accessible callback environment where required
• Secure credential storage
• Error-handling logic
• Transaction reconciliation logic

For production access, MTN's current go-live process also requires business and contractual information, followed by the applicable onboarding and approval process.

How to Create an MTN MoMo Developer Account

To start developing, use the official MTN MoMo developer platform.

1. Open the MTN MoMo developer platform.
2. Select the sign-up option.
3. Create your API Management account.
4. Sign in to the developer portal.
5. Review the available products and API documentation.
6. Select the API product relevant to your project.
7. Set up the required sandbox resources.
8. Generate the credentials required for testing.

MTN currently provides a dedicated sign-up page for creating a MoMo API Management account.

What Is the MTN MoMo Sandbox?

The MTN MoMo sandbox is a testing environment designed to simulate the live API environment.

It allows developers to build and test their applications before processing real transactions.

Why use the sandbox?

• Test API authentication
• Test payment requests
• Test transaction status
• Test callbacks
• Test transfers
• Test error handling
• Test your database logic
• Test your application's payment flow

MTN's current go-live documentation states that partners are required to begin integration with thorough sandbox testing before proceeding to production.

Sandbox vs production

MTN MoMo API Authentication

Authentication is required before your application can access protected API functionality.

MTN's current documentation identifies three important pieces in the authentication process:

• Subscription Key
• API User
• API Key

The API User and API Key are used for OAuth 2.0 bearer-token authentication, while the Subscription Key is used to authenticate and control API access.

Sandbox authentication

In the sandbox, API users and keys can be generated through the relevant provisioning APIs.

Production authentication

For production, MTN's documentation states that API users and API keys are managed through the partner/account portal as part of the onboarding process.

Never publish these credentials in your frontend application or public source repository.

What Is an MTN MoMo Subscription Key?

A Subscription Key is a credential associated with an API product subscription.

MTN's documentation states that the subscription key is supplied through the Ocp-Apim-Subscription-Key request header.

The developer portal can provide primary and secondary keys for subscribed products, and different keys may be used for different API products.

This means that having a developer account alone is not necessarily enough to call every API. Your application must have access to the relevant API product and use the required credentials.

MTN MoMo Request to Pay and Collections

Request to Pay is particularly important for developers building online payment systems.

It allows a partner application to initiate a supported payment request for a customer.

A simplified workflow looks like this:

1. Customer creates an order.
2. Your system generates a transaction reference.
3. Your backend sends a Request to Pay request.
4. MTN validates the request.
5. The request is processed asynchronously.
6. The customer authorizes the payment.
7. Your system receives the final transaction result through the supported callback mechanism or retrieves the status.
8. Your application completes the order if the payment is successful.

MTN's documentation specifically explains that Request to Pay is asynchronous. The initial API request can return 202 Accepted while the transaction is still being processed.

This is one of the most important concepts for developers integrating MTN MoMo.

MTN MoMo Disbursements

Disbursements work in the opposite direction from collections: instead of receiving money from customers, an approved business can use the service to send money to recipients.

MTN describes disbursements as supporting automated payments to multiple users.

For example, a business could have a system like:

Payroll System
     ↓
Payment Approval
     ↓
Backend
     ↓
MTN Disbursement API
     ↓
Recipient Mobile Money Account

Before using live disbursement functionality, businesses should confirm the applicable eligibility, onboarding, contractual and regulatory requirements.

MTN MoMo Remittance API

MTN's developer platform also includes a Remittance API.

This can support eligible applications involving money transfers from the diaspora to local Mobile Money recipients.

Remittance applications can involve additional regulatory and compliance requirements, so developers should not assume that a sandbox integration automatically gives permission to operate a live remittance business.

How MTN MoMo Transaction Status Works

A good payment system must understand the difference between:

• A request being received
• A request being accepted
• A transaction being processed
• A transaction succeeding
• A transaction failing

For example, your application may send a Request to Pay request and receive a 202 Accepted response.

That response means the request has been accepted for processing. It should not automatically cause your website to mark the customer's order as paid.

Your application should wait for the appropriate final transaction result.

Recommended database statuses

A simple application could use internal states such as:

pending
successful
failed
cancelled
expired

The exact mapping should follow the statuses and response codes documented for the specific MTN API product you are using.

MTN MoMo API Callbacks and Webhooks

Callbacks are essential for asynchronous payment processing.

MTN's current documentation explains that Request to Pay and Transfer APIs are asynchronous. After the initial request is accepted, the transaction is processed and a callback can be sent to the merchant system with the final result.

How callbacks work

Your Server
     │
     │ Request to Pay
     ↓
MTN MoMo API
     │
     │ 202 Accepted
     ↓
Transaction Processing
     │
     │ Final Result
     ↓
Your Callback Endpoint
     │
     ↓
Update Database
     │
     ↓
Complete Order

Important callback requirements

MTN's current documentation provides specific callback requirements. For example, the callback URL must correspond to the registered callback host, and production callbacks use HTTPS.

MTN also states that its platform sends the callback once and does not retry it if the partner system fails to respond. Developers should therefore implement reliable callback handling and use transaction-status polling when appropriate if a callback is not received.

This is an important reason to build your payment system with both callback handling and transaction-status verification.

How to Move From Sandbox to Production

Getting a sandbox integration working is not the same as going live.

MTN's current go-live process consists of several stages.

Step 1: Complete sandbox testing

Thoroughly test your application using the sandbox environment.

Step 2: Prepare business information

MTN's current onboarding process requests information such as:

• Entity type
• Business description
• Description of the product or service
• Whether the solution is your own or a third-party integration
• Customer channel such as web, app or USSD
• Business and hosting location
• Customer journey
• Customer support contacts

Step 3: Complete contractual onboarding

The applicable business, legal and contractual information must be submitted for review.

Step 4: Complete KYC requirements

MTN's documentation describes KYC and business documentation as part of the go-live process.

Step 5: Production setup

After the applicable testing, contracting and approval process is completed, MTN facilitates production wallet setup and provides production credentials.

Step 6: Deploy your production integration

Only after the production environment has been configured should your application be switched from sandbox credentials and endpoints to the appropriate live configuration.

How to Integrate MTN MoMo API Into a Website

A professional website integration should separate the customer interface from the payment backend.

Recommended architecture

Browser / Mobile App
        ↓
Your Frontend
        ↓
Your Backend API
        ↓
Payment Service
        ↓
MTN MoMo API
        ↓
Transaction Processing
        ↓
Callback / Status
        ↓
Your Backend
        ↓
Database
        ↓
Order / Invoice

Step 1: Create the order

Create an internal order before starting the payment.

Step 2: Generate a unique reference

Generate a unique identifier for the transaction. MTN's documentation uses UUID version 4 for transaction identifiers in relevant API workflows.

Step 3: Initiate payment

Your backend sends the appropriate API request using the required credentials and parameters.

Step 4: Record the initial response

Store the transaction reference and initial state in your database.

Step 5: Wait for final confirmation

Use the callback and/or transaction-status mechanism.

Step 6: Update the order

Only mark the order as paid after the transaction has been properly confirmed.

Step 7: Reconcile

Keep payment and order records synchronized so that your accounting system can identify successful, failed and unresolved transactions.

Can You Use MTN MoMo API With PHP?

Yes. PHP is suitable for building the backend of an MTN MoMo integration because it can make HTTPS requests to REST APIs.

A PHP integration can use:

• cURL or another HTTP client
• Environment variables
• A database such as MySQL or PostgreSQL
• Secure backend routes
• Callback endpoints
• Logging and error handling

The API credentials should remain on the server rather than being embedded in HTML or browser-side JavaScript.

Can You Use MTN MoMo API With Node.js?

Yes. Node.js can also be used as the backend for an MTN MoMo integration.

A Node.js application can handle:

• Authentication
• API requests
• Payment initiation
• Callbacks
• Transaction-status checks
• Database updates
• Error handling

The same architecture applies regardless of whether your backend is built with PHP, Node.js, Python, Java or another suitable server-side technology.

Practical MTN Rwanda MoMo API Integration Example

One of the most useful ways to integrate the MTN Rwanda MoMo API is to allow customers to pay for a product or service directly from your website. For example, an online shop could allow a customer to enter their MTN phone number, click Pay with MTN MoMo, and receive a payment request on their phone.

Example: Online Shop Payment Flow

A typical payment flow can look like this:

1. The customer selects a product on your website.
2. The customer enters their MTN Rwanda phone number.
3. Your website creates a unique transaction/reference ID.
4. Your backend authenticates with the MTN MoMo API.
5. Your backend sends a payment request to MTN.
6. The customer approves the payment on their phone.
7. MTN processes the transaction asynchronously.
8. Your callback/webhook receives the final transaction result, or your server checks the transaction status.
9. Your website marks the order as paid only after receiving a successful payment result.

Recommended Architecture

Customer
   |
   v
Your Website
   |
   v
Your Backend / API
   |
   +---- Authentication ----> MTN MoMo API
   |
   +---- Payment Request ---> MTN MoMo
   |
   <---- Callback / Status --- MTN
   |
   v
Update Order as PAID

Important: API credentials should remain on your server. Do not place your API key, subscription key, or other private credentials inside browser-side JavaScript.

Illustrative PHP Backend Example

The following example demonstrates the general structure of a server-side integration. It is intentionally simplified and uses placeholders rather than real credentials.

 $amount,
    'currency' => $currency,
    'externalId' => $referenceId,
    'payer' => [
        'partyIdType' => 'MSISDN',
        'partyId' => $customerPhone
    ],
    'payerMessage' => 'Payment for Fyndin order',
    'payeeNote' => 'Online order payment'
];

/*
 * In a real implementation:
 * 1. Authenticate and obtain the required access token.
 * 2. Send the payment request using the current MTN endpoint
 *    and headers specified in the official documentation.
 * 3. Store the reference ID in your database.
 * 4. Wait for the callback or query transaction status.
 * 5. Mark the order as paid only after confirmation.
 */

echo "Payment request prepared for reference: " . $referenceId;
?>

Note: This is an educational integration pattern, not a copy-and-paste production implementation. MTN's current API documentation should be followed for the exact endpoint, authentication flow, headers, request format, callback configuration, and environment settings.

Why You Need a Backend

A secure implementation should normally follow this structure:

• Frontend: displays the product, payment form and transaction status.
• Backend: communicates with MTN and protects credentials.
• Database: stores orders, reference IDs and payment status.
• Callback endpoint: receives the final payment result from MTN.

This prevents sensitive credentials from being exposed to website visitors and gives your application a reliable way to reconcile payments.

Example Database Record

After MTN confirms the payment, your application can change the status from Pending to Successful. If the payment fails, the order should remain unpaid and the customer should be given an appropriate retry option.

Callback vs Transaction Status

MTN MoMo transactions can be processed asynchronously. Therefore, your application should not assume that an accepted payment request immediately means the customer has successfully paid.

A robust implementation should use the callback mechanism where appropriate and maintain transaction-status checking as a fallback. This is particularly important for e-commerce, school payments, subscriptions and other systems where incorrectly marking an order as paid could cause financial problems.

Production Integration Checklist

• Developer account created
• Sandbox integration completed
• Authentication implemented securely
• Unique transaction/reference IDs generated
• Payment requests stored in your database
• Callback endpoint configured correctly
• Transaction-status handling implemented
• Failed and pending payments handled
• HTTPS enabled on the production website
• API credentials stored securely on the server
• Business/KYC requirements completed
• Production access approved by MTN

Official MTN Rwanda MoMo API Developer Resources

Before implementing the API, developers should use MTN's official documentation rather than relying on third-party tutorials for current endpoints and authentication requirements.

• MTN MoMo API Developer Portal: Start here to access the developer resources and API environment.
• Getting Started: Follow MTN's official guide for creating your first API request.
• API Documentation: Review the official production API documentation, including use cases and API behaviour.
• API User & API Key Management: Follow the official authentication instructions before connecting your application.
• Sandbox: Test your integration before requesting production access.
• Common Error Codes: Use the official error reference when troubleshooting failed API requests.

Always verify the current documentation before deploying because API endpoints, authentication requirements, supported products and production procedures can change.

MTN MoMo API vs MoMo Pay vs MoMo App

If you are building an e-commerce website, school-management system, SaaS platform, marketplace or another application that needs automated payment processing, the API is the option designed for deeper software integration.

MTN MoMo API Security Best Practices

Because the API deals with financial transactions, security should be considered from the beginning of the project.

Never expose credentials

Do not put API keys or other private credentials in frontend JavaScript, HTML, public GitHub repositories or publicly accessible configuration files.

Use environment variables

Store sensitive configuration outside your source code where possible.

Use HTTPS in production

Production callback endpoints and payment communication should follow MTN's documented security requirements.

Validate callbacks

Do not blindly trust incoming requests. Validate the information and process the transaction according to your application's security rules.

Prevent duplicate processing

Your callback handler should be idempotent so that processing the same transaction event more than once does not create duplicate orders or payouts.

Use unique transaction IDs

Every payment should be traceable to an internal order and an external transaction identifier.

Limit access to production credentials

Only authorized members of your development and operations team should have access to live API credentials.

Monitor your payment system

Monitor API errors, failed payments, pending transactions, callbacks and unusual activity.

Common MTN MoMo API Problems

Why Does My MTN MoMo API Callback Not Work?

Callbacks are one of the most common areas where developers encounter problems.

Check the following:

• Is the callback host correctly registered?
• Does the callback URL belong to the registered host?
• Is the callback endpoint publicly accessible?
• Is the correct protocol being used for the environment?
• Does the endpoint accept the required HTTP methods?
• Does your application return the expected response?
• Are you logging incoming callback requests?
• Can your application retrieve the transaction status if the callback is missing?

MTN's current documentation specifically notes that callback configuration differs between sandbox and production, so developers should follow the instructions for the environment they are using.

How Much Does the MTN Rwanda MoMo API Cost?

There is no single universal price that should be quoted for every MTN MoMo API integration.

API products, transaction types, commercial arrangements and applicable local terms can affect the cost of a production integration.

Developers should therefore avoid copying old pricing information from unrelated websites when planning a live payment service.

Before launching a commercial application, confirm the applicable fees and terms directly with MTN during the onboarding process.

Who Should Use the MTN Rwanda MoMo API?

The API is particularly useful for businesses and developers that need automated Mobile Money functionality inside their own software.

Good use cases include:

• E-commerce: Connect Mobile Money to online checkout.
• Startups: Build local payment functionality into digital products.
• Schools: Build supported payment collection systems.
• Marketplaces: Manage supported collection and payout workflows.
• Fintechs: Build approved financial technology services.
• Organizations: Automate supported collections and disbursements.
• Developers: Build and test payment applications through the sandbox.

MTN MoMo API vs Manual Mobile Money Payments

MTN MoMo API for E-Commerce in Rwanda

E-commerce is one of the clearest use cases for a MoMo API.

Imagine a Rwandan online store selling electronics, clothing or digital services.

Instead of displaying a Mobile Money number and asking every customer to send payment manually, the business can build a structured checkout experience around an approved API integration.

The workflow could look like:

1. Customer selects a product.
2. Customer enters checkout.
3. Website creates an order.
4. Customer selects MTN Mobile Money.
5. Backend initiates the supported payment request.
6. Customer authorizes payment.
7. MTN processes the transaction.
8. Application receives the final result.
9. Database records the successful payment.
10. Order moves to processing.

This architecture can reduce manual reconciliation and make it easier for a business to scale its online payment operations.

MTN MoMo API for a School Payment System

A school management platform could also use supported collection functionality to connect payment records with student accounts.

For example:

Student Account
      ↓
School Invoice
      ↓
MTN MoMo Payment
      ↓
Transaction Confirmation
      ↓
Student Account Updated
      ↓
Receipt / Payment Record

The exact service and eligibility would depend on the school's requirements and MTN's applicable onboarding process.

MTN MoMo API for a Rwanda Startup

For a startup building a Rwanda-focused application, Mobile Money integration can be an important part of the product architecture.

Potential applications include:

• Online marketplaces
• Delivery platforms
• Ticketing systems
• Subscription services
• Digital education platforms
• Business management software
• Payment collection platforms
• Approved fintech applications

The important consideration is to design the payment architecture before writing the integration code.

Best Practices for Building an MTN MoMo Integration

1. Start with the sandbox. Do not experiment with live customer transactions.
2. Choose the correct API product. Collections and disbursements solve different problems.
3. Keep credentials server-side.
4. Use unique transaction references.
5. Handle asynchronous payments correctly.
6. Implement callbacks carefully.
7. Have a transaction-status fallback.
8. Make payment processing idempotent.
9. Log important payment events.
10. Reconcile payments with your internal records.
11. Read the current MTN documentation before production deployment.

Frequently Asked Questions

What is the MTN Rwanda MoMo API?

The MTN Rwanda MoMo API is a set of APIs that allows approved businesses and developers to integrate supported MTN Mobile Money functionality into applications and digital services.

Is the MTN MoMo API available in Rwanda?

Yes. MTN provides a Rwanda developer environment and documentation for building and testing MoMo API integrations.

Is there an MTN MoMo API sandbox?

Yes. MTN provides a sandbox environment where developers can test their integrations before moving to production.

Can I use MTN MoMo API for an online shop?

Yes. Collections can be used for supported payment collection use cases, including online and digital commerce workflows.

Can I use PHP for MTN MoMo API integration?

Yes. PHP can communicate with REST APIs through HTTPS and can be used to build the backend of an MTN MoMo integration.

Can I use Node.js?

Yes. Node.js can also be used to build the backend services required for an MTN MoMo API integration.

What credentials are required?

MTN's current documentation identifies a subscription key, API user and API key as important credentials for accessing supported APIs and generating OAuth 2.0 access tokens.

What is a subscription key?

A subscription key is used to authenticate access to a subscribed API product and is supplied through the appropriate request header.

What happens after a Request to Pay request is accepted?

The transaction can continue processing asynchronously. The application should wait for the appropriate final transaction result rather than treating the initial accepted response as proof of successful payment.

Why are callbacks important?

Callbacks allow the payment platform to notify your application when an asynchronous transaction reaches its final state.

Can I use the MTN MoMo API for disbursements?

Yes. MTN's developer platform provides a Disbursements API for supported use cases involving payments to recipients.

Can I use the API for remittances?

MTN provides a Remittance API for supported remittance use cases. Live operation may require additional business, regulatory and contractual requirements.

Can I use the sandbox to process real customer payments?

No. The sandbox is intended for development and testing. Real transactions require the appropriate production onboarding and live environment.

How do I get production access?

Complete the required sandbox testing and follow MTN's current go-live process, including the applicable business, contractual, KYC and approval requirements.

How much does MTN MoMo API cost?

There is no single price applicable to every API integration. Confirm current commercial terms and applicable fees with MTN for your specific product and use case.

Related Fyndin Guides

• MTN MoMo Rwanda App 2026: Download, Login & How to Use It
• MTN MoMo Rwanda Code 2026: Complete USSD Guide
• MTN MoMo Rwanda Login 2026: How to Access Your Account
• MTN MoMo Pay Rwanda 2026: How It Works, Fees & Payments
• MTN Rwanda MoMo Tariff 2026: Complete Fees & Charges
• MTN MoMo Virtual Card Rwanda 2026
• How to Check MTN MoMo Transaction History in Rwanda

Final Takeaway

The MTN Rwanda MoMo API gives developers and businesses a way to connect supported MTN Mobile Money functionality with websites, mobile applications and business systems.

The best way to approach an integration is to start with the sandbox, choose the correct API product, implement secure authentication, correctly handle asynchronous transactions, build reliable callbacks and verify transaction status before completing orders or payouts.

For businesses building digital services in Rwanda, this can provide a much more scalable payment architecture than relying entirely on manual Mobile Money verification.

If you are planning a production integration, always check MTN's current developer documentation and onboarding requirements because API functionality, technical requirements, commercial terms and production procedures can change.