canonical: https://jentic.com/apis/bud-financial.thisisbud.com/bud-financial-thisisbud

# Bud Financial Thisisbud Bud Financial Platform API

Bud Financial's platform API gives banks, lenders, and fintechs access to UK and EU Open Banking data through a single REST surface. The spec covers OAuth token creation, customer creation and lifecycle management, listing aggregated bank accounts and transactions, and retrieving the consumer's bank connections set up via Bud's Connect product. It is the integration entry point for use cases like affordability assessment, cash-flow underwriting, account verification, and personal finance dashboards.

## For AI agents

Provision customers, retrieve their aggregated Open Banking accounts and transactions, and manage bank connections via Bud's financial data platform.

## Scope

Does not handle payment initiation, lending decisions, or KYC document verification - use for Open Banking customer provisioning, account aggregation, and transaction retrieval only.

## Capabilities

- Mint OAuth bearer tokens for the Bud platform via `/v1/oauth/token`
- Create and look up end customers in the Bud platform with createcustomer and getcustomer
- List all customers tied to a Bud client account for back-office tooling
- Retrieve a customer's aggregated bank accounts across UK and EU Open Banking providers
- List historical transactions for a customer's connected accounts for cash-flow analysis
- Retrieve the live bank connections a customer has authorised through Bud Connect
- Delete a customer record to honour right-to-erasure and offboarding workflows

## Use cases

### Affordability and Cash-Flow Underwriting

Underwrite consumer loans, mortgages, or rent applications using real bank-account behaviour rather than self-reported income. After the customer connects their bank through Bud Connect, the lender retrieves `/financial-data/v3/accounts` to confirm balances and `/financial-data/v3/transactions` to compute monthly inflows, recurring outgoings, and discretionary spend. Bud's category labels make it easy to classify rent, salary, and gambling outflows for affordability calculators.

Example prompt: Call listaccounts for the customer's customer_id, then call listtransactions filtered to the last 90 days and aggregate inflows by category

### Account Verification Before Direct Debit

Verify that a customer owns the bank account they are about to set up a direct debit on by retrieving `/connect/v2/connections` after the consumer's Bud Connect flow completes. The connection record returns the institution and the verified account holder name so the merchant can match it to the application form before submitting a SEPA or Bacs mandate. This reduces failed mandates and chargebacks.

Example prompt: Call listconnections on `/connect/v2/connections` for the customer and confirm the returned account holder name matches the application form

### Personal Finance Dashboard Backend

Build a personal finance management app where each end user is created via `/platform/v3/customers`, links their bank through Bud Connect, and the app then renders categorised transactions retrieved via `/financial-data/v3/transactions.` The same listaccounts call returns balances across current, savings, and credit accounts so the dashboard can show net position. Bud handles the underlying Open Banking provider connections.

Example prompt: Create a customer with createcustomer, store the returned customer_id, and on each refresh call listtransactions with that customer_id for the dashboard view

### AI Agent Open Banking Through Jentic

Allow an AI agent to inspect a consented user's bank data on their behalf without ever holding the Bud platform JWT. Through Jentic, the agent searches by intent, loads the listtransactions schema, and executes against `/financial-data/v3/transactions` with the customer_id supplied by the consented user's session. The OAuth token is minted and refreshed by Jentic at execution time so the agent never touches client credentials.

Example prompt: Use Jentic to search 'list a customer's bank transactions', load the listtransactions schema, and execute with the consented customer_id and a date range

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/oauth/token` | Mint a bearer access token |
| POST | `/platform/v3/customers` | Create an end customer in the Bud platform |
| GET | `/platform/v3/customers` | List all customers tied to your client account |
| GET | `/platform/v3/customers/{customer_id}` | Retrieve a single customer by ID |
| DELETE | `/platform/v3/customers/{customer_id}` | Delete a customer record |
| GET | `/financial-data/v3/accounts` | List a customer's aggregated bank accounts |
| GET | `/financial-data/v3/transactions` | List a customer's bank transactions |
| GET | `/connect/v2/connections` | List a customer's authorised bank connections |

## Key resources

- **OAuth** — Mint bearer tokens for authenticated calls to the Bud platform
- **Customers** — Create, list, retrieve, and delete end customers tied to your Bud client account
- **Financial Data** — List aggregated bank accounts and historical transactions for a customer
- **Connections** — List the Open Banking bank connections a customer has authorised through Bud Connect

## Why Jentic

- **Setup:** Wiring the Bud Financial Platform API by hand means minting and refreshing OAuth bearer tokens at `/v1/oauth/token` from your client id and secret, choosing the sandbox or production host, and coordinating customer, account, and transaction endpoints yourself. Through Jentic you install once, import the Bud Financial Platform API from the API Directory, store the client id and secret once, and your agent calls it.
- **Permission scoping:** Bud puts the customer id in the URL path (`/platform/v3/customers/{customer_id}`), so a rule can pin your agent to one customer: it can read that customer's accounts and transactions and nothing else. You choose the operations it may call, so a destructive one like deleting a customer is not included unless you add it.
- **Credential handling:** Your Bud client id and secret are stored once, encrypted, by your own Jentic One instance, which mints and refreshes the OAuth bearer token at execution time and injects only that token. The secret never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list a customer's bank transactions', and Jentic returns the matching transactions operation with its parameter schema so the agent calls `/financial-data/v3/transactions` without browsing the reference docs.

## Related APIs

- **Buckaroo Checkout JSON Gateway API** — European payment gateway used to debit accounts after Bud has verified ownership
- **Buckaroo Checkout JSON Gateway API** — Same Buckaroo gateway sourced from buckaroo.nl for SEPA charging after Bud verification
- **Bubble Data API** — Stores Bud customer IDs and underwriting decisions in a no-code Bubble app

## FAQ

### What authentication does the Bud Financial Platform API use?

Bud uses OAuth 2.0 bearer tokens in JWT format. POST your client_id and client_secret to `/v1/oauth/token` to receive an access_token, then send Authorization: Bearer <token> on subsequent requests. Through Jentic the client credentials are stored encrypted in the vault and the OAuth exchange runs server-side so they never enter the agent's context.

### Can I retrieve a customer's bank transactions with this API?

Yes, after the customer has authorised an Open Banking connection through Bud Connect. GET `/financial-data/v3/transactions` with the customer_id query parameter returns categorised transactions across all the customer's connected accounts. Combine with `/financial-data/v3/accounts` to retrieve balances at the same time.

### What are the rate limits for the Bud Financial API?

Bud applies per-client rate limits that vary between the sandbox and production environments. Specific values are not encoded in the spec - see the Bud client portal at docs.thisisbud.com for the limits assigned to your account. The API returns standard 429 responses when throttled and clients should back off before retrying.

### How do I create a Bud customer through Jentic?

Install the SDK with pip install jentic, search for 'create a Bud customer', load the createcustomer schema, and execute it against `/platform/v3/customers` with the customer's name and email. Jentic mints and refreshes the OAuth token from the vault and returns the new customer_id you can store for later `/financial-data/v3`/* calls.

### Does this API include Open Banking consent collection?

No. The Bud Financial Platform API itself does not host the consent flow - consent is collected through the Bud Connect product, which redirects the consumer to their bank to authorise data sharing. Once consent is granted the connection appears in `/connect/v2/connections` and accounts and transactions become accessible via the financial-data endpoints.

### Is the Bud Financial API free?

Bud is a paid platform sold to banks, lenders, and regulated fintechs. Pricing is negotiated per client and depends on call volume and the Bud products enabled (Connect, Aggregation, Transaction Categorisation, etc.). Sandbox access is provided for integration; see thisisbud.com for commercial terms.

### Can I limit what my agent is allowed to do with the Bud Financial Platform API?

Yes. Because you run Jentic One yourself, your own rules decide which Bud operations and credentials the agent may use. Since Bud puts the customer id in the URL path, such as `/platform/v3/customers/{customer_id}`, you can pin the agent to a single customer so it only reads that customer's accounts and transactions and nothing else. You also choose which operations it may call, so a destructive one like deleting a customer stays out of reach unless you explicitly allow it.