- Brand
- Kubera
- Category
- Finance
- Primary Subcategory
- Wealth & Portfolio Tracking Dashboards
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
- 32
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Agent Discoverability
ChatGPT Plugin Discovery ScoreYour score is coming
ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.
What discovery looks like
Get alerts for Kubera
Get updates when Kubera’s Discoverability Score or category rank changes.
Competing in ChatGPT Wealth & Portfolio Tracking Dashboards
View Category32 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 and its parent account's total is recalculated from the remaining holdings; for a top-level item, the account is archived. Archiving a manually-added parent account that has holdings (e.g. a manual brokerage) archives all of its holdings with it — pass the parent's id once; do NOT archive each holding separately. 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, and if the named sheet or section does not exist yet it is created for the item — so a new sheet/section can be made in the same call, without a separate create_sheet / create_section. When that happens the response carries `createdSheet` / `createdSection` with the new name: always tell the user a new sheet or section was created, since it changes how their portfolio is laid out. 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. The `ticker` field accepts only a value returned by get_ticker. The same symbol exists on several exchanges and as different instrument types, so get_ticker normally returns several matches and a guessed or assembled symbol creates the item against the wrong ticker. Keep `name` a short label and `description` a brief one-line summary; put any longer details, context or comments in `note`. `ownership` (percentage owned — the UI's "Portfolio Share"), `cmtdCap` (committed capital), a Value Adjustment (`adjValue`, e.g. carried interest) and, for an asset, its Asset Class (`assetClass`) and investable status (`investable`) may also be set at creation time. Pass `parentId` to create the item as a HOLDING inside an existing item (e.g. a stock inside a brokerage account) instead of as a standalone item — note this turns a plain parent into a manual account whose value becomes the sum of its holdings; see the `parentId` field description. 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
Step 1 of storing a file in Kubera. The file's bytes are never sent through this tool: it returns a one-time `uploadUrl`, and you then send the file to it yourself with an HTTP PUT of the raw bytes, e.g. run the returned `curl` command with the file's path. Use it only if you can run a shell command or a script that can read the file and reach the Kubera API. If you can't, don't call it, and don't try to paste the file's contents anywhere: tell the user to upload the file in the Kubera app. Two places a file can go: the portfolio's document vault (pass only `portfolioId`), or attached to one asset, debt or insurance item (pass the item's `ID` from get_default_portfolio / get_portfolio as `custodianId`; `portfolioId` can then be left out). A file for a holding of a connected account is attached to its parent account, as in the app. Pass the file's exact size in bytes as `sizeBytes` (e.g. `wc -c < file`); the upload is rejected if it sends more. At most 50 MB per file, less if the account's storage is nearly full. The URL works once and expires at `expiresAt` (15 minutes). The PUT's JSON response holds the stored file as `data.file` (id, name, fileType, size, portfolioId, custodianId), or `errorMessage` on failure; that id works with get_file. Uploading a file with an existing file's name adds a second file, it does not replace it. IMPORTANT: Confirm with the user which file goes where before calling this tool.
create_upload
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 — an item in a Debt or Insurance sheet is rejected. `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
Creates a fund schedule entry on an asset — a dated capital call or distribution — or updates the existing entry of that type on that date. IMPORTANT: this records a SCHEDULE, not a payment. It does not move money and does not affect IRR, returns, net worth or the item's value. If the user has actually paid a capital call or received a distribution, record that with create_or_update_cash_flow as well — a `capitalcall` corresponds to a `cashIn` and a `distribution` to a `cashOut` — because cash flow is what Kubera computes the return from. Writing it here only does not change any number the user sees. The KEY is the type AND the date together: an asset can hold one capital call and one distribution on the same date, so writing a distribution never disturbs a capital call on that date, and vice versa. If an entry of the same type already exists on that date it is UPDATED IN PLACE — `value` is REPLACED, not added to. Fields you omit keep their stored values. Use get_fund_schedule first to see what is already there. IMPORTANT: Always confirm with the user before calling this tool. Show them what will be changed and ask for explicit approval.
create_or_update_fund_schedule
Deletes a single cash flow entry from an asset, identified by its date. The date is the key — an asset holds at most one entry per date — so call get_cash_flow first and pass back a date it returned; a date with no entry is rejected and the error names the dates that do exist. Only one entry per call: there is no way to clear an asset's whole cash flow through this tool, and the user must do that in the Kubera app. The entry is removed permanently and cannot be restored through these tools, so treat it as final for this conversation. Kubera recomputes the asset's IRR from the entries that remain, so deleting one CHANGES the reported return — and deleting the last one leaves the asset with no cash-flow-based return at all. Say this to the user when the entry being removed is the only one. To correct a wrong amount, prefer create_or_update_cash_flow, which overwrites the entry for that date in place; delete is for an entry that should not exist at all. IMPORTANT: Always confirm with the user before calling this tool. Show them what will be deleted and ask for explicit approval.
delete_cash_flow
Deletes a single fund schedule entry from an asset, identified by its type AND date together. Because an asset can hold one capital call and one distribution on the same date, the type is what decides which of the two is removed — passing the wrong one deletes the wrong entry. Call get_fund_schedule first and pass back a type and date it returned; a combination with no entry is rejected, and the error names the entries that do exist. Only one entry per call: there is no way to clear an asset's whole schedule, or all of one type, through this tool — the user must do that in the Kubera app. The entry is removed permanently and cannot be restored through these tools, so treat it as final for this conversation. It changes no computed figure — the schedule feeds no IRR, return or net worth — so removing an entry loses the planned commitment record and nothing else. Any cash flow recorded for the same event is separate and is NOT removed by this; delete that with delete_cash_flow if the user wants it gone too. To correct a wrong amount, prefer create_or_update_fund_schedule, which overwrites the entry in place; delete is for an entry that should not exist at all. IMPORTANT: Always confirm with the user before calling this tool. Show them what will be deleted and ask for explicit approval.
delete_fund_schedule
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. Kubera's server provides every tool named in these tool descriptions (e.g. create_portfolio_item, update_portfolio_item). If one you need is not in your tool list, the user's MCP client has blocked it — its permission is set to Block in their connector settings. Tell the user which tool is blocked and that they can allow it in their connector settings for Kubera; don't say Kubera lacks the tool.
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 a download link for one file the user has stored in Kubera — a file in the portfolio's document vault or one attached to an asset, debt or insurance item. Take the file's id from the `ID` column of the Documents table in get_portfolio / get_default_portfolio. Returns the file's metadata (`file`: id, name, fileType, size) and a `downloadUrl` that downloads it; the contents themselves are not in the result. To read the file, fetch `downloadUrl` with your web-fetch or code tool when `fileType` is a format you can read — PDF, JPEG / PNG / GIF / WebP images, plain text, CSV or JSON — and answer from what you fetched. If you have no tool that can fetch it, or the format is one you can't read (e.g. spreadsheets, archives), give the user the link to open instead, and don't guess at contents you haven't read. The link stops working at `downloadUrlExpiresAt`, five minutes after the call, so fetch it straight away; calling get_file again gives a fresh one.
get_file
Returns an asset's fund schedule — its dated capital calls and distributions. A `capitalcall` entry is money the user is due to put in against a commitment; a `distribution` entry is money due back out. This is typically used for private equity, venture and other capital-commitment style holdings, alongside the item's committed capital (`cmtdCap`). IMPORTANT: these entries are a SCHEDULE, not money that has moved. Kubera does not use them to compute IRR, returns, net worth or the item's value — nothing in the schedule changes a single reported number. Actual money in and out is recorded separately as cash flow (get_cash_flow), and that is what drives IRR. An item can have both, and they will not agree if a call was scheduled but not yet paid. Each entry is keyed by its type AND date: an asset can hold one capital call and one distribution on the same date, but not two of the same type. An empty result just means none have been entered. Use get_default_portfolio or get_portfolio first to find the asset's id.
get_fund_schedule
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
Reads the recap report identified by a reportId from request_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`; call request_recap_report again. Report ids expire 20 minutes after they are issued.
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. Kubera's server provides every tool named in these tool descriptions (e.g. create_portfolio_item, update_portfolio_item). If one you need is not in your tool list, the user's MCP client has blocked it — its permission is set to Block in their connector settings. Tell the user which tool is blocked and that they can allow it in their connector settings for Kubera; don't say Kubera lacks the tool.
list_portfolios
Read-only. Retrieves Kubera Recap data for a portfolio — composition and performance over time (net worth trend, allocation by asset class, sheets & sections, stocks by sector/geography/market cap, crypto, brokerages, taxability, and more). Nothing in the user's account is created or changed: the numbers are derived from existing portfolio data and are not saved anywhere the user can see. Recap takes a few seconds to compute, so this returns a `reportId` and a `status`, NOT the data: read it with get_recap_report using that id until status is `completed`, waiting `pollIntervalMs` (2s) between calls. If `status` comes back as `in_progress` there is no reportId — a different Recap is still being computed for this user; wait `retryAfterMs` and call again. The same parameters always map to the same reportId and the computed result is cached for 20 minutes, so calling again is cheap and does not recompute. Use get_default_portfolio / list_portfolios first to get a portfolioId.
request_recap_report
Switches the user's active portfolio — the one get_default_portfolio returns. 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. Non-destructive and fully reversible: it changes one preference — which portfolio is treated as active — and never touches portfolio data. No item, value, sheet, section or history is modified, and no portfolio is deleted, hidden or changed. To undo it, call it again with the previous portfolioId; nothing is lost in between. The choice is remembered, so the next session starts on the same portfolio. 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, note, value, ticker, cost, ownership percentage (the UI's "Portfolio Share"), committed capital, Value Adjustment (`adjValue`, e.g. carried interest), and for an asset its Asset Class (`assetClass`) and investable status (`investable`, incl. marking a home as the primary residence). Keep `name` a short label and `description` a brief one-line summary; put any longer details, context or comments in `note` — see the field descriptions. 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. To move an item onto a different ticker (e.g. it was created against the wrong exchange listing), pass `ticker` — verify the intended one with get_ticker first (compare `market`/`code`, `type`/`subType` and `currency`). Only a manually managed item's ticker can be changed; a connected account's, or an account with holdings, is rejected. 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
Recommended guideHow to get your ChatGPT Plugin suggestedFollow the practical steps agents use to find, shortlist, and choose your Plugin.Read guideKubera ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Kubera's ChatGPT Plugin 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-11-02, Kubera competes with Antevo Wealth, Bitpanda, CoinTracker, De Belegger, ether.fi, Finary, Finnce, HealthMoney and 12 more 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.