Kubera
Track net worth & spot trends
- Category
- Finance
- Primary Subcategory
- Wealth & Portfolio Tracking Dashboards
View in the ChatGPT registry↗Integration details
Description
Ask questions about your Kubera portfolio. Connect your Kubera account to access your live balance sheet data, including net worth, assets, liabilities, and allocation. The assistant uses this data to answer questions, surface patterns, and explain what’s in your portfolio. Example questions: - What is my current net worth? - What stands out in my balance sheet? - Where am I overly concentrated? - Summarize my assets, liabilities, and entities - What questions should I ask my advisor? - Update my Tesla shares to 100 units Kubera is the Balance Sheet for those who manage their own wealth. https://www.kubera.com/
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Wealth & Portfolio Tracking Dashboards
- Secondary Subcategories
- None listed
- Brand
- Kubera
- Access
- Account required
- First tracked
- 2026-08-13
- Tool count
- 25
- Geography
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Get alerts for Kubera
Get updates when Kubera’s Discoverability Score or category rank changes.
ChatGPT Plugin Discovery Score
ChatGPT Plugin discovery is coming soon
ChatGPT can surface a Plugin when it matches a user's request.Your Plugin Discovery Score measures how often yours appears.
No spam. Unsubscribe any time.
What discovery looks like
Competing in ChatGPT Wealth & Portfolio Tracking Dashboards
View Category25 tools agents can invoke
Archives a single portfolio item (asset/debt) by id. Depending on the item's history, this either deletes the item outright (if it has no meaningful history — e.g. it was just added today) or archives it while preserving its past values. For a holding, the holding's value is zeroed out; for a top-level item, the account is archived. Only manually-added items can be archived — connected/linked accounts (bank, brokerage, crypto, etc.) cannot be archived through this tool and will be rejected. Use get_default_portfolio / get_portfolio first to find the item's id. IMPORTANT: Always confirm with the user before calling this tool. Show them what will be archived and ask for explicit approval.
archive_portfolio_item
Archives a section and every item in it. This is what the Kubera app's own delete-section action does: the section stops appearing in the portfolio and stops counting towards net worth, while the past values of its items are preserved so historical net worth stays correct. It can only be undone from the Kubera app, not through these tools, so treat it as final for this conversation. Get the `sectionId` from get_portfolio's `## Portfolio Structure` table, and check its `Items` count there first so the user knows how much goes with it. To archive a single item instead, use archive_portfolio_item. CRITICAL: Always confirm with the user before calling this tool. Name the section, say how many items are being archived with it, and require an explicit yes.
archive_section
Archives a sheet and everything under it — all of its sections and all of the items in them. This is what the Kubera app's own delete-sheet action does: the sheet stops appearing in the portfolio and stops counting towards net worth, while the past values of its items are preserved so historical net worth stays correct. It can only be undone from the Kubera app, not through these tools, so treat it as final for this conversation. Get the `sheetId` from get_portfolio's `## Portfolio Structure` table, and check the `Items` counts there first so the user knows how much goes with it. CRITICAL: Always confirm with the user before calling this tool. Name the sheet, say how many sections and items are being archived with it, and require an explicit yes.
archive_sheet
Creates a new, empty portfolio on the user's Kubera account. It comes pre-seeded with Kubera's default sheets and sections (Investments, Real Estate, Others, Credit Cards, Loans, …), so there is no need to create those afterwards — call get_portfolio on the new portfolio to see what it already has before adding anything. This does NOT switch the user to the new portfolio; use set_default_portfolio for that. Only works on the user's own account: a white-label advisor cannot create a portfolio for a client through this tool, and a family member cannot create one inside the account shared with them. The user's plan caps how many portfolios they may have, so this can be rejected with a limit error. IMPORTANT: Always confirm with the user before calling this tool. Show them the name and currency and ask for explicit approval.
create_portfolio
Creates a new manual portfolio item (asset or debt) in a portfolio. By default the item is added to the portfolio's first Asset section, or its first Debt section when `isDebt` is true. To target a specific location, pass `sheetName` and/or `sectionName`; if they match an existing section it is used, otherwise it falls back to the default section. CRITICAL — like update_portfolio_item, the `value` field is overloaded: when a `ticker` is given (a ticker-backed holding such as a stock, ETF, fund, crypto or precious metal) `value` is the QUANTITY held (number of shares/units), NOT the market value in currency; Kubera derives market value as quantity × price. For a plain cash / manually-valued item (a `currency`, or no ticker/currency) `value` is the monetary amount. If neither `ticker` nor `currency` is given, the portfolio currency is used as the item currency. IMPORTANT: Always confirm with the user before calling this tool. Show them what will be created and ask for explicit approval.
create_portfolio_item
Creates a new section inside a sheet. A section is the group that actually holds assets and debts, so a sheet needs at least one before anything can be added to it. The section inherits its sheet's category (Asset, Debt or Insurance). When a user asks to create a section without specifying which sheet or category, assume they mean an Asset sheet — ask which Asset sheet to add it to, don't default to Debt or Insurance. Only treat it as Insurance if the user is explicit about it (e.g. they name the Insurance sheet or say 'insurance'), since Insurance is a single fixed sheet holding information for an emergency contact, not asset/debt data. Check get_portfolio's `## Portfolio Structure` table first — it lists every existing section including empty ones, so a suitable section may already exist. Once created, put items into it by passing the sheet and section NAMES to create_portfolio_item's `sheetName` / `sectionName`. IMPORTANT: Always confirm with the user before calling this tool. Show them the section name and which sheet it goes in.
create_section
Creates a new sheet in a portfolio. A sheet is a top-level tab that holds sections, and sections hold the assets and debts. A sheet belongs to exactly one category — Asset or Debt — and can only ever hold items of that category, so pick it deliberately; it is the one thing a sheet cannot sensibly be changed to later once it has items in it. This tool cannot create an Insurance sheet: Insurance is a separate, fixed, single sheet per portfolio (not asset/net-worth data, but information the user saves to pass on to an emergency contact) — the user can't have more than one, and can only add sections to the existing one via create_section, never a new Insurance sheet via this tool. A new sheet is created with one empty section ("Section 1"), so items can go into it right away; use create_section only for extra sections. Check get_portfolio's `## Portfolio Structure` table first: it lists every existing sheet, including empty ones, so an appropriate sheet may already exist. IMPORTANT: Always confirm with the user before calling this tool. Show them the sheet name and category and ask for explicit approval.
create_sheet
Creates a new cash flow entry for an asset, or updates the existing one if an entry already exists for the same date. Cash flow applies to assets only, not debts. `cashIn` is any money spent on the asset — buys/purchase cost, contributions, maintenance, loan interest paid. `cashOut` is any money received from the asset — sells, dividends, distributions, withdrawals, rental income. Only pass the field that applies for a given date — leave the other omitted rather than passing 0 when there's no cash-in or cash-out that day. If there are multiple transactions on the same date (e.g. two buys), combine them into a single entry with the summed amount, and use `note` to record the breakdown briefly — the individual buys/sells and their quantities, not a long explanation. Keep `note` short and factual (e.g. 'Buy 5', 'Sell 12', 'Dividend', 'Distribution') — don't pad it with unnecessary detail. Kubera uses these entries plus the asset's current value to compute IRR, so accuracy matters: for a mortgaged property, `cashIn` on the purchase date should be the full purchase price (down payment + loan amount), not just the down payment — and ongoing loan payments should only be logged as `cashIn` for their interest portion, not the principal, since principal repayment isn't a real expense. Log the mortgage balance itself as a separate debt item, not as `cashIn` here. The earliest entry in an asset's cash flow must be a `cashIn` (an investment has to start with money going in before anything can come out) — Kubera doesn't block a cashOut-first entry when adding it, but the UI shows an error and IRR can't be calculated until it's fixed, so flag this to the user if you see or after creating a `cashOut` as the earliest date. Use get_cash_flow to see existing entries before adding new ones. Cost basis and cash flow are two alternative ways to calculate returns — an asset needs one or the other, not both. Once an asset has cash flow entries, don't also suggest or set a cost basis for it; IRR is already calculated from the cash flow alone. IMPORTANT: Always confirm with the user before calling this tool. Show them what will be changed and ask for explicit approval.
create_or_update_cash_flow
Returns the user's active portfolio data optimized for LLM consumption as Markdown. Also returns an 'otherPortfolios' array listing the user's remaining portfolios (each with id, n=name, t=currency, and c=client/owner name when the portfolio belongs to an advisor's client or is shared by a family owner — use c to group portfolios by client/owner), so the full set of portfolios is available here. For a complete, explicit list of all portfolios with the active one flagged, use list_portfolios.
get_default_portfolio
Returns the cash flow entries recorded for a specific asset — the money the user put into it (`cashIn`: any money spent on the asset, e.g. purchase/buy, contributions, maintenance, loan interest paid) and money the user got out of it (`cashOut`: any money received from the asset, e.g. sells, dividends, distributions, withdrawals, rental income). Each entry has a date and currency (entries can be in different currencies or crypto across the same asset). Cash flow is optional — the user may not have entered any, so an empty result doesn't mean the asset is inactive. The earliest entry should always be a `cashIn` (money has to go in before anything can come out); if the earliest entry is a `cashOut` instead, the data is incomplete — Kubera's IRR calculation and its UI both flag this as an error, so point it out to the user rather than treating it as valid. When cash flow exists, it helps explain a value change: a jump in value may be from new money going in (a buy or contribution) rather than market gains, and a drop may be from money being withdrawn (a sell) rather than a loss — check the cash flow before attributing a value change purely to performance. Kubera also uses this cash flow, together with the asset's current value, to compute IRR (a money-weighted rate of return) — this is the recommended way to track returns when the cost basis is hard to pin down (e.g. contributions made over time, or a property with ongoing costs and rental income), rather than requiring a single cost-basis figure. Use create_or_update_cash_flow to add or edit entries. Use get_default_portfolio or get_portfolio first to find the asset's id.
get_cash_flow
Returns the value history for a single portfolio item (asset/debt), optimized for LLM consumption — mirrors get_portfolio_history but for one item. Returns `itemDataPoints`, an array of { date, value } points (value in the portfolio's currency) as one continuous series; the value is carried forward on dates without an explicit edit, so there are no gaps between entries. Use get_default_portfolio / get_portfolio first to find an item's id.
get_item_history
Returns a specific portfolio's data by ID as Markdown. The header line includes Start Date — the user-configured date from which the portfolio's numbers are considered official (used to anchor All Time CAGR and to exclude early test/placeholder data); it's omitted if the user hasn't set one. Use list_portfolios or get_default_portfolio first to see available portfolios. Reads only — the active portfolio is unchanged by this call and is set by set_default_portfolio.
get_portfolio
Returns a specific portfolio's CAGR (Compound Annual Growth Rate) by ID — the annualized rate of growth from the portfolio's start date to today, smoothing out the ups and downs in between. Returns two separate CAGR values: one for net worth and one for investable assets, each as a plain percentage number (e.g. 12.5 means 12.5%). Four periods are returned per value — YTD, QTD, trailing 1-year, and all-time. Periods under 1 year (YTD, QTD) are simple percentage growth over that period, not annualized; periods over 1 year (trailing 1-year, all-time) are annualized. The response includes portfolioStartDate, the user-configured date the 'all-time' CAGR is measured from (this may be later than when the portfolio was first created, if the user excluded early test data). Use list_portfolios or get_default_portfolio first to see available portfolios.
get_portfolio_cagr
Returns a specific portfolio's historical value snapshots by ID. Each entry includes the date, net worth (`value`), investable assets total (`investibleTotal`), gross assets before debt (`assetTotal`), and total liabilities (`debtTotal`) — so assetTotal minus debtTotal equals value. Snapshot frequency is not uniform: older history is typically monthly, more recent months are weekly, and the last ~30 days are daily, becoming denser closer to today. The response includes portfolioStartDate — the user-configurable date from which the portfolio's numbers are considered official; data points before this date may reflect test or placeholder entries the user hasn't cleaned up, so treat them with caution or filter them out when computing trends. Use list_portfolios or get_default_portfolio first to see available portfolios.
get_portfolio_history
Returns the user's profile: name, IANA timezone (tz), UTC offset in minutes (utcOffset), and date of birth. Use tz for scheduling or date-relative logic where possible, since utcOffset does not reflect daylight saving changes. dateOfBirth supports age-based calculations (e.g. Fast Forward scenario rules that target a specific age).
get_profile
Fetches a recap report previously started with submit_recap_report. While `status` is `pending` or `processing` the report is still being computed — wait ~2 seconds and call again. When `status` is `completed` the response carries `params` (the resolved request) and `results`: one entry per report × time range, each with `timeRange`, `report`, `currency`, `valueType` (`number` or `percentage`) and `rows`. A row is { label, dataPoints, children? } where dataPoints are { date, value } ordered oldest → newest; leaf rows also carry `itemId`, joinable to get_item_history / update_portfolio_item. A `failed` status carries an `error`; submit again. Report ids expire 20 minutes after submission.
get_recap_report
Returns the current server status, time, and the version of Kubera's MCP surface. Quote `version` when reporting a problem with a Kubera tool, so the behaviour can be matched to the deployed build.
get_server_status
Looks up Kubera tickers by name or symbol and returns the matches, so a stock, ETF, fund, crypto, currency or precious metal can be resolved to the exact ticker Kubera knows. It is the source of the `ticker` value create_portfolio_item takes for a ticker-backed item, where `value` is then a QUANTITY of that ticker; a symbol that has not been resolved here is how a holding ends up against the wrong ticker. Returns an ARRAY of matches, each with: `ticker` (the short name create_portfolio_item takes), `name` (full name), `type` (e.g. stock, fund, crypto, fiat) and `subType`, `code` (exchange code), `market` (the exchange), `currency` the ticker is priced in, `countryCode`, and `id` (Kubera's internal ticker id). This is reference information only — it carries NO price, quote or exchange rate, and cannot value a holding or quote a market price. A lookup usually returns SEVERAL matches, including for an exact symbol: the same name or symbol is listed on multiple exchanges and as different instrument types, so the first row is not necessarily the intended one. The fields that separate them are `type` / `subType` (a stock vs an ETF/fund vs crypto vs a fiat currency vs a precious metal), `market` / `code` / `countryCode` (the exchange it is held on) and `currency` (what it is priced in); where the request leaves those undetermined, the portfolio's country and currency and the user's other holdings indicate which listing is meant — a US portfolio naming a US-listed company means the US listing, not a foreign cross-listing or a same-symbol company elsewhere. Matches come back best-first and are capped at 10, so a refined name returns a better set than a broader one. A name Kubera does not carry returns an empty array — a normal result meaning no match for that spelling, not a failure.
get_ticker
Returns a specific portfolio's biggest asset and debt movers over the last 1 day and the last 1 month, by ID. Each mover has `name`, `currentValue` (its latest value), `value` (the change amount over that period — not a running total; can be negative), and `cids` (one or more custodian IDs rolled into this row, e.g. multiple wallets shown together as 'Bitcoin'). `assetChangeTotal`/`assetTotal` and `debtChangeTotal`/`debtTotal` give the totals across all assets/debts, not just the top 10 shown. Use list_portfolios or get_default_portfolio first to see available portfolios.
get_top_movers
Returns the full list of the user's portfolios with id, name, currency, which one is active (the `isDefault` flag), and clientName (present when the portfolio belongs to an advisor's client or is shared by a family owner — use it to group portfolios by client/owner). Use this to discover all portfolios before fetching a specific one with get_portfolio. Reads only — which portfolio is active is unchanged by this call and is set by set_default_portfolio.
list_portfolios
Marks a specific portfolio as the user's active portfolio — the one returned by get_default_portfolio. This is what switching portfolio consists of: a user who selects, switches or changes to a portfolio is asking for this call, and it is the whole of that request. It changes a single preference and no portfolio data: the active portfolio is stored on the user's Kubera account and persists across sessions, applying wherever they use Kubera, and calling this again with a different portfolioId fully replaces it. Use list_portfolios or get_default_portfolio first to see available portfolios and their IDs.
set_default_portfolio
Renames a portfolio and/or changes its reporting currency. This is the portfolio ITSELF — to change an asset or debt inside it, use update_portfolio_item. CAUTION on `currency`: it is the currency every value in the portfolio is reported in, not a per-item currency. Changing it re-denominates the whole portfolio and makes Kubera recompute returns and rebuild its charts, which takes a while to settle — only change it when the user explicitly asks to change the portfolio's reporting currency, never as a way to record an item held in another currency. Pass at least one of `name` or `currency`. IMPORTANT: Always confirm with the user before calling this tool. Show them what will change and ask for explicit approval.
update_portfolio
Update a specific portfolio item (asset/debt): name, description, value, cost, ownership percentage (the UI's "Portfolio Share"), committed capital. CRITICAL — the `value` field is overloaded: for ticker-backed holdings (stocks, ETFs, mutual funds, crypto, precious metals, private/pre-IPO stock) `value` is the QUANTITY held (number of shares/units), NOT the market value in currency; Kubera derives market value as quantity × current price. For plain cash and manually-valued items (no ticker) `value` is the monetary amount. Read the item first (get_portfolio / get_default_portfolio) and check its `Quantity` column to know which applies — see the `value` field description. This tool cannot set or change an item's ticker: there is no `ticker` field, and the holding's ticker stays as created. If the item is against the wrong ticker, verify the intended one with get_ticker (compare `market`/`code`, `type`/`subType` and `currency`) and create the holding with create_portfolio_item using that exact ticker. IMPORTANT: Always confirm with the user before calling this tool. Show them what will be changed and ask for explicit approval.
update_portfolio_item
Renames a section, reorders it, collapses/expands it, or moves it to another sheet — the items in it move with it. Get the `sectionId` from get_portfolio's `## Portfolio Structure` table. Pass at least one field to change; anything omitted is left as it is. Common reasons to move a section: reorganizing within Assets (moving it to a different Asset sheet), or moving it between Asset and Debt sheets — the latter changes whether its items count towards net worth as owned or owed, so confirm that's intended before doing it. IMPORTANT: Always confirm with the user before calling this tool. Show them what will change and ask for explicit approval.
update_section
Renames a sheet, reorders it, or changes its update-reminder frequency or category. Get the `sheetId` from get_portfolio's `## Portfolio Structure` table. Pass at least one field to change; anything omitted is left as it is. Changing `category` moves the whole sheet between the Assets, Debts and Insurance side of the portfolio along with everything in it, which flips whether those items count towards net worth as owned or owed — Insurance items don't count towards net worth at all, since Insurance holds information for an emergency contact, not asset/debt data. Note the Insurance sheet is a fixed, single sheet per portfolio that already exists and cannot be created (see create_sheet) — this field lets you move a sheet INTO the Insurance category but there's normally no reason to, since Insurance content is meant to live in the one existing Insurance sheet, not a converted one. A sheet cannot be moved to a different portfolio through this tool. IMPORTANT: Always confirm with the user before calling this tool. Show them what will change and ask for explicit approval.
update_sheet
How do I improve a ChatGPT Plugin's discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Kubera alternatives on ChatGPT?
As of 2026-09-29, Kubera competes with Findash, HealthMoney, IBI, Parqet, Portfolio Dividend Tracker, WealthCheck Financial Planner, wlthy, マネックス証券 in ChatGPT Wealth & Portfolio Tracking Dashboards, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.