Pluggy AI - Demo Notebook

Mix.install([
  {:pluggy_ai, path: Path.join(__DIR__, "..")},
  {:kino, "~> 0.14"},
])

Configuration

Enter your Pluggy API credentials below.

client_id_input = Kino.Input.text("Client ID")
client_secret_input = Kino.Input.text("Client Secret", type: :password)

Kino.Layout.grid([client_id_input, client_secret_input], columns: 2)

Create Client

This authenticates with the Pluggy API eagerly — if your credentials are wrong, you'll get an error here.

client_id = Kino.Input.read(client_id_input)
client_secret = Kino.Input.read(client_secret_input)

{:ok, client} = Pluggy.Client.new(client_id, client_secret)

List Connectors

Fetch available connectors and display a simplified view.

{:ok, %{results: connectors}} = Pluggy.Connectors.list(client)

connectors_simplified =
  for %{name: name, id: id, products: products} <- connectors do
    %{name: name, id: id, products: products}
  end
  |> Enum.sort_by(& &1.name)

Kino.DataTable.new(connectors_simplified)

Pluggy Connect Widget

Render the Pluggy Connect widget inline. Select a bank and complete the connection flow.

You can pass a :client directly — the widget generates the token for you:

widget = Pluggy.Connect.Kino.new(client, include_sandbox: true)

Connected Item

After completing the connection above, run this cell to retrieve the item data.

item = Pluggy.Connect.Kino.await_item(widget)

Accounts

Fetch the accounts for the connected item.

accounts = Pluggy.Accounts.list(client, item) |> Pluggy.Unwrap.results()
Kino.DataTable.new(accounts)

Transactions

Pass an account map directly — no need to extract the ID manually.

transactions_map =
  for account <- accounts, into: %{} do
    transactions = Pluggy.Transactions.list(client, account) |> Pluggy.Unwrap.results()
    {account.type, transactions}
  end

for {type, transactions} <- transactions_map do
  %{name: String.capitalize(type), transaction_count: length(transactions)}
end
|> Kino.DataTable.new()

transaction_select =
  transactions_map
  |> Enum.map(fn {key, _v} = option -> {option, String.capitalize(key)} end)

type_select = Kino.Input.select("Transaction type:", transaction_select)

{account_type, transactions} =
  type_select
  |> Kino.Input.read()

Kino.DataTable.new(
  transactions,
  name: "\'#{String.capitalize(account_type)}\' transactions"
)

Investments

Fetch investments for the item, then pass an investment map to get its transactions.

investments = Pluggy.Investments.list(client, item) |> Pluggy.Unwrap.results()
Kino.DataTable.new(investments)

investment = hd(investments)
inv_transactions = Pluggy.Investments.transactions(client, investment) |> Pluggy.Unwrap.results()
Kino.DataTable.new(inv_transactions)