Homepage

We enable businesses of all sizes to access prepaid products, helping them build innovative solutions that attract, engage, retain, and reward customers worldwide.

Unlock new, high-profit revenue opportunities by offering complementary products such as mobile top-ups, data bundles, gift cards, and prepaid utility payments to new or existing customers.

Our Prepaid-as-a-Service platform ensures seamless, quick, and hassle-free integration.

Get Started Now

      <?php
        require_once(__DIR__ . '/vendor/autoload.php');
        
        // Configure API key authorization: ApiKey
        Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
        // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
        // Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');
        
        $api_instance = new Swagger\Client\Api\ZenditApi();
        $data = ; // Dto.TopupPurchaseMakeInput | Purchase input data
        
        try {
            $result = $api_instance->v1TopupsPurchasesPost($data);
            print_r($result);
        } catch (Exception $e) {
            echo 'Exception when calling ZenditApi->v1TopupsPurchasesPost: ', $e->getMessage(), PHP_EOL;
        }
        ?>

       var ZenditGatewayApi = require('zendit_gateway_api');
        var defaultClient = ZenditGatewayApi.ApiClient.instance;
        
        // Configure API key authorization: ApiKey
        var ApiKey = defaultClient.authentications['ApiKey'];
        ApiKey.apiKey = "YOUR API KEY"
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKey.apiKeyPrefix['Authorization'] = "Token"
        
        var api = new ZenditGatewayApi.ZenditApi()
        
        var data = ; // {Dto.TopupPurchaseMakeInput} Purchase input data
        
        
        var callback = function(error, data, response) {
          if (error) {
            console.error(error);
          } else {
            console.log('API called successfully. Returned data: ' + data);
          }
        };
        api.v1TopupsPurchasesPost(data, callback);

use Data::Dumper;
        use WWW::SwaggerClient::Configuration;
        use WWW::SwaggerClient::ZenditApi;
        
        # Configure API key authorization: ApiKey
        $WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
        # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
        #$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";
        
        my $api_instance = WWW::SwaggerClient::ZenditApi->new();
        my $data = WWW::SwaggerClient::Object::Dto.TopupPurchaseMakeInput->new(); 
        # Dto.TopupPurchaseMakeInput | Purchase input data
        
        eval { 
            my $result = $api_instance->v1TopupsPurchasesPost(data => $data);
            print Dumper($result);
        };
        if ($@) {
            warn "Exception when calling ZenditApi->v1TopupsPurchasesPost: $@\n";
        }

    from __future__ import print_statement
        import time
        import swagger_client
        from swagger_client.rest import ApiException
        from pprint import pprint
        
        # Configure API key authorization: ApiKey
        swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
        # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
        # swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'
        
        # create an instance of the API class
        api_instance = swagger_client.ZenditApi()
        data =  # Dto.TopupPurchaseMakeInput | Purchase input data
        
        try: 
            # Create transaction for purchase
            api_response = api_instance.v1_topups_purchases_post(data)
            pprint(api_response)
        except ApiException as e:
            print("Exception when calling ZenditApi->v1TopupsPurchasesPost: %s\n" % e)

     import io.swagger.client.*;
        import io.swagger.client.auth.*;
        import io.swagger.client.model.*;
        import io.swagger.client.api.ZenditApi;
        
        import java.io.File;
        import java.util.*;
        
        public class ZenditApiExample {
        
            public static void main(String[] args) {
                ApiClient defaultClient = Configuration.getDefaultApiClient();
                
                // Configure API key authorization: ApiKey
                ApiKeyAuth ApiKey = (ApiKeyAuth) defaultClient.getAuthentication("ApiKey");
                ApiKey.setApiKey("YOUR API KEY");
                // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
                //ApiKey.setApiKeyPrefix("Token");
        
                ZenditApi apiInstance = new ZenditApi();
                Dto.TopupPurchaseMakeInput data = ; // Dto.TopupPurchaseMakeInput | Purchase input data
                try {
                    dto.TopupPurchaseResponse result = apiInstance.v1TopupsPurchasesPost(data);
                    System.out.println(result);
                } catch (ApiException e) {
                    System.err.println("Exception when calling ZenditApi#v1TopupsPurchasesPost");
                    e.printStackTrace();
                }
            }
        }

curl -X POST -H "Authorization: [[apiKey]]" "https://api.zendit.io/v1/topups/purchases"

      Configuration *apiConfig = [Configuration sharedConfig];

        // Configure API key authorization: (authentication scheme: ApiKey)
        [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
        // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
        //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
        
        Dto.TopupPurchaseMakeInput *data = ; // Purchase input data
        
        ZenditApi *apiInstance = [[ZenditApi alloc] init];
        
        // Create transaction for purchase
        [apiInstance v1TopupsPurchasesPostWith:data
                      completionHandler: ^(dto.TopupPurchaseResponse output, NSError* error) {
                                    if (output) {
                                        NSLog(@"%@", output);
                                    }
                                    if (error) {
                                        NSLog(@"Error: %@", error);
                                    }
                                }];

      using System;
        using System.Diagnostics;
        using IO.Swagger.Api;
        using IO.Swagger.Client;
        using IO.Swagger.Model;
        
        namespace Example
        {
            public class v1TopupsPurchasesPostExample
            {
                public void main()
                {
                    
                    // Configure API key authorization: ApiKey
                    Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                    // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                    // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
        
                    var apiInstance = new ZenditApi();
                    var data = new Dto.TopupPurchaseMakeInput(); // Dto.TopupPurchaseMakeInput | Purchase input data
        
                    try
                    {
                        // Create transaction for purchase
                        dto.TopupPurchaseResponse result = apiInstance.v1TopupsPurchasesPost(data);
                        Debug.WriteLine(result);
                    }
                    catch (Exception e)
                    {
                        Debug.Print("Exception when calling ZenditApi.v1TopupsPurchasesPost: " + e.Message );
                    }
                }
            }
        }

Scalability

Our cloud based platform can easily scale to meet the needs of businesses of all sizes, from small startups to large enterprises.

Integrations

A wide range of options from API, SDKs to No/Low code widgets and plugins that can easily integrate our prepaid catalog with your existing systems and technologies.

Security

We are built with state-of-the-art security measures to ensure the safety and security of all transactions.

Availability

Hosted on a highly available and reliable cloud infrastructure, ensuring uptime and availability of your prepaid payment options.

Workflow

Designed to be a user-friendly and intuitive workflow without sacrificing powerful features and flexibility. Create your own customized solution or use one of our pre-built solutions.