# Teller MCP

> Teller connects your AI client directly to live bank accounts via Open Banking standards. It lets you list connected accounts, check real-time balances, query historical transactions, verify account owner identity, and initiate payments like Zelle transfers, all using natural language commands.

## Overview
- **Category:** finance-accounting
- **Price:** Free
- **Tags:** banking-api, financial-data, transaction-history, payment-initiation, open-banking

## Description

Listen up. This MCP Server gives your AI client direct access to your live bank accounts using Open Banking standards. You're not dealing with clunky dashboards; you manage money and run payments just by talking to it.

**Setting Up & Checking Your Accounts**

You wanna know which banks we can even connect to? Use `list_institutions` to get a rundown of every supported financial institution. Once connected, `list_accounts` spits out a list of every bank account under your current enrollment, complete with unique identifiers. If you need specific information about one particular account, use `get_account`. For sensitive details like routing numbers and full account IDs, run `get_account_details`. You can pull general info for any connected account using `get_account`.

To check your money situation, first, use `get_account_balances`. That function fetches both the current available balance—the cash you can spend right now—and the overall ledger balance for any specified account. If you wanna see what happened with that dough over time, run `list_transactions`. You can query past financial movements and filter those results by a specific date range or page through large data sets.

**Identity Verification & Payees**

Need to verify who owns the money? Use `get_identity` to pull personal details like names, addresses, phone numbers, and emails linked to the bank accounts. When you're ready to send dough somewhere, first, you gotta define the recipient using `create_payee`. This sets up a new person or business you can actually send cash to from your connected accounts.

**Making Payments & Managing Access**

Sending money is straightforward: run `initiate_payment` specifying which account you're sending it from and which payee you just set up. You don't gotta deal with wire forms; you just tell the agent what to do, and it sends the payment (like a Zelle transfer).

If things get messy or you change banks, you can control your access. Use `delete_account` if you only wanna cut off one specific bank account from the enrollment. If you want to wipe the slate clean and revoke all banking credentials for every single linked account, run `delete_all_accounts`. That's it.

## Tools

### get_account_balances
Fetches the current available balance and ledger balance for any connected account.

### get_account_details
Gets sensitive data like routing numbers and full account identifiers for a specific bank account.

### list_accounts
Generates a list of every bank account connected under the current enrollment.

### create_payee
Defines a new recipient (payee) that you can send money to from your linked accounts.

### delete_account
Removes authorization access for one specific bank account from the enrollment.

### delete_all_accounts
Revokes all banking credentials and deletes access to every account linked in your enrollment.

### get_account
Retrieves general details for a single, specified bank account ID.

### get_identity
Pulls the owner's identity information, including names, addresses, phone numbers, and emails.

### initiate_payment
Sends money from a specified account to a defined payee (e.g., via Zelle).

### list_institutions
Returns a list of all supported financial institutions that Teller can connect to.

### list_transactions
Queries and lists historical ledger transactions for a specified account, supporting date filters.

## Prompt Examples

**Prompt:** 
```
List all my connected bank accounts and their IDs.
```

**Response:** 
```
I've retrieved your accounts. You have a 'Checking' account (ID: acc_123) and a 'Savings' account (ID: acc_456) connected via Chase.
```

**Prompt:** 
```
What is the current balance of my account acc_123?
```

**Response:** 
```
The current ledger balance for account acc_123 is $1,250.50, with $1,200.00 available for immediate use.
```

**Prompt:** 
```
Show me the identity information associated with my accounts.
```

**Response:** 
```
The identity records show the accounts are owned by 'John Doe', with a registered address at 123 Finance St and email 'john@example.com'.
```

## Capabilities

### List connected financial accounts
Retrieves a list of all linked bank accounts and their unique identifiers.

### Check account balances
Gets the current ledger balance and the amount available for immediate spending on any specified account.

### Pull transaction history
Queries past financial movements, allowing you to filter by date range or page through results.

### Verify account owner identity
Pulls personal data (name, address, email) linked to the bank accounts for verification purposes.

### Send money payments
Initiates a payment from an account using services like Zelle after you've defined the recipient payee.

### Manage account access
Allows you to add new payees or completely revoke authorization for specific accounts within the enrollment.

## Use Cases

### Reconciling multi-source spending
You need to track every expense from last month. Instead of logging into three different bank websites and copy/pasting data, you ask your agent: 'Show me all transactions for the period of March 1st to March 31st.' The agent runs `list_transactions` across all connected accounts, giving you one unified output.

### Verifying a client's ownership
Before sending money, compliance needs to confirm the account owner. You ask your agent: 'Verify John Doe's details for account acc_123.' The agent runs `get_identity`, which instantly provides the registered name, address, and email, completing the check.

### Setting up a new payment workflow
You need to pay a vendor who isn't in your system. First, you use `create_payee` to define them. Then, when ready, you ask: 'Pay $500 to the vendor.' The agent runs `initiate_payment`, executing the transfer instantly.

### Quickly checking fund availability
You're running a payment script and need confirmation that sufficient funds exist before proceeding. You ask: 'What is the available balance on my main account?' The agent runs `get_account_balances` to give you the precise, actionable figure.

## Benefits

- **Real-Time Balance Checks:** Stop guessing if you have enough money. Using `get_account_balances` gives immediate ledger and available funds for any account, eliminating manual balance lookups.
- **Full Transaction Audit Trail:** Need to know where the cash went? `list_transactions` pulls detailed history across accounts, letting you filter by date or page through thousands of entries instantly.
- **Automated Payments:** Never manually initiate a transfer again. You can define payees using `create_payee` and then run payments directly with `initiate_payment`, all from chat.
- **Identity Verification Built-In:** Compliance checks are simple. The `get_identity` tool instantly pulls owner info (address, email) associated with the accounts, saving you weeks of manual KYC work.
- **Centralized Account Management:** Instead of logging into five different bank portals, use `list_accounts` and `get_account_details` to treat all your financial data as one unified source for your AI agent.

## How It Works

The bottom line is: You talk to your AI client, and the client talks to your bank account via Teller.

1. Subscribe to the Teller server and enter your required Access Token, Certificate, and Private Key.
2. Your AI client authenticates with Vinkius and receives API access credentials for the bank network.
3. You prompt your agent (e.g., 'What was my spending last Tuesday?') and the agent executes the necessary tools (`list_transactions`) to get the answer.

## Frequently Asked Questions

**How does Teller handle initiating payments?**
You must first use `create_payee` to define the recipient before running any payment. Once the payee is set up, the agent executes `initiate_payment`, sending funds directly from your specified account.

**Can I check my balances for all accounts at once using Teller?**
Yes. You can first run `list_accounts` to get all available IDs, and then ask the agent to run `get_account_balances` on those IDs sequentially for a full view.

**What if I need to stop using an account with Teller?**
You can revoke access by running `delete_account` for that specific bank, or use the more drastic `delete_all_accounts` tool if you want to cut ties completely.

**Does Teller support transactions older than 90 days?**
The `list_transactions` tool supports date filtering and pagination. You specify the necessary start and end dates, allowing you to query historical data beyond typical limits.

**What authentication credentials does Teller require to execute a tool like `list_accounts`?**
You must provide your Teller Access Token, Certificate, and Private Key. These keys are generated during the initial enrollment process with Teller. Your AI client uses these credentials to authenticate every call, ensuring secure access to your banking data.

**How do I check which financial institutions are supported by the Teller API?**
You run the `list_institutions` tool to get a list of all compatible banks. This lets you verify connectivity before trying to fetch accounts from a specific source. It confirms the scope of your data access.

**Can the Teller API completely revoke my banking connection using `delete_all_accounts`?**
Yes, calling `delete_all_accounts` immediately revokes authorization for every connected financial account. This action is irreversible and severs all access between your AI client and the bank data.

**What does the Teller API return when I use the `list_accounts` tool?**
The `list_accounts` tool returns a list containing every connected account ID and its associated name. This initial list allows you to then target specific accounts for detailed queries, like running `get_account_details`.

**Can I retrieve my full account and routing numbers for a specific account?**
Yes. Use the `get_account_details` tool with the specific Account ID. It will return the sensitive account and routing numbers associated with that account.

**Is it possible to list transactions within a specific date range?**
Absolutely. The `list_transactions` tool allows you to provide `start_date` and `end_date` parameters (in ISO 8601 format) to filter your transaction history.

**Can I initiate a payment like Zelle through this integration?**
Yes. You can use `create_payee` to set up a destination and then `initiate_payment` to send funds using supported schemes like Zelle.