Documentation

Privacy & your data

Guest portfolios use a temporary hosted session plus a backup in your browser. Signed-in portfolios are stored under your hosted account. Desktop portfolios are stored on your disk; market-data and public-data requests send ticker symbols, and cloud AI, tax calculations, optional sharing and hosted synchronization send the data described below. The desktop MCP bridge requires that hosted synchronization.

At a glance

The short version — what the How your data is handled link on the app's first screen (and in its Get started card) shows. Each point is explained in full further down.

Using the app as a guest

The Free dashboard works without an account. Guests can import holdings, use portfolio analytics, backtest a trade plan and use the in-app assistant within Free limits: 3 accounts and 50 assets. Social requires a signed-in account; Taxes, external-agent MCP access and investor-group analytics require Pro. See the Free plan boundaries.

As a guest on the hosted app, your data lives in two places:

Practically, that means:

What creating an account changes

An optional email + password account (the Account tab in ⚙ Settings, hosted app only) moves the durable copy of your data to the server:

Starting as a guest, signing up later

You lose nothing by trying the app first: your first sign-in from a browser claims what you built there as a guest.

The story in order:

  1. You open the app as a guest, upload your exports, star favourites, tune settings.
  2. Later you create an account (or sign in for the first time) from that same browser. If the account is still empty and your guest session has data, everything the guest session owns — sources with their transactions, settings, API keys, manual assets, favourites — is moved to the account in one step, all-or-nothing.
  3. Any other device you sign in on now sees the same portfolio, served from the server.

Two edges worth knowing, exactly as implemented:

API keys

On the hosted app, LLM API keys entered in Settings are encrypted at rest on the server and are never stored in the browser — not in localStorage, not in the IndexedDB backup. They belong to your session or account and are wiped with it. If you run the app yourself, keys can also come from the server's own .env or environment (OPENAI_API_KEY / OPENROUTER_API_KEY) — and only then. The hosted app deliberately ignores both, so no session can ever end up spending a key it was not given.

And if you'd rather not send portfolio context to any cloud model: use the desktop app with Ollama or LM Studio. Assistant inference then stays on your computer; the other outbound services below remain separate choices.

What reaches an LLM provider

Ordinary dashboard calculations do not need an LLM. Import parsing, portfolio values, charts, performance, risk and allocation are computed by the portfolio engine. Enabled assistant features — including reports, AI insights, smart search and proactive comments — can call the selected model without a newly typed chat question. Their relevant context follows the provider choice below.

Out of the box, the hosted app answers on our key. So that you are not sent off to obtain an API key before you can try anything, a new session starts on a small free budget against the deployment's own OpenAI key, on gpt-5.6-luna. Be clear about what that means: those calls reach OpenAI exactly like any other — the only difference is whose key pays for them. A quiet donut beside the chat shows how much of the budget is left, and when it runs out the assistant stops rather than quietly falling back to anything else. Enter your own key in ⚙ Settings → Assistant and it takes over at once and is never metered; use a local model on desktop to keep that model request on your computer. The desktop app has no free budget — it starts on a local model. So that the free budget cannot be farmed by opening session after session, the server records the address a free budget was started from — never the IP address itself, only a keyed hash of it (an HMAC under a secret key held on the server: without that key the stored value cannot be turned back into the address) — with the budget, and a per-day count of how many budgets each hashed address started. It is used only to recognise the same address again. These records are not currently deleted on a schedule.

Whichever of those you are on, using an assistant feature (chat, the one-click reports, AI insights, smart search) sends your question plus the portfolio context the answer needs — holdings with weights and values, performance and risk figures, recent trades, your strategy text, and what's currently on your screen — to the provider behind the model you picked (OpenAI, Anthropic or OpenRouter for cloud models), under your key or, on the free budget, under ours. Your imported raw CSV files are not automatically sent as portfolio context. Attachments you deliberately send in chat are shared with the selected provider; a connected external agent can also access authorized attachments and Assistant context, as described below. What those providers do with request data is governed by their terms, which is exactly why the choice of provider — including a local one — is yours.

Screenshots and PDF statements you import with AI. A screenshot or PDF dropped on an import area is sent to a model only when you press Read with AI in the dialog that opens, and the dialog says first which provider and model will read it and on whose key — or that a local model reads it on your computer. What the model receives is the PDF’s extracted text, or the image (downscaled to 2048 px; a scanned PDF’s first eight page images) — with whatever is on it: account numbers, your name, balances. Crop or cover what you would rather not share before dropping it. The file is kept only for that one request — in memory, or for a file over 1 MB in a temporary file on the server that is deleted when the request ends — and is never saved to the database or kept afterwards; nothing is stored unless you press Import, and then only the rows you kept in the review table (instrument, date, quantity, price, fees, currency) as an account — never the image, the PDF or its text. That account is deleted like any other (remove it in ⚙ Settings → Data, or delete your account). The request counts against the free budget like any assistant feature, and the Admin statistics count that an import happened and from which platform — never what was in it.

The desktop app

The native desktop app runs the portfolio engine on your computer and stores its data locally. Market-data requests, public-data lookups, cloud AI and opt-in Social sharing have the boundaries described below. Pro users of the desktop app can also choose One synchronized portfolio in Settings → Assistant → External agents. This copies portfolio inputs to the hosted account and keeps web and desktop synchronized while the app is running; it is required for the desktop external-agent bridge. Review both datasets and choose which to keep before synchronization starts. Replaced inputs are backed up and conflicting edits pause sync for review.

Where your data lives

Everything the app knows sits in its own data folder on your disk: a SQLite database with your transactions, sources, settings, manual assets and favourites; the local encryption key protecting any API keys you enter; and the market-data caches. On macOS that folder is ~/Library/Application Support/Fortunest, on Windows %APPDATA%\Fortunest. Back it up and you've backed up the app; deleting it removes the local copy. If you enabled hosted synchronization, Social sharing or made a backup, those copies are separate.

What leaves your machine, and why

What works offline

Essentially all of it: the dashboard, performance, allocation, risk, dividends, correlations, simulations, trade recommendations, Explore, and the assistant on a local model. Price history is cached for a day; when the network is away the app simply keeps serving the last cached prices (and quietly retries in the background), so charts show the world as of your last online session. An offline session cannot fetch fresh market data or price a symbol it has never fetched before — so a fresh install wants one online session to warm its cache, and after that cached analysis remains available. Cloud AI, Social, hosted synchronization/MCP and Pro tax calculations need connectivity. For a mode-by-mode comparison and a local-model check, see the private portfolio tracker guide.

Offline mode makes it a choice, not an accident. In the desktop apps (Mac since 0.2.6, Windows since 0.2.7), the Online / Offline switch in the desktop app’s top bar (also in ⚙ Settings → General) blocks the outside services the app contacts on its own — all of them, plus any other internet host, or just the ones you pick, such as the logo services, SEC EDGAR, FRED and cloud AI while Fortunest prices keep updating. The app refuses each connection to a blocked service before it is made — in its backend and in its window, judged by the address the request is going to, so a proxy does not change the answer — and only this computer (the app and a local AI model) stays reachable. One limit: when a market-data request that is allowed is redirected by the server it went to, the redirect is followed without a second check. Its panel lists each service as allowed or blocked and counts the connections it refused.

External agents & your permissions — Pro

Connecting Codex, Claude Code or another MCP client gives that named client the permissions you approve at Fortunest sign-in. Authorized reads can include portfolio figures and Assistant context: conversations, attachments, notes, memories, skills and reports. Your chosen agent provider receives this information under its own terms. Fortunest provider API keys and login credentials are never exposed to the agent.

Connection consent sets the client’s permissions; ordinary authorized reads do not require a new approval for each call. Sensitive changes need action approval unless an active permission already covers them. Approve once, reject, allow matching bounded actions, or allow all actions within this connection’s existing permissions for 1 hour or 8 hours. Review activity and revoke connections or permissions in Settings → Assistant → External agents. Desktop-agent approvals and Undo are reviewed in the hosted app. Completed action details and Undo are retained for seven days, with minimal status history for 90 days. Interrupted actions require review instead of being retried automatically. See the connection guide and approval details.

The demo endpoint. https://app.fortunest.ai/mcp/demo lets anyone connect an agent to the shared demo portfolio without an account. It has no sign-in, sets no cookie, starts no app session and reads nothing of yours — only the synthetic demo data. No record is kept per call — no agent activity, no IP address — beyond the server diagnostics of a call that fails. To throttle abuse the server holds the caller’s address (for IPv6, its /64 network) in memory for about a minute after its last request and then forgets it, and it counts requests by method, tool name and outcome (fixed categories, no address or client name) in its operational metrics. What you ask goes to your own agent’s provider under its terms; Fortunest runs no AI model for the demo.

Where agent connections come from, counted per day. The server keeps a per-day count of agent connections and tool calls (since 10 November 2026). For the demo endpoint each row is the UTC day, the directory the address was copied from — the ?src= word a listing adds to it (for example ?src=smithery), one of a fixed list, otherwise direct or other — and the name the agent app gives itself when it connects (such as claude-ai), shortened to a plain word; nothing else. For a signed-in Pro connection it is the day and the name of the app you approved, counting new connections, the days a connection is used and its tool calls. No IP address, no account, no connection id and nothing you ask are part of it; a tester’s or the operator’s own Pro connections are counted apart. Only the operator sees these counts, and each day’s rows are deleted after 400 days. The ?src= word changes nothing about what the endpoint answers, and the server’s access log records the demo address without it.

Social & friends

Group portfolios keep the current relative snapshot and three previous publications. Current sharing toggles and friendship/block grants apply to all four at read time. Delete shared data and account deletion remove the history. Own comparison weights stay on your device.

The Social tab is the one place data of yours can become visible to other people — and only ever the people you approved (or, if you create a public link, whoever you give that link to), only ever the sections you ticked, and only ever relative figures. The rules, exactly as built:

Usage analytics & feedback

Recovering a failed app download. If a tab cannot download part of the app, including Safari’s module-loading failure, it can reload once in five minutes to fetch the current version. A later failure can recover again after that pause. This uses one timestamp in the tab’s session storage. If that storage is blocked or recovery has already been attempted, the original error remains visible; you can reload the page through your browser. Chart range strips also defer resize measurements to the next frame and discard pending work when closed. Expected animation cancellations, including a viewport-size change while the animation is preparing, are handled without an error alert. A failed page update or unexpected animation failure still reports, even if its message resembles a cancellation. Repeated browser notices are grouped together, while genuine page failures remain visible to the operator.

The hosted app records anonymous, cookieless usage events (which features are used, how large portfolios are as counts). Only generic values travel — never file names, tickers, amounts, queries, chat or strategy text, or emails. The same anonymous counts are mirrored into cookieless Umami page analytics; this website uses the same cookieless Umami counter and no analytics of any other kind. The only cookies this website ever reads are the pd_signedin marker described above — set by the app when you sign in, deleted when you sign out, carrying the character 1 and nothing else — used for one thing: deciding whether the header should show your avatar; and, for testers only, the pd_tester marker below, which stops the visit beacon and the Umami counter. It is never sent anywhere, and if you have no account you have no cookie from us at all. That includes the pages that ask the app something — the header’s account button, the prices in the pricing section and this site’s account page: reading them, signed out, never starts an app session and sets no cookie. The app’s anonymous session cookie is set only once you open the app itself (or when you sign in, which sets the login cookie described above).

Which days an account is used. Besides the time your account was last used, the server keeps one record per account for each UTC day it signs in or uses a signed-in session — split into the web (the website and the hosted app) and the desktop app (a request with its licence), with how many sign-ins there were that day and whether you interacted that day (since 21 October 2026): after the first time each UTC day you press, type, touch or scroll with a wheel in the app, it sends the server one request with no content, which sets that one yes-or-no on the day’s record — so a tab left open overnight is told apart from a day you used the app. The desktop app (builds after 0.2.6) forwards that request with its licence when you are signed in, and not in Offline mode. Nothing about what you pressed, where or when is sent or kept, and a browser opted out with ?notrack sends nothing. The record is keyed by a pseudonymous id derived from your account number with the server’s secret, never your email; it holds no IP address, no browser details and no page. It feeds only the operator’s count of signed-in accounts per day, testers left out, and is deleted after 90 days and with the account.

Campaign events in Umami. Beside page views, Umami counts a few steps of the way in, so the operator can see which links and campaigns bring people who actually try the app. Umami stays cookieless: these events set no cookie and store nothing in your browser, with two exceptions described in the table: the homepage strip for visitors sent by an AI assistant remembers its ✕ and that it was shown this visit (two flags), and the demo’s introduction card remembers that a link asked for it and when it ended (one value). Each carries only the categorical values in the table — never your email, a name, an amount, a holding or anything typed into the app. Campaign tags in a link you arrived by (utm_source, utm_campaign and the like) are read by Umami from the page address, as for any page view. A one-time code in a link — a password-reset or email-confirmation link, or the hand-off that finishes two-step verification — is taken off the address before Umami reads it, and is removed again from anything Umami sends, so it never reaches Umami. The steps that carry your first touch (below) repeat four of them — all but utm_term — on the address they report, so a campaign’s count still includes a step taken after a reload. Umami also reads the Google Ads click id (gclid) on the one page an ad opened, website or app, since Google puts it in that address. That page then takes it off the address bar, and the website carries it on only into the app and to its account page (below), so Umami does not see it again on later pages. The same ?notrack opt-out silences these events too, and the desktop app sends none.

EventData sentWhen
open-appplace (nav, hero, guide-cta, explore-guide, changelog-cta, ai-strip, footer…), page (this website's page path)A link on this website into the app is clicked.
download-desktopos (mac or windows)A desktop installer download is clicked.
get-proplace (pricing, banner, limit or trial)A Get Pro is clicked: the pricing section's button on this website (pricing); in the app, See plans on the one-time founding-offer notice (banner), Get Pro in a message saying a free-plan limit was reached (limit), or Keep Pro on the notice counting down a Pro trial (trial).
signupmethod (email, google or apple)A new account is created — once per account.
demo-startnone, or via: link"Explore the demo" loads the demo portfolio — or a link with ?demo=1 (the site’s “Open app” buttons on the guides) loaded it for a visitor with no data yet.
demo-introaction (shown, ask, tour, add or close)The demo’s introduction card, which a link with ?demo=1&intro=1 shows a guest instead of the demo bar: shown (once per page load), then Ask the AI about this portfolio, Take the tour, Add my portfolio or its ✕ pressed. The browser remembers that the card was asked for, and when it ended (localStorage pd_demo_intro, the value 1 or done); nothing else.
first-importroute (csv, api, snaptrade, ai, manual or assistant), platform (the broker, exchange or file format — e.g. degiro, kraken or revolut — from a fixed list, otherwise other; manual or market for hand-added assets); capped (only when the free plan loaded part of a file: how many of its positions were left out — a count, never which)The first data of your own arrives, whichever way it comes — a file, a screenshot or PDF read with AI, a connection, or an asset you add by hand.
importroute, platform, capped (the same values as first-import)Each later new account of your own data — another file, connection or broker account — and every asset you add by hand — never a re-upload of a file you already have, and never the demo.
checkout-startplan (pro), period (monthly or yearly)You are handed to Stripe to pay for Pro.
checkout-completeplan (pro), period, revenue and currency (the plan's list price, e.g. 69 EUR)Stripe sends you back after paying.
keep-promptaction (shown, dismissed or signup-click), trigger (import, answer or return)A guest's “Keep this portfolio” card in the app: shown once per visit, Not now pressed, or Save it pressed.
engagedpage (this website's page path), why (time or scroll)A page of this website has been open in front of you for 30 seconds in total (time spent in a background tab or a minimised window does not count) or you scrolled past its middle, whichever comes first — at most once each time a page is opened. It tells a visit that read the page from one that left at once; nothing about what you read or how fast.
mcp-demo-copypage (this website's page path)The Copy URL button of the demo MCP block is clicked, on an MCP guide or in the External agents chapter — nothing about what you then connect it to.
ai-strip-viewsource (chatgpt, claude, perplexity, copilot or gemini)The homepage’s one-line strip for a visitor sent by an AI assistant is shown — at most once per visit. It appears only when the page address names one of those assistants as utm_source, or your browser reports one of their sites as the page you came from.
ai-stripsource (the same word), action (demo, mcp or close)One of the strip’s links (the live demo, or connecting the assistant over MCP) or its ✕ is clicked. The ✕ is remembered in this browser (localStorage pd_ai_strip_closed, the value 1), and the tab notes for the visit that the strip was shown (sessionStorage pd_ai_strip_seen, 1) so the view is not counted twice; neither records which assistant it was.

The events from get-pro to checkout-complete — in the app, and the sign-up and checkout ones on this website’s account page — also carry the campaign tags of the link you first arrived by, when there is one (below): src (utm_source), med (utm_medium), cmp (utm_campaign) and ad (utm_content) — the same words that were in that link, nothing about you. Like every event here, they go to Umami.

The link you arrived by. An ad or a campaign link can carry campaign tags in its address — utm_source, utm_medium, utm_campaign, utm_content and utm_term, e.g. google, cpc and a campaign name. When you open a page of this website through such a link, the page adds exactly those five tags to its links into the app and to its own page links, so they reach the app if you go there. That happens in the links’ addresses only: this website still sets no cookie and stores nothing in your browser for it, and it carries nothing else from the address except Google’s ad click id (gclid, below) — never another network’s click id, and no click id on a link to another part of the same page. When the app opens with those tags, it removes them from the address bar and the server saves them, once, with your guest session — or with your account, if you are signed in to one created within the last day — together with the time they arrived; a later tagged link never replaces them. If you then create an account from that browser — in the app or on this website’s account page, with a password, Google or Apple — the new account takes them over. An account that already existed for more than a day before you came by such a link is left as it was: the tags describe the sign-up they led to, nothing later. That is the whole record: the tags and the time — no IP address, no browser details, no page you read. We keep it to learn which campaigns bring people who sign up. The operator sees it in the Admin tab’s account list and a count of sign-ups by source; the four tags named above also go, as event data, to our analytics service Umami (above), and to nobody else — the tags are never sent to Google or any other ad network. The guest session’s copy is deleted when the session is swept or when an account signs in from that browser; the account’s is in Download my data and is deleted with the account. The desktop app saves none.

Google Ads conversions — only if you allow it. When you come from a Google ad, the address also carries Google’s click id (gclid) — a random code Google gave that one click. The page takes it off the address bar; the website passes it on only in its links into the app and to its account page, still with no cookie of its own, and the app’s server keeps it with your guest session. If you then create an account — in the app or on this website, with a password, Google or Apple — the sign-up form shows one unticked box: “Tell Google Ads that I signed up — and, later, first imported my data — after clicking its ad. Only the ad’s click id and the times of those two steps are sent: no name, email or portfolio data.” Nobody who did not come from an ad is asked. Only if you tick it, and create the account within half an hour, do we send Google, once a day, that click id with “Signup” or “First import” and the time it happened — never your name, email, IP address or anything in your portfolio. We keep when you ticked it and which wording you saw. If you leave it unticked, the click id is deleted at once, and so is a first import you made as a guest waiting for that answer. A guest who never signs up is never reported: the click id goes when the guest session is swept. When you tick the box on this website’s account page and then continue with Google or Apple, the app’s server holds that answer for the trip through the provider in a 15-minute cookie on its own address (pd_ads_consent, the click id encrypted) — set only when you tick, cleared when you untick or come back. You can withdraw it at any time: ⚙ Settings → Account → Google Ads conversions → Withdraw deletes the click id and every record at once, so nothing more is sent; what Google already received stays with Google. Click ids and these records are deleted 90 days after the ad click — for a sign-up on this website, whose page cannot know when the ad was clicked, 90 days after the sign-up — or with your account, and are in Download my data together with when you agreed and to which wording. Google receives them under its own advertising terms, to measure which ads bring real users — we ask it not to use them for personalising ads. The desktop app keeps none.

One visit counter of our own. Both this website and the hosted app send the server a single visit beacon once per browser tab session: a request to /api/visit whose entire content is two words — which surface you are on (site or app) and a device class (desktop, mobile or tablet, worked out in your browser from the screen width and whether it has a touch pointer). That is the whole payload. It carries no cookie (the request is sent without credentials and the server sets none in reply), no identifier of any kind, no page address and no user-agent string; the server does not store your IP address — it keeps only a salted, in-memory hash of it for about a minute to throttle abuse, then forgets it. What is stored is one row per day per surface per device class with a count, so the operator can see "how many visits came from phones this week" and nothing finer. It respects the same opt-out as the analytics: a browser that has opted out with ?notrack sends no beacon either. The opt-out works on this website and in the app alike: add ?notrack to any page address once (?track undoes it). Each keeps its own setting, so opting out in the app does not cover the website. The desktop app sends none at all.

Testers are left out of the operator's numbers. The operator keeps a short list of tester addresses (himself and friends who try new builds) so their use does not inflate the counts. If you signed in with an address on that list, the app sets one more marker cookie, pd_tester=1, scoped like pd_signedin — its whole value is the character 1 and it grants nothing. Your browser stops sending the visit beacon and stops counting in Umami (the website and the app set Umami’s own umami.disabled switch, the one ?notrack uses, to tester — and clear it again once the marker is gone, while a ?notrack of your own stays), and if you later use the app without signing in, that guest session is marked as a tester's so it stays out of the operator's counts. It is removed the next time you open the app signed in once your address is off the list. Nobody else ever gets it.

Guests are counted per day, without an address. Only people who use the app without an account are guests: reading this website never makes you one. When a guest session first returns its cookie, the server adds one to a per-day count of new guests. At that moment it checks whether the request came from one of the operator's own IP addresses (or from a tester's browser) and notes only the answer — one word, kept with the guest session until it expires — so his own testing stays out of the counts. This count stores no IP address, and the operator's own addresses are kept for it only as keyed hashes, the same way as for the free budget above.

Crawlers are left out, and a guest counts once it does something. To keep search-engine, ad-review and link-preview crawlers out of the guest and visit counts, the server checks the user-agent header your browser sends with every request against a list of known crawlers; only the yes-or-no answer is used, only for these counts, and the header itself is never stored. In each page load of the app, after the first time you press, type, touch or scroll with a wheel — and only once the app knows you are a guest — it sends the server one request with no content; the server counts your guest session once, however many pages send it: it changes that one word kept with the session to interacted (deleted with the session when it expires) and adds one to a per-day count. Nothing about what you pressed, where or when is sent or kept. A browser opted out with ?notrack, or marked as a tester’s, sends no such request.

Imports are counted per day, without who. When a new account of your own data is added — a file, an exchange connection, a broker account, an asset added by hand — the server adds one to a per-day count kept by how it arrived (file, API key, SnapTrade, by hand or by the assistant), by the same platform word as the analytics event above, and by whether it was a guest or an account. That is the whole record: no session id, no account, no file name, no amounts. It is counted when the account is added, so it stays after a guest’s data expires. Testers, the operator’s own IP addresses and the demo portfolio are left out.

Errors are counted per person per day, without their content. When a request of yours fails on the server, or your browser sends a crash report, the server adds one to a per-day count of errors kept under the same salted hash of your session id that the error tracker sees — never the id itself, never the message or the stack (the error tracker receives separately minimized diagnostic details). At most ten are counted per minute, and the counts are deleted after 90 days, or with your account. The operator sees, per account, how many errors it ran into in the last seven days next to a link that opens the error tracker filtered to that hash; for guests, only how many guest sessions ran into errors.

When an assistant answer fails, is refused, is cut short or comes back empty, the server records diagnostic details in its local event log, tied to the anonymous session id. Reports sent to the external error tracker are separately minimized: the tracker receives a salted hash of that id, error categories, approved diagnostic messages and software locations, while unreviewed free-form text is replaced with an opaque signature.

External error reports. Reports sent to Sentry exclude stack-frame variable values, source-code snippets, request contents and headers, URL query values, arbitrary extra context and breadcrumb contents. This prevents portfolio transactions and SQL parameter values in backend exceptions from being attached to reports. Error types, severity and code locations remain available so real failures can still be investigated. This protection applies to newly sent reports after the app update; it does not remove earlier reports from the tracker.

Database health. The operator monitors database response times, read/write availability, storage headroom and server resource pressure. These measurements use counts and fixed categories, without query contents, transaction values or user identifiers. A failed or stale check is shown as unhealthy, and genuine failures remain visible to the operator. An independent availability checker can receive only two health flags through a separate restricted credential. A private store for up to 180 days of these database and server measurements is prepared but has not been activated.

Server diagnostics. The hosted service also keeps a size-limited local error journal, separate from usage analytics, so faults can be investigated without the external error tracker. It records timestamps, severity, route patterns, software version identifiers, diagnostic messages and bounded stack locations. It does not collect request bodies, headers, cookies or stack-frame variable values. Common credentials, email addresses and URL queries are scrubbed from diagnostic text. Access is restricted to server operators; older records are overwritten within a 10 MiB storage budget, and excess reports are dropped during an error flood.

One exception exists, and you type it yourself: a message sent through the in-app Feedback button is stored as written (with the email field only if you fill it in), tied to nothing more than the same anonymous session id.

Asking about your data

Write to privacy@fortunest.ai for anything covered on this page — a copy of what is stored about you, a correction, or deletion. The app already does both without a letter — Download my data in the account panel is the copy, and deleting your account removes it (all but the small deletion record described above, which a letter here erases); the address is there for the cases that need a person, and for the rights the GDPR gives you beyond the button.

For everything else: support@fortunest.ai for help with the app, security@fortunest.ai for a vulnerability report.