Payments Hub Integration Guide

Atomic Payments Hub is Atomic's bundled UI for PayLink Manage. It gives users a single place to view connected billing accounts and take common actions.

Launch the Payments Hub by initializing Transact in your client app. Atomic handles authentication and orchestrates the provider workflows behind the scenes.

Overview

The recommended Payments Hub integration flow is as follows:

1
From your client, request a publicToken from your server when the user enters Payments Hub.
2
On your server, create an AccessToken by calling Atomic's API, then return the publicToken to your client.
3
On the client, launch Atomic Transact with pay-link scope and a manage task for the Hub apps you want to show.
4
The user authenticates with providers in Transact. Handle emitted SDK events as they occur in your client application.
5
After authentication, users are directed back to the Payments Hub to view connected accounts and bills, see recommendations, and take related actions.
6
Optionally, use webhook events or Task polling for backend observability and sync.

For implementation, you mainly need your server-side publicToken flow, a client-side Transact launch, and handlers for SDK events and webhooks.

See the Transact SDK Parameters and Connect Accounts guide for additional integration details.

Creating an AccessToken

To establish a connection to a 3rd party system, you will need to create an AccessToken via a call to the Atomic API, then instantiate Transact. These API calls are secured via your API Key and Secrets. You can retrieve your API credentials for the relevant environment from the Atomic Console.

Atomic uses client-side field level encryption with KMS keys to encrypt sensitive data such as account details in our system. If required, you can utilize a unique data key for encrypting data for your users. Reach out to your Atomic contact for more details.

Request an AccessToken server-side

An AccessToken for the end user is required to initialize Transact. To retrieve the AccessToken, make the following HTTPS request from your server.

This API call creates a user in the Atomic system using the identifier. All subsequent communications from Atomic, such as webhooks and client-side events, will contain this identifier to facilitate mapping corresponding data to the correct user.

POST/access-token

https://sandbox-api.atomicfi.com/access-token

Send publicToken to your client

The above request will result in a response with a publicToken.

You will need the publicToken from the response for setting up your client-side code to initialize Transact. Once it's been received on your server, send the publicToken to your client.

Response body

{
  "data": {
    "publicToken": "PUBLIC_TOKEN"
  }
}

Setting Up Transact

Use the Atomic Transact SDK to launch Payments Hub from your client application. Your app fetches a publicToken from your server, then initializes Transact with a Manage task that determines which Hub apps are shown.

Create your configuration

Transact requires a configuration object when initialized in a live application. To get started you only need the publicToken from the previous step and the tasks you wish to execute.

For the Payments Hub experience, launch Transact with a Manage task and set the apps array to the Hub sections you want to render (for example, ['expenses', 'suggestions']).

For a full list of options, please refer to the Transact SDK Parameters Reference .

Launch Payments Hub

Atomic.transact({
  config: {
    scope: 'pay-link',
    publicToken: 'PUBLIC_TOKEN',
    tasks: [{ operation: 'manage', apps: ['expenses', 'suggestions'] }]
  }
})

Add Transact to your app

Atomic's Transact is a client-side SDK that lets your users manage billing relationships with service providers.

Transact handles credential validation, multi-factor authentication, and error handling for each system that we support. For Payments Hub, you can choose which sections to show by setting task apps in configuration.

Next Steps

Payments Hub is a bundled interface for Manage use cases, so your next steps are mostly configuration and event handling rather than building each screen from scratch.

Use these guides to complete your integration:

Connect Accounts

Ingest Data

Transact SDK Reference