TrueLayer

Overview

TrueLayer offers an Open Banking platform designed to enable financial institutions and fintech companies to access financial data and initiate payments directly from bank accounts. Founded in 2017, the company provides an API-driven infrastructure that connects to banks across various markets, primarily within Europe. The platform supports a range of use cases, including initiating account-to-account payments, verifying account ownership, and accessing real-time transaction data for financial management and lending applications.

Developers utilize TrueLayer's APIs to embed financial services directly into their applications. This includes the Payments API for secure payment initiation without card schemes, the Data API for retrieving account information and transaction histories, and the Payouts API for making disbursements. The platform is regulated under PSD2 (Payment Services Directive 2) and adheres to data protection standards such as GDPR and ISO 27001, providing a compliant framework for handling sensitive financial information.

TrueLayer's services are suited for businesses seeking to reduce payment processing costs, enhance payment security, and streamline financial operations. By offering direct bank connections, it aims to provide an alternative to traditional card-based payments and manual data entry. The platform supports a sandbox environment for testing integrations before deployment, and provides documentation and SDKs for multiple programming languages to facilitate developer onboarding.

The core value proposition of TrueLayer lies in its ability to enable direct interactions with bank infrastructure. This can lead to faster payment settlement times compared to traditional methods and offers a more granular view of customer financial behavior for risk assessment and personalized services. Businesses in sectors such as lending, wealth management, and e-commerce can leverage these capabilities to build new financial products or enhance existing ones, for example, by automating income verification or offering immediate bank transfers at checkout.

Key features

• Payments API: Enables direct, real-time account-to-account payments from customer bank accounts, bypassing traditional card networks. This can reduce transaction fees and enhance payment security by eliminating sensitive card data handling.
• Data API: Provides access to customer financial data, including account balances, transaction history, and account details, with user consent. This data supports applications in personal finance management, lending, and fraud detection.
• Payouts API: Facilitates programmatic disbursements and refunds directly to bank accounts. This feature is useful for platforms requiring efficient and secure transfer of funds, such as payroll systems or marketplace payouts.
• Account Verification: Allows businesses to verify account ownership and details in real-time, helping to prevent fraud and comply with KYC (Know Your Customer) regulations.
• Fraud Prevention Tools: Utilizes real-time financial data and account insights to identify and mitigate potential fraudulent activities, enhancing the security of transactions.
• Regulatory Compliance: Operates under PSD2 regulation and adheres to GDPR and ISO 27001 standards, ensuring a secure and legally compliant framework for financial data access and payment initiation.
• Sandbox Environment: Offers a dedicated testing environment for developers to build and validate integrations without affecting live production data.
• Multi-language SDKs: Provides client libraries for popular programming languages including Python, Node.js, Java, Go, Ruby, and PHP, simplifying API integration.

Pricing

TrueLayer offers tiered pricing based on usage, beginning with a free Starter plan. Paid plans are structured with monthly fees and per-transaction charges, varying by product (Payments, Data, Payouts) and volume.

Pricing as of 2026-05-28. For detailed and up-to-date pricing, refer to the TrueLayer pricing page.

Common integrations

• E-commerce Platforms: Integrate TrueLayer for direct bank payments at checkout, offering an alternative to card payments.
• Personal Finance Management (PFM) Apps: Utilize the Data API to aggregate user financial data from multiple bank accounts, providing a comprehensive financial overview.
• Lending and Credit Scoring Platforms: Access real-time transaction data and income verification to automate and improve credit assessment processes.
• Digital Wallets: Enable users to link their bank accounts for instant top-ups and payments within the wallet ecosystem.
• Accounting Software: Automate reconciliation by pulling transaction data directly from bank accounts, streamlining bookkeeping tasks.
• Investment Platforms: Facilitate direct bank transfers for funding investment accounts and managing portfolio cash flows.

Alternatives

• Plaid: Offers similar services for connecting bank accounts and enabling payments, primarily focused on the US market but with growing international presence.
• Yapily: Specializes in Open Banking infrastructure, providing APIs for financial data access and payment initiation across Europe, similar to TrueLayer.
• Stripe: While primarily known for card processing, Stripe also offers bank debit options and financial services components that can serve as alternatives or complements for certain use cases. Stripe's ACH Direct Debit documentation provides details on their bank payment offerings.
• Akoya: Focuses on secure, API-based access to financial data, primarily in the US, acting as a network between financial institutions and data aggregators.

Getting started

To begin integrating with TrueLayer, developers typically start by signing up for a developer account and obtaining API credentials. The process involves creating an application in the TrueLayer Console and configuring redirect URIs. The following Python example demonstrates how to initiate an authorization request for a user to connect their bank account, a common first step in accessing financial data or initiating payments.

import requests
import json

# Replace with your actual client_id and client_secret from TrueLayer Console
CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"
REDIRECT_URI = "YOUR_REDIRECT_URI"

# TrueLayer authorization endpoint
AUTH_URL = "https://auth.truelayer.com"

def get_authorization_url(scope: list[str], state: str) -> str:
    """Generates the TrueLayer authorization URL."""
    params = {
        "response_type": "code",
        "client_id": CLIENT_ID,
        "scope": " ".join(scope), # Space-separated scopes
        "redirect_uri": REDIRECT_URI,
        "state": state,
        "enable_mock": "true" # Use 'true' for sandbox environment testing
    }
    query_string = "&".join([f"{k}={v}" for k, v in params.items()])
    return f"{AUTH_URL}/?{query_string}"

# Example usage:
# Define the scopes needed (e.g., 'accounts' for account data, 'payments' for payment initiation)
REQUESTED_SCOPES = ["info", "accounts", "transactions", "balance", "payments"]
# A unique state string to prevent CSRF attacks
SESSION_STATE = "some_unique_session_identifier"

auth_url = get_authorization_url(REQUESTED_SCOPES, SESSION_STATE)
print(f"Please open this URL in your browser to authorize: {auth_url}")
print(f"After authorization, you will be redirected to: {REDIRECT_URI}")
print("TrueLayer will append 'code' and 'state' query parameters to your redirect URI.")

# In a real application, you would then handle the redirect and exchange the 'code' for an access token.
# This typically happens in a backend service.
# For example, to exchange the code for an access token:
# def exchange_code_for_token(auth_code: str) -> dict:
#     token_url = f"{AUTH_URL}/connect/token"
#     headers = {
#         "Content-Type": "application/x-www-form-urlencoded"
#     }
#     data = {
#         "grant_type": "authorization_code",
#         "client_id": CLIENT_ID,
#         "client_secret": CLIENT_SECRET,
#         "redirect_uri": REDIRECT_URI,
#         "code": auth_code
#     }
#     response = requests.post(token_url, headers=headers, data=data)
#     response.raise_for_status()
#     return response.json()

# Example of what the token response might look like:
# {
#     "access_token": "eyJ...",
#     "expires_in": 3600,
#     "token_type": "Bearer",
#     "scope": "info accounts transactions balance payments",
#     "refresh_token": "eyJ..."
# }

This Python code snippet constructs the initial authorization URL. Once a user grants consent through their bank, TrueLayer redirects them back to the REDIRECT_URI with an authorization code. This code is then exchanged for an access token using a backend call, which can then be used to make authenticated requests to TrueLayer's Data and Payments APIs. Comprehensive details on authentication flows are available in the TrueLayer documentation on authentication.