Wise API SDKs & Libraries: Official and Community Support (2026)

SDKs overview

The Wise Platform API offers programmatic access to its suite of financial services, including international money transfers, multi-currency accounts, and business payments. To facilitate integration, Wise (formerly TransferWise) provides official Software Development Kits (SDKs) across several popular programming languages. These SDKs abstract away the complexities of HTTP requests, JSON serialization, and OAuth 2.0 authentication, allowing developers to focus on application logic rather than low-level API interactions Wise API reference documentation. By utilizing an SDK, developers can often reduce development time, minimize errors, and ensure adherence to best practices for interacting with the Wise API.

In addition to official support, the Wise API ecosystem benefits from community-contributed libraries. These third-party tools can extend functionality, provide alternative language support, or offer specialized integrations. While official SDKs are maintained directly by Wise and generally offer the most stable and up-to-date features, community libraries can provide flexibility and address niche use cases as part of the broader developer community.

The Wise API's design, which includes clear documentation and a sandbox environment for testing, supports efficient development regardless of whether an official SDK or a community library is used. Authentication is primarily handled via OAuth 2.0, a widely adopted authorization framework for securing API access across various platforms, including services like Google Cloud and Microsoft Azure OAuth 2.0 framework specification. This standardized approach simplifies secure integration for developers.

Official SDKs by language

Wise offers several official SDKs designed to streamline the development process for various programming languages. These SDKs encapsulate API endpoints, handle data serialization, and manage authentication flows, ensuring a consistent and robust integration experience. Each SDK is maintained by Wise and is the recommended approach for integrating with the Wise API in its respective language.

Installation

Installing a Wise SDK typically follows the standard package management procedures for the respective programming language. Each SDK is designed to be easily integrated into existing projects, requiring only a few commands to get started.

Java SDK Installation

For Java projects, the Wise SDK is available via Maven Central. Developers add the dependency to their project's pom.xml (for Maven) or build.gradle (for Gradle). Specific version information and repository details are available in the Wise API integration guide.

<dependency>
    <groupId>com.wise</groupId>
    <artifactId>wise-java-sdk</artifactId>
    <version>X.Y.Z</version> <!-- Replace with the latest version -->
</dependency>

Python SDK Installation

The Python SDK can be installed using pip, the Python package installer. This command retrieves the package from PyPI, the Python Package Index, which hosts a vast collection of Python libraries Python Package Index (PyPI).

pip install wise-python-sdk

Node.js SDK Installation

For Node.js applications, the SDK is available through npm (Node Package Manager) or Yarn.

npm install @wise/wise-node-sdk

Or using Yarn:

yarn add @wise/wise-node-sdk

PHP SDK Installation

PHP projects typically use Composer for dependency management. The Wise PHP SDK can be added to your project with a simple Composer command.

composer require wise/wise-php-sdk

.NET SDK Installation

For .NET (C#) projects, the SDK is distributed as a NuGet package, which can be installed via the .NET CLI or NuGet Package Manager in Visual Studio.

dotnet add package Wise.Net.SDK

Quickstart example

This Python quickstart example demonstrates how to initialize the Wise Python SDK and make a simple API call to retrieve your Wise profile details. Before running this code, ensure you have obtained your API token from the Wise developer console and set it as an environment variable or replace YOUR_API_TOKEN with your actual token. This token is crucial for authenticating your requests with the Wise API using OAuth 2.0.

import os
from wise.client import WiseClient
from wise.exceptions import WiseError

# Initialize the Wise client with your API token
# It's recommended to load your API token from an environment variable for security.
api_token = os.environ.get("WISE_API_TOKEN", "YOUR_API_TOKEN")

try:
    client = WiseClient(api_token=api_token)

    # Get your profile details
    # The 'me' endpoint typically returns information about the authenticated user/profile.
    profile = client.profile.me()

    print(f"Successfully fetched profile details:")
    print(f"  ID: {profile.id}")
    print(f"  Type: {profile.type}")
    print(f"  Name: {profile.first_name} {profile.last_name}")
    print(f"  Email: {profile.email}")

    # Example: List available currencies (if applicable by the SDK/API version)
    # The exact method might vary based on the SDK version and API structure.
    # For demonstration, let's assume a 'currencies' endpoint exists.
    # This part might need adjustment based on current Wise API reference.
    # currencies = client.currency.list()
    # print(f"Available currencies: {[c.code for c in currencies]}")

except WiseError as e:
    print(f"An error occurred: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

This example demonstrates basic client initialization and a call to retrieve authenticated user details. For more complex operations, such as initiating transfers or managing balances, consult the Wise API reference documentation, which provides detailed endpoint descriptions and request/response examples for all available services.

Community libraries

Beyond the official SDKs, the Wise API community has developed various third-party libraries and tools that can assist with integration. These community contributions often fill specific gaps, provide support for less common languages, or offer specialized functionalities not covered by the official SDKs. While not officially supported or maintained by Wise, they can be valuable resources for developers.

• Go/Golang Libraries: Although there isn't an official Go SDK from Wise, the Go community often develops client libraries for popular APIs. Developers can search platforms like GitHub for wise-go-sdk or transferwise-go to find community-maintained clients. These typically involve manual binding to the REST API endpoints.
• Ruby Libraries: Similar to Go, community-driven Ruby gems might exist to interact with the Wise API. Searching for wise-api-ruby or transferwise-ruby on RubyGems.org or GitHub could yield relevant projects.
• Other Languages: For languages without official SDKs, developers often create custom wrappers or use generic HTTP client libraries to interact with the Wise REST API directly. This approach requires manual handling of authentication, request construction, and response parsing, offering maximum flexibility but also requiring more development effort.
• API Clients & Tools: Beyond language-specific libraries, various API clients and tools, such as Postman collections or OpenAPI/Swagger definitions, are often shared by the community. These can help in exploring the API endpoints and generating client code stubs. The Wise API provides an OpenAPI specification for automated client generation.

When using community libraries, it is important to review their documentation, community support, and maintenance status to ensure they meet project requirements for stability and security. Always refer to the official Wise API documentation for the most accurate and up-to-date information on endpoints, authentication, and data models, especially for critical financial transactions.