Checkout.com SDKs & Libraries: Official Integrations (2026)

SDKs overview

Checkout.com offers a suite of official Software Development Kits (SDKs) designed to facilitate the integration of its payment processing services into various applications and platforms. These SDKs are available for several popular programming languages, providing developers with client libraries that abstract the underlying RESTful API interactions. The purpose of these SDKs is to simplify common tasks such as initiating payments, managing refunds, handling disputes, and receiving real-time notifications via webhooks. By using an SDK, developers can interact with the Checkout.com API using familiar language constructs, rather than directly constructing HTTP requests and parsing JSON responses, which can reduce development time and potential errors Checkout.com server-side SDKs documentation.

The official SDKs are actively maintained by Checkout.com and are typically kept up-to-date with the latest API versions and features. They often include built-in features for request signing, error handling, and object serialization, contributing to a more streamlined and secure integration process. For example, the SDKs might automatically manage API key authentication headers, allowing developers to focus on business logic rather than authentication specifics. The availability of these tools supports a broader range of developer preferences and existing technology stacks, enabling businesses to integrate Checkout.com's payment capabilities across different environments.

Official SDKs by language

Checkout.com provides official SDKs for a range of programming languages, each designed to offer a native-like experience for developers. These SDKs encapsulate the complexities of direct API calls, offering functions and objects that map to Checkout.com's API resources. Each SDK typically includes comprehensive documentation and examples to guide developers through common integration patterns.

Each SDK is maintained to support the latest features and security standards of the Checkout.com platform. For example, the JavaScript SDK, compatible with Node.js environments, enables server-side integrations for web applications. The PHP SDK integrates seamlessly with Composer-managed projects, a common practice in the PHP ecosystem. Java developers can incorporate the Java SDK into their Maven or Gradle builds, aligning with standard enterprise Java development workflows. Python developers benefit from a pip-installable package, fitting into typical Python project setups. Similarly, .NET developers can use NuGet to integrate the .NET SDK, and Ruby developers use RubyGems for the Ruby SDK. This broad language support ensures that a wide array of development teams can integrate Checkout.com services efficiently Checkout.com SDK official guides.

Installation

Installing Checkout.com SDKs typically follows the standard package management practices for each respective programming language. These methods are designed to be straightforward, allowing developers to quickly add the necessary libraries to their projects.

JavaScript (Node.js)

For Node.js projects, the SDK is available via npm or Yarn. Navigate to your project directory and run one of the following commands:

npm install @checkout.com/checkout-sdk-node

or

yarn add @checkout.com/checkout-sdk-node

This command downloads the package and its dependencies, making the SDK available for import in your JavaScript files.

PHP

PHP projects commonly use Composer for dependency management. To install the PHP SDK, execute the following command in your project's root directory:

composer require checkout/checkout-sdk-php

Composer will add the SDK to your composer.json and install it into your vendor directory.

Java

Java developers typically use Maven or Gradle. For Maven, add the following dependency to your pom.xml file:

<dependency>
    <groupId>com.checkout</groupId>
    <artifactId>checkout-sdk-java</artifactId>
    <version>1.x.x</version> <!-- Use the latest version -->
</dependency>

For Gradle, add it to your build.gradle file:

implementation 'com.checkout:checkout-sdk-java:1.x.x' // Use the latest version

Replace 1.x.x with the latest stable version number available from the Checkout.com Java SDK GitHub repository or Maven Central.

Python

The Python SDK is distributed via PyPI. You can install it using pip:

pip install checkout-sdk-python

This command installs the SDK and its required packages into your Python environment.

.NET

.NET developers use NuGet for package management. From the Package Manager Console in Visual Studio, or via the .NET CLI, run:

dotnet add package Checkout.Com.Sdk

This command adds a reference to the Checkout.com SDK in your project file.

Ruby

The Ruby SDK is available as a RubyGem. To install it, run:

gem install checkout_sdk

After installation, you can require the gem in your Ruby application.

For all SDKs, it is recommended to consult the specific language's installation guide on the Checkout.com developer documentation for the most current installation instructions and versioning details.

Quickstart example

This example demonstrates how to initiate a payment using the Checkout.com Node.js SDK. This snippet illustrates the basic steps involved: initializing the SDK client, defining payment details, and making an API call to create a payment. This example assumes you have your secret API key available.

const Checkout = require('@checkout.com/checkout-sdk-node');

const cko = new Checkout.DefaultSdk({
    secretKey: 'sk_test_YOUR_SECRET_KEY',
    environment: Checkout.environments.sandbox
});

async function createPayment() {
    try {
        const payment = await cko.payments.request({
            source: {
                type: 'token',
                token: 'tok_YOUR_CARD_TOKEN' // Obtained from Checkout.js or similar client-side method
            },
            amount: 1000, // Amount in minor units (e.g., 1000 = 10.00 USD)
            currency: 'USD',
            reference: 'order-12345',
            processing_channel_id: 'pc_YOUR_PROCESSING_CHANNEL_ID' // Optional
        });

        console.log('Payment created successfully:', payment);
        return payment;
    } catch (error) {
        console.error('Error creating payment:', error.name, error.message, error.body);
        throw error;
    }
}

createPayment();

In this Node.js example:

• secretKey: Your secret API key, obtained from your Checkout.com dashboard. For testing, a sandbox key is used.
• environment: Specifies whether to connect to the sandbox or live environment.
• source: Details about the payment instrument. Here, a token is used, which would typically be generated client-side using Checkout.js or a similar method that securely tokenizes card details Checkout.com client-side SDKs documentation.
• amount: The payment amount in minor units (e.g., cents for USD).
• currency: The three-letter ISO currency code.
• reference: A unique identifier for the payment, useful for reconciliation.
• processing_channel_id: An optional identifier for a specific processing channel, if configured.

This quickstart demonstrates a server-side payment initiation. Client-side integrations, often involving JavaScript libraries like Checkout.js, are typically used to securely collect sensitive payment information and tokenize it before sending it to your server for processing with the server-side SDKs. The separation ensures PCI compliance by minimizing the exposure of raw card data on your servers, aligning with industry best practices for secure payment processing, as detailed in Stripe's PCI DSS compliance guide.

Community libraries

While Checkout.com maintains official SDKs for major languages, the open-source community may also develop libraries or plugins to extend functionality or support additional frameworks. These community-contributed tools are not officially supported by Checkout.com, meaning their maintenance, security, and compatibility with future API changes are at the discretion of their respective developers. Developers considering community libraries should review their source code, check for active maintenance, and understand the potential risks associated with using unsupported third-party software.

Community contributions often emerge to fill specific niches, such as integrations with less common programming languages, specialized e-commerce platforms (e.g., custom Magento extensions not officially provided by Checkout.com), or specific web frameworks. These libraries can sometimes offer expedited development for unique use cases or provide alternative approaches to integration. However, it's crucial to verify their adherence to security standards, especially when handling sensitive payment data. Organizations like the Open Web Application Security Project (OWASP) provide guidelines on secure coding practices that are relevant when evaluating any third-party library OWASP Top Ten project.

For critical production systems, relying on official SDKs and direct API integrations is generally recommended due to guaranteed support, consistent updates, and adherence to security protocols. Developers are encouraged to consult the official Checkout.com documentation and API reference for the most reliable and secure integration methods Checkout.com official documentation.