# FinBridge (remote · mcp.gronox.kr) Korean stock research MCP: DART financials, global filings, daily prices and research tools. - Trust score: 81/100 (high trust) - Change this week: +4 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-09-20 ## Components - remote · `mcp.gronox.kr`: 81/100 (this document), [markdown](https://verifymcp.io/servers/kr-gronox-finbridge/mcp.md), [page](https://verifymcp.io/servers/kr-gronox-finbridge/mcp) ## Channel facts - Endpoint: `https://mcp.gronox.kr/mcp` - Transports: `streamable-http` - Auth: `none` - Version: `0.1.4` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-09-20. - **Endpoint Security**: 94/100 - The endpoint's TLS certificate is valid, in date, and uses a strong key. - Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token. - HTTPS is enforced; there's no plaintext access path. - The HSTS (Strict-Transport-Security) header is present. - DNSSEC check failed: this domain isn't protected by DNSSEC. - The authorisation server offers only Dynamic Client Registration (RFC 7591), which MCP 2026-07-28 deprecated in favour of Client ID Metadata Documents. - **Transport & Reachability**: 100/100 - Verified streamable-http transport via a live MCP handshake. - **Schema Quality & AI Usability**: 57/100 - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 28833 tokens (~655/item across 44 items; 44 tools + 0 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 36/100 - Stability check failed: schema churn in the 13 days we've observed: 3 tool removals, 0 breaking changes, 0 auth/transport breaks, 7 additions. - **Tool Coverage**: 97/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 90% of tool parameters carry a description. - Structured output schemas are declared (91% of tools); any adoption earns full credit. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation. - An AI judge read all 45 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### How do I install the FinBridge MCP server? FinBridge is a hosted endpoint at https://mcp.gronox.kr/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add --transport http kr-gronox-finbridge 'https://mcp.gronox.kr/mcp' ``` ### Cursor ```json { "mcpServers": { "kr-gronox-finbridge": { "url": "https://mcp.gronox.kr/mcp" } } } ``` ### VS Code ```json { "servers": { "kr-gronox-finbridge": { "type": "http", "url": "https://mcp.gronox.kr/mcp" } } } ``` ### Codex ```toml [mcp_servers.kr-gronox-finbridge] url = "https://mcp.gronox.kr/mcp" ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "kr-gronox-finbridge": { "type": "remote", "url": "https://mcp.gronox.kr/mcp", "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add kr-gronox-finbridge --url 'https://mcp.gronox.kr/mcp' --transport streamable-http ``` ### Hermes ```yaml mcp_servers: kr-gronox-finbridge: url: "https://mcp.gronox.kr/mcp" ``` ### Netclaw ```json { "McpServers": { "kr-gronox-finbridge": { "Transport": "http", "Url": "https://mcp.gronox.kr/mcp" } } } ``` ### Vellum ```bash assistant mcp add kr-gronox-finbridge -t streamable-http -u 'https://mcp.gronox.kr/mcp' ``` ### Other ```json { "mcpServers": { "kr-gronox-finbridge": { "type": "http", "url": "https://mcp.gronox.kr/mcp" } } } ``` The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs. ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-09-20 (score 81, +1) - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ### 2026-09-19 (score 80, 0) - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ### 2026-09-18 (score 80, +1) - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ### 2026-09-17 (score 79, 0) - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ### 2026-09-16 (score 79, +1) - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ### 2026-09-15 (score 78, 0) - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ### 2026-09-14 (score 78, +1) - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ### 2026-09-13 (score 77, −1) - [security regression] Stability: 0.17 → fail - [functional] This server's schema is too large to store in full, so we cannot compare its tools day to day ## MCP tools (44) ### `real_estate_get_coverage` (~39 tokens) Apartment Data Coverage Stored Korean apartment sale coverage: collected region/month progress, source and license. Not live listings; refreshed by a collector, not automatically. ### `real_estate_list_regions` (~66 tokens) List Korean Districts List Korean sigungu districts (LAWD_CD) with the contract months actually collected for each. Districts with months=0 are not collected yet — querying them returns an error, not zero trades. Input parameters: - `onlyCollected` (boolean) - `sido` (string) ### `real_estate_search_trades` (~132 tokens) Search Apartment Sales Search stored MOLIT apartment sales. Only collected regions/months are available. Prices in KRW 10,000; area in square metres. Canceled sales excluded by default. Input parameters: - `district` (string) - `from` (string) - `includeCanceled` (boolean) - `limit` (integer) - `maxArea` (number) - `maxPriceMan` (number) - `minArea` (number) - `minPriceMan` (number) - `name` (string) - `offset` (integer) - `to` (string) ### `real_estate_summarize_trades` (~123 tokens) Summarize Apartment Sales Summarize stored apartment sales, excluding cancellations. Monthly medians are not a price index or valuation. Months with no trades report count 0 — uncollected months raise an error instead. Input parameters: - `district` (string) - `from` (string) - `includeCanceled` (boolean) - `maxArea` (number) - `maxPriceMan` (number) - `minArea` (number) - `minPriceMan` (number) - `name` (string) - `to` (string) ### `import_portfolio` (~830 tokens) Import Portfolio Holdings Store the structured holdings explicitly entered by the user in their FinBridge portfolio. Uploaded files, screenshots, chat history and extracted file content are not supported sources for this connector. Accepts listed stocks (KR/US/TW/JP) as well as cash, crypto (BTC etc.) and physical assets (gold): stocks are matched against the database, crypto and gold (PAXG) get live ccxt quotes, cash and physical assets are stored at the given value. For ETFs or foreign products not in the database, pass value directly. If the user specifies an asset class, pass asset_class as well (cash|bond|physical|growth|dividend|crypto|other; Korean labels 현금|채권|현물|성장주|배당주|가상자산|기타 are accepted). Registered listed stocks are also added to the watchlist automatically. Use when: the user explicitly enters what they hold and wants it stored for get_portfolio. There is no per-holding edit or delete tool: to change or remove holdings, re-import the complete corrected list with replace=true (replace=false only adds/updates the rows given). Not this tool for: the watchlist (manage_watchlist — companies followed, no quantities), valuing a company (get_valuation), or reading what is already stored (get_portfolio). IMPORTANT — read the response before telling the user you are done: 1\. Confirmation gate: if the user already has a stored portfolio, this call returns `preview:true` with a `changes` diff (added/removed/changed) and does NOT save anything, unless you pass confirm=true. Show the diff to the user — call out `changes.removed` especially: if the submission was only part of their holdings, those positions will look fully sold. Only pass confirm=true after the user has seen and accepted the diff (skip this if `get_portfolio` was empty to begin with — there is nothing to compare against). 2\. Missing fields: each saved row reports `missing_fields` (commonly `acquired_on`, since brokerage statements rarely include it) and unresolved symbols appear in `needs_input` — ambiguous names/codes lis… Input parameters: - `confirm` (boolean): Set true to apply after the user has reviewed the `changes` preview from a prior call with the same holdings/replace. Required whenever a portfolio already exists and this submission would change it;… - `holdings` (array, required): Structured holdings entered by the user. Each item accepts exactly: symbol (required), qty, avg_price, return_pct, asset_class, currency, value, acquired_on, price_symbol, unit, price_scale. Other ke… - `replace` (boolean): true = wipe the existing portfolio (stocks + assets) and replace it; default false = merge Output parameters: - `cash` (object) - `changes` (object) - `error` (string) - `holdings` (array) - `imported` (number|null) - `needs_input` (array) - `notes` (array) - `preview` (boolean) - `snapshot` (object) - `unmatched` (array) ### `get_portfolio_history` (~129 tokens) Portfolio Import History List the append-only portfolio snapshots recorded for this user. Each import_portfolio call that actually changes the stored holdings/assets (and each restore_portfolio_snapshot) appends one snapshot of the whole portfolio at that moment — quantities, average prices, symbols and asset classes, never market prices or computed valuations (those are recomputed fresh whenever needed). Identical resubmissions do not create a duplicate entry. Use this to see when the portfolio changed, then restore_portfolio_snapshot to undo a bad import. Input parameters: - `limit` (integer): Max snapshots to return, most recent first. Default 20. Output parameters: - `count` (number|null) - `error` (string) - `snapshots` (array) ### `restore_portfolio_snapshot` (~135 tokens) Restore a Past Portfolio Roll the stored portfolio back to a past snapshot from get_portfolio_history, replacing ALL current holdings and assets with that snapshot's content. Use this to undo a bad import_portfolio call. Omit snapshot_id to restore the snapshot immediately before the current state (undo the last change). This action is itself recorded as a new snapshot — history is append-only, so restoring is itself reversible the same way. Tell the user what was restored (get_portfolio afterwards shows it valued at current prices). Input parameters: - `snapshot_id` (integer): Snapshot id from get_portfolio_history. Omit to restore the one immediately before the latest. Output parameters: - `assets` - `error` (string) - `holdings` - `notes` (array) - `restored_from` (number|null) - `snapshot` (object) ### `get_portfolio` (~156 tokens) My Portfolio Return the holdings this user has already registered in FinBridge with import_portfolio — listed stocks plus cash, crypto, ETF and physical assets — valued at the latest prices, with return and asset allocation. A user who has registered nothing gets an empty list. Not this tool for: analysing or valuing a company (get_valuation), prices (get_stock_prices), or finding companies (screen_companies). It reads only what this user stored, so it knows nothing about a company they do not hold. Crypto and ETFs use live ccxt quotes, stocks the latest close in the database, cash and physical assets the registered amount. allocation is aggregated per currency; combined converts everything to KRW using an ECB-derived USD/KRW rate. Output parameters: - `allocation` (array) - `combined` - `count` (number|null) - `error` (string) - `holdings` (array) - `notes` (array) - `total_value` ### `get_watchlist` (~32 tokens) My Watchlist Read the companies followed by the authenticated user. Returns names, symbols and markets without changing the watchlist or holdings. Output parameters: - `error` (string) - `total` (number|null) - `watchlist` (array) ### `manage_watchlist` (~173 tokens) Add or Remove Watchlist Companies Add or remove a company from the user's watchlist. This changes saved preferences, not financial assets. Only remove deletes an entry. action='add' and action='remove' each take one symbol and are idempotent: adding a company already on the list leaves it there, removing one that is not on the list is a no-op. Both report the resulting list size. Not this tool for: holdings and cash (that is a portfolio — use get_portfolio / import_portfolio), or for any market data. The watchlist stores which companies the user follows, nothing about quantities, prices or returns. Input parameters: - `action` (string, required): 'add' and 'remove' each need a symbol. - `symbol` (string): Stock code, ticker or company name. Required for 'add' and 'remove'. Output parameters: - `action` (string|null) - `error` (string) - `market` - `name` - `symbol` - `total` (number|null) - `watched` (boolean) - `watchlist` (array) ### `backtest_portfolio` (~1013 tokens) Portfolio Backtest (FinBridge DB) Backtest a fixed-weight KR or US portfolio on daily data from the local finbridge.db (stocks are corporate-action adjusted; US stocks are total-return where SEC-reported dividends exist). ETFs are PRICE-RETURN ONLY in every market (no distributions). Detected US ETF splits are adjusted, but coverage is not exhaustive; unexplained jumps and long gaps are refused. US history starts 2023-03-28, so earlier start dates are clipped. Pure historical simulation — no forecasts. Account storage: when connected to an account, this call automatically saves its inputs and summary as a new run. Repeating it creates another run. Only the newest 200 runs are kept; saving beyond that limit deletes older runs and their trade logs. No brokerage order is placed. Args: \- assets: 1-15 of {symbol, weight}. symbol = KR 6-digit code ('005930'), US ticker ('AAPL', 'SPY'), or a company/ETF name. Weights are normalized to sum 1. \- from (required, YYYY-MM-DD), to (default: today). Start is clipped to the latest asset inception date (noted). \- rebalance: 'none'|'monthly'|'quarterly'|'yearly' (default 'yearly') — rebalanced at the close of the first trading day of each new period. \- currency: 'USD' (default) | 'KRW' — reporting currency; assets in the other currency are converted daily (USDKRW, Federal Reserve H.10). \- initial: starting value in the report currency (default 10000). Returns: {period, currency, rebalance, assets[](weight_pct, first_date, dividend_adjusted, converted), metrics{total_return_pct, cagr_pct, vol_annual_pct, sharpe, mdd_pct, mdd_peak_date, mdd_trough_date, best_year, worst_year}, annual_returns[], equity_curve[](sampled, JSON only), notes[]}. Examples: \- Samsung + KODEX 200 70/30: {assets:[{symbol:'005930',weight:0.7},{symbol:'069500',weight:0.3}], from:'2021-01-01', currency:'KRW'} Use when: "what if I invested in X portfolio since YYYY" questions, comparing allocations, drawdown/volatility analysis. Don't use for: single-stock history (get_stock_price… Input parameters: - `assets` (array, required): Portfolio assets with weights - `benchmark` (string): Benchmark symbol from the benchmarks table (KOSPI, KOSPI200, SPY, VTI, EW_KR, EW_US, EW_TW), 'auto' for the dominant market's default, or 'none'. - `costs` (boolean): Deduct commission, slippage and sell-side tax on every rebalance (default true). Set false for a gross-return view. - `currency` (string): Reporting currency (default USD) - `from` (string, required): Start date YYYY-MM-DD - `initial` (number): Starting value in the report currency (default 10000) - `label` (string): Name this run so you can find it again with get_backtest_runs (the run is saved either way). - `rebalance` (string): Rebalancing frequency (default yearly) - `response_format` (string): 'markdown' for tables, 'json' for compact machine-readable output - `slippage_bps` (number): One-way slippage in basis points (default 5). An assumption — we hold no quote data. - `to` (string): End date YYYY-MM-DD (default: today) Output parameters: - `annual_returns` (array) - `assets` (array) - `benchmark` - `currency` - `equity_curve` (array) - `final_value` - `initial` - `metrics` (object) - `notes` (array) - `period` (object) - `rebalance` - `run_id` (number) ### `analyze_factors` (~2032 tokens) Factor Study (FinBridge DB) Measure whether a ranking signal actually separates future returns, point-in-time, on KR/US/TW daily bars from the local finbridge.db. Expect several seconds (typically 5-10 s): it rebuilds point-in-time ranks at every rebalance date. This is the question that comes BEFORE a screener: not "which names pass today" but "does this axis pay at all". Account storage: when connected to an account, this call automatically saves its inputs and summary as a new run. Repeating it creates another run. Only the newest 200 runs are kept; saving beyond that limit deletes older runs and their trade logs. No brokerage order is placed. Three answers per factor: \- Quantile portfolios: at every rebalance the investable set is sorted on the factor and cut into N buckets; you get each bucket's average forward return. A real signal is monotonic from Q1 to QN. If only the ends move and the middle is noise, that is a tail, not a signal. \- IC (information coefficient): the cross-sectional Spearman correlation between factor rank and forward-return rank at each date. mean is the strength of the direction; ir = mean/stdev is how consistently it holds. A high mean with a low IR was made by a few regimes. \- Correlation matrix: average rank correlation between the factors themselves. Two factors that see the same thing do not diversify each other. Price factors (any market with bars, and the default set): mom_12_1 (12-month return skipping the last month), reversal_1m, trend_50_200, range_52w (position in the 52-week band), volatility_60d, liquidity (a control, since the investable set is already ranked on it). Fundamental factors (KR and US only, request them explicitly): earnings_yield (diluted EPS / price), roe, net_margin, gross_margin, debt_ratio, asset_growth (YoY total assets), accruals ((net income − operating cash flow) / assets). Three more need a point-in-time market capitalisation (share-count history), so they run only where that exists — US/KR for book_yield (equity / ma… Input parameters: - `factors` (array): Subset of factors; omit for the price set (mom_12_1, reversal_1m, trend_50_200, range_52w, volatility_60d, liquidity). Fundamental keys (KR/US only): insider_net_buy, book_yield, sales_yield, earning… - `hold` (integer): Forward-return window in trading days (default 20) - `label` (string): Name this study so you can find it again with get_backtest_runs (it is saved either way). - `market` (string, required): Market with daily bars: 'kr', 'us' or 'tw' - `neutralize` (string): 'sector' ranks each factor within its sector group and measures returns against the sector mean, so the result is not an industry bet - `quantiles` (integer): Number of buckets (default 5) - `rebalance` (integer): Trading days between measurement dates (default 20). Equal to hold = non-overlapping observations. - `response_format` (string): 'markdown' for tables, 'json' for compact machine-readable output - `slippage_bps` (number): One-way slippage in bp used for the reported cost figure (default 5) - `universe` (integer): Most-traded names forming the investable set (default 300) - `years` (integer): History window in years (default 5). US bars only exist from 2023-03-28 and the study also spends a 260-session warm-up, so a US run covers roughly two years however large this is — the response `ran… Output parameters: - `caveats` (array) - `correlation` (array) - `cost_per_rebalance_pct` (number) - `data_as_of` - `factors` (array) - `hold` (number) - `market` (string) - `neutralized` (boolean) - `overlapping` (boolean) - `quantiles` (number) - `range` (object) - `rebalance` (number) - `rebalances` (number) - `run_id` (number) - `universe` (number) - `us_note` (string|null) ### `delete_backtest_run` (~67 tokens) Delete a Saved Backtest or Factor Study Delete one saved simulation and its trade log from the authenticated account. This permanently removes the saved result; it does not place orders or change financial assets. An unknown or other-account run returns an error without modifying any data. Input parameters: - `run_id` (integer, required): Saved run ID to delete Output parameters: - `deleted` (boolean) - `error` (string|null) - `run_id` (number) ### `get_backtest_runs` (~680 tokens) Saved Backtests & Factor Studies (FinBridge) List, open or re-check the backtest and factor runs saved for your account. This tool does not modify saved runs. Every backtest_portfolio and analyze_factors call is stored automatically with the exact inputs it ran on, the headline numbers, and the data vintage (the market's latest price session at the time). Why re-check matters: in this dataset the same inputs can give a different answer later. Split adjustments get applied (225 US ETFs on 2026-09-04), financials get restated, delistings get flagged — all of which rewrite history retroactively. action='recheck' re-runs the stored inputs against today's data and reports what moved, which is the only way to notice that kind of drift. Run types: 'portfolio' (backtest_portfolio), 'factors' (analyze_factors), and 'strategy' (the screener replay in the web studio). Only portfolio runs carry a trade log; a strategy run stores headline numbers alone, because that engine reports a capped sample of picks rather than every trade, and calling that a trade log would be a lie. Args: \- action: 'list' (default) | 'get' | 'recheck' \- run_id: required for get / recheck \- kind: 'portfolio' | 'factors' | 'strategy' — filter for list \- limit: 1-50 for list (default 20) \- trades: include the trade log in 'get' (default false). A portfolio run stores its initial purchase, every rebalance delta and any delisting liquidation; factor studies have no trades. Returns: \- list: {runs: [{run_id, kind, label, market, range, data_as_of, created_at, headline}]} \- get: {run: {...}, params, summary, trades?} \- recheck: {run, stored, current, changed: [{key, before, after, delta}], data_as_of: {stored, now}, verdict} Use when: comparing runs you made earlier, auditing which trades a portfolio backtest actually made, or checking whether a saved result still holds after nightly ingests. Not this tool for: running something new — a new portfolio simulation is backtest_portfolio and a new signal study is analyze_factors (both save… Input parameters: - `action` (string): What to do (default 'list') - `kind` (string): Filter the list by run type - `limit` (integer): How many runs to list (default 20) - `response_format` (string): 'markdown' for tables, 'json' for compact machine-readable output - `run_id` (integer): Run id — required for get / recheck - `trades` (boolean): Include the trade log in 'get' (default false) Output parameters: - `action` - `changed` (array) - `count` (number) - `current` - `data_as_of` (object) - `deleted` (boolean) - `error` (string|null) - `params` - `range` (object) - `run` (object) - `run_id` (number) - `runs` (array) - `stored` - `summary` - `trade_count` (number) - `trades` (array) - `verdict` ### `get_peers` (~754 tokens) Peer Companies Comparison references for one company across KR / US / TW / JP / EU. The default uses a sourced business theme or broad source classification and does not assert direct competition or add unrelated companies to fill the limit. Explicit rank='size' returns same-currency size references and does not assert an industry relationship. Also returns the company's business-segment revenue split where available (Japan from 有価証券報告書 XBRL, the US from SEC DERA financial-statement datasets; US segment names are usually end markets, not industries) — informational unless rank='segments'. Args: \- company: US ticker ('AAPL'), KR 6-digit code ('005930'), TW/JP 4-digit code ('2330', '7203'), or a company name (local or English). \- market: 'kr'|'us'|'tw'|'jp'|'eu' (optional) — disambiguates codes/names shared across markets (TW and JP both use 4-digit codes; 'eu' companies are addressed by ISIN). \- limit: 1-10 peers (default 5). \- same_market_only: true = restrict peers to the company's own market (default false — a KR chipmaker can sit next to a US one). \- rank omitted = business-related references; 'size' = explicit size references with verified equal market-cap currency; 'segments' = rank by business-mix similarity — each company's segment revenue shares are mapped to standard industries (companies without segment data count as 100% their own industry) and compared by cosine similarity, ties broken by normalized size. Conglomerates (Sony: games/music/pictures/electronics/finance) then get conglomerate peers instead of whichever single bucket they were filed under. \- response_format: 'markdown' (default) or 'json'. Returns: existing fields plus policy_version, purpose, insufficiency_reason; each peer also has selection_reason, comparison_role and evidence_status. Broad/theme rows are business-related references, not verified direct competitors. Explicit size rows are size-reference only. Examples: \- {company:'7203'} -> Toyota + transportation-equipment peers, with… Input parameters: - `company` (string, required): Ticker, KR 6-digit code, TW/JP 4-digit code, or name - `limit` (integer): Peers to return (default 5) - `market` (string): Restrict resolution to one market ('eu' = ESEF filers, identified by ISIN) - `rank` (string): Omit for business-related references; 'size' explicitly requests same-currency size references; 'segments' uses business-mix similarity - `response_format` (string): Output format (default markdown) - `same_market_only` (boolean): Only peers from the company's own market Output parameters: - `as_of` (string|null) - `basis` - `company` (object) - `data_as_of` - `industry_mix` - `notes` (array) - `peers` (array) - `sector` - `segments` ### `search_dart_company` (~376 tokens) Search Korean Companies (DART) Search companies registered with DART, South Korea's corporate disclosure system, by name, 6-digit stock code, or 8-digit DART corp_code. Returns the corp_code required by the other dart_* tools. Not this tool for: US registrants (use search_edgar_company). Japan, Taiwan and Europe have no search tool — reach them through screen_companies or query_db on the companies table. Args: \- query: company name (Korean works best, e.g. '삼성전자'), 6-digit KRX stock code ('005930'), or 8-digit corp_code \- listed_only: restrict to KRX-listed companies (default true). Set false to include ~90k unlisted entities. \- limit: max results, 1-50 (default 10) Returns: {count, companies: [{corp_code, corp_name, stock_code}]} — stock_code is null for unlisted companies. Match priority: exact stock code > exact name > listed partial > unlisted partial. Examples: \- {query: '삼성전자'} -> corp_code 00126380, stock_code 005930 \- {query: '카카오', listed_only: false} -> listed 카카오 plus unlisted same-name entities Use when you need a corp_code or must disambiguate similar names. Don't use for US companies (use search_edgar_company). Errors: DART_API_KEY not configured; no match returns count 0 (not an error). Input parameters: - `limit` (integer): Max results, 1-50 (default 10) - `listed_only` (boolean): Only KRX-listed companies (default true) - `query` (string, required): Company name, 6-digit stock code, or 8-digit DART corp_code Output parameters: - `companies` (array) - `count` (number) ### `get_dart_financials` (~1454 tokens) Korean Company Financials (DART) Fetch financial statements of a Korean company from OpenDART (fnlttSinglAcntAll: full single-company statements) and normalize them to standard metrics. Amounts are raw KRW (no scaling); EPS is KRW per share. Not this tool for: US statements (get_edgar_financials), a KR-vs-US pair on one screen (compare_financials_kr_us), or ranking many companies at once (screen_companies, which reads the stored table and covers KR/US/TW/JP/EU). This tool requests one Korean company's statements through the DART adapter; results may be reused from a process-local cache for up to 24 hours. data_as_of.generated_at is response creation time, not source retrieval time. Peer comparisons use separately dated database snapshots. Args: \- corp: Company: Korean name (e.g. '삼성전자'), 6-digit stock code (e.g. '005930'), or 8-digit DART corp_code (e.g. '00126380') \- year: business year 2015-2026 (default: last year). Annual reports are filed ~March of the following year (FY2025 filed 2026-03). \- report: 'annual' | 'q1' | 'half' | 'q3' (default 'annual') \- fs: 'consolidated' | 'separate' (default 'consolidated'). If consolidated statements do not exist, automatically retries separate and says so in notes. \- statement: optional BS/IS/CIS/CF/SCE account-group filter \- account_query: optional case-insensitive account name or account_id substring \- account_limit: returned account rows, 1-200 (default 40) \- as_of: optional YYYY-MM-DD. Adds point_in_time: the version of this period/basis that was public on that day. \- response_format: 'markdown' (default, tables) or 'json' (compact) Returns structured {normalized, accounts}: \- normalized: {company:{name,id,ticker}, basis, periods:[{period, fiscal_year, currency:'KRW', metrics:{revenue, gross_profit, operating_income, net_income, eps_diluted, assets, liabilities, equity, cash_and_equivalents, operating_cash_flow}}], notes}. Annual reports include the prior-year comparative as a second period. \- accounts: selected reported statem… Input parameters: - `account_limit` (integer): Maximum returned account rows (default 40). - `account_query` (string): Optional account name/account_id substring. - `as_of` (string): Optional YYYY-MM-DD. Return point_in_time: the preserved version of this period that was public on that day. - `corp` (string, required): Company: Korean name (e.g. '삼성전자'), 6-digit stock code (e.g. '005930'), or 8-digit DART corp_code (e.g. '00126380') - `fs` (string): Statement scope: consolidated(연결, CFS) or separate(별도, OFS). Default consolidated. - `report` (string): Report type: annual(사업보고서) | q1(1분기) | half(반기) | q3(3분기). Default annual. - `response_format` (string): 'markdown' for tables, 'json' for compact machine-readable output - `statement` (string): Optional statement-group filter. - `year` (integer): Business year (bsns_year), 2015-2026. Default: last year (2025). Output parameters: - `account_selection` (object) - `accounts` (array) - `data_as_of` - `earnings_disclosures` (object) - `normalized` (object) - `peer_comparison` - `plan_limit` (object) - `point_in_time` (object) - `preserved_revisions` (object) - `revision_links` (object) - `statement_groups` (array) - `sum_checks` (array) ### `get_dart_document` (~583 tokens) Explore Korean Disclosure Document (DART) Explore the primary body of one DART filing by receipt number while preserving section and table structure. Use get_dart_filings first to obtain rcept_no. Start with action='overview', then select a section or table instead of requesting a long flattened filing. Args: \- rcept_no: 14-digit DART receipt number \- action: overview (default) | section | table | compare_tables | compare_sections \- compare_rcept_no and compare_index: second filing and its selected table/section index for comparison; table_index/section_index selects the first. Use both overviews first. Only selected content is compared, not entire filings. \- section_index or section_query: one section selector for action='section' \- table_index: 1-based table selector for action='table' \- max_chars: section text cap, 1,000-100,000 (default 30,000) \- max_rows/max_columns: selected table caps (defaults 50/30) \- overview_offset/overview_limit: paginate both section and table summaries with the same 0-based slice (defaults 0/20, max 100) \- response_format: markdown or json Returns source evidence for the OpenDART document entry and character range. Tables retain row/column order, cell text, rowspan/colspan and nearby reported unit labels. Zero and negative strings are not discarded. Separate HWP/PDF attachments are not fetched or rehosted. This tool does not claim an XBRL presentation/calculation hierarchy. Use get_dart_financials for normalized figures, reported account groups and known statement sum checks. Input parameters: - `action` (string): Start with the outline, then select a section or a leaf table. - `compare_index` (integer) - `compare_rcept_no` (string) - `max_chars` (integer): Maximum characters of selected section text; truncation is explicit. - `max_columns` (integer): Maximum selected table columns; original column count is retained. - `max_rows` (integer): Maximum selected table rows; original row count is retained. - `overview_limit` (integer): Maximum section and table summaries per outline page; follow next_offset. - `overview_offset` (integer): 0-based outline slice offset for both sections and tables. - `rcept_no` (string, required): 14-digit DART receipt number from get_dart_filings - `response_format` (string): Readable markdown or JSON; both retain structured content. - `section_index` (integer): 1-based section number from the outline; use only with section action. - `section_query` (string): Section title search; use instead of section_index. Ambiguous matches are rejected. - `table_index` (integer): 1-based leaf-table number; required for table action. Output parameters: - `action` (string) - `comparison` (object) - `notes` (array) - `overview` (object) - `preservation` (object) - `section` (object) - `sections` (array) - `source_evidence` (object) - `table` (object) - `tables` (array) ### `get_dart_filings` (~651 tokens) Korean Disclosure Filings (DART) List corporate disclosure filings from DART, optionally filtered by company, date range, and disclosure type. Report names are in Korean. Not this tool for: US filings (get_edgar_filings), a cross-market feed already stored here (get_disclosure_feed), or major-event reports specifically (get_dart_major_events, a narrower slice of this one). Args: \- corp: optional — Company: Korean name (e.g. '삼성전자'), 6-digit stock code (e.g. '005930'), or 8-digit DART corp_code (e.g. '00126380'). Omit for a market-wide list. \- from / to: YYYY-MM-DD (default: last 90 days) \- type: DART pblntf_ty — A=periodic reports(정기공시), B=major events(주요사항보고), C=securities issuance(발행공시), D=ownership/stake(지분공시), E=other(기타공시), F=external audit(외부감사관련), G=funds(펀드공시), H=asset securitization(자산유동화), I=KRX disclosures(거래소공시), J=fair trade(공정위공시) \- limit: results per page, 1-100 (default 20); page: page number (default 1) Returns: {total, page, filings: [{rcept_no, corp_name, report_nm, flr_nm, rcept_dt, url}]} — url opens the filing in the DART viewer. Pass rcept_no to get_dart_document to explore its primary body by outline, section, or table. Examples: \- {corp: '삼성전자'} -> Samsung filings in the last 90 days \- {type: 'A', from: '2026-03-01', to: '2026-03-31'} -> March periodic reports market-wide Use to track what a company disclosed. For major events with keyword filtering use get_dart_major_events. Errors: no filings in range (DART status 013) -> widen dates or drop filters; unknown company -> search_dart_company. Input parameters: - `corp` (string): Optional filter — Company: Korean name (e.g. '삼성전자'), 6-digit stock code (e.g. '005930'), or 8-digit DART corp_code (e.g. '00126380') - `from` (string): Start date YYYY-MM-DD (default: 90 days ago) - `limit` (integer): Results per page, 1-100 (default 20) - `page` (integer): Page number (default 1) - `to` (string): End date YYYY-MM-DD (default: today) - `type` (string): Disclosure type: A=periodic, B=major events, C=issuance, D=ownership, E=other, F=audit, G=funds, H=asset-backed, I=KRX, J=fair-trade Output parameters: - `filings` (array) - `page` - `total` (number|null) ### `get_dart_major_events` (~690 tokens) Korean Major-Event Disclosures (DART) List major-event disclosures (주요사항보고서, DART type B): capital increases, mergers, convertible bonds, treasury stock, bankruptcy, lawsuits, etc. Optionally filter report names with a regex. Not this tool for: the full disclosure list or other report categories (get_dart_filings — periodic reports, securities issuance, ownership, KRX notices), US 8-K events (get_edgar_filings), or the cross-market stored feed (get_disclosure_feed). What this adds over get_dart_filings type='B': a 'kinds' regex over Korean report names (e.g. '증자|합병|전환사채'), a 180-day default window tuned for event scans, and matched-count totals — so use it when the question is 'which companies announced X', not 'what did company Y file'. Args: \- corp: optional — Company: Korean name (e.g. '삼성전자'), 6-digit stock code (e.g. '005930'), or 8-digit DART corp_code (e.g. '00126380'). Omit for market-wide events. \- from / to: YYYY-MM-DD (default: last 180 days) \- kinds: optional JavaScript regex matched against the Korean report name, e.g. '증자|합병|전환사채' (capital increase | merger | CB) or '자기주식' (treasury stock). Filtering is applied client-side over the most recent 100 events in range. \- limit: max results, 1-100 (default 20) Returns: {total, page, filings: [{rcept_no, corp_name, report_nm, flr_nm, rcept_dt, url}]} — same shape as get_dart_filings. When kinds is given, total = matched count within the scanned window. Examples: \- {corp: '삼성전자', kinds: '자기주식'} -> Samsung treasury-stock decisions in the last 180 days \- {kinds: '유상증자', from: '2026-01-01', to: '2026-06-30'} -> market-wide rights offerings in H1 2026 Use when: event-driven screening (rights offerings, mergers, CBs, treasury stock, lawsuits) market-wide or for one company. For every filing category, or when you already know the report you want, use get_dart_filings. Errors: no events in range (DART status 013) -> widen dates; invalid kinds regex; unknown company -> search_dart_company. Input parameters: - `corp` (string): Optional filter — Company: Korean name (e.g. '삼성전자'), 6-digit stock code (e.g. '005930'), or 8-digit DART corp_code (e.g. '00126380') - `from` (string): Start date YYYY-MM-DD (default: 180 days ago) - `kinds` (string): Regex filter on Korean report names, e.g. '증자|합병|전환사채' or '자기주식' - `limit` (integer): Max results, 1-100 (default 20) - `to` (string): End date YYYY-MM-DD (default: today) Output parameters: - `filings` (array) - `page` - `total` (number|null) ### `get_dart_insider_trades` (~579 tokens) Get KR Insider Trades (DART 임원·주요주주 소유보고) Korean insider transactions for a listed KR company, from DART's 임원ㆍ주요주주 특정증권등 소유상황보고서 (elestock) — the Korean equivalent of SEC Form 4. Includes a buy-vs-sell summary and an optional buy/sell filter. Not this tool for: US insiders (get_edgar_insider_trades) or institutional managers, which are a different kind of holder entirely (get_edgar_13f). Buy vs sell is the SIGN of the reported share change (증감수): positive = 취득 (acquire / buy), negative = 처분 (dispose / sell). Insider BUYING is a stronger sentiment signal. Args: \- company (required): KR 6-digit stock code (e.g. '005930'), company name, or 8-digit DART corp_code \- limit: number of most-recent reports to return, 1-100 (default 20) \- tx_type: 'all' (default) | 'buy' (share change > 0) | 'sell' (share change < 0) \- response_format: 'markdown' (default) or 'json' Returns: {company:{corp_code, corp_name}, tx_type, summary:{buys:{count,shares}, sells:{count,shares}}, count, trades:[{filedAt, reporter, position, registered_exec, major_shareholder, change, shares_after, change_rate}], notes}. summary totals cover the whole fetched set regardless of the filter. Important: unlike US Form 4, the KR report has NO transaction price — only share counts (no value). Reports are filed within ~5 business days. Examples: \- "삼성전자 임원 매수" -> {company:'005930', tx_type:'buy'} \- "SK하이닉스 내부자 매도 최근" -> {company:'000660', tx_type:'sell'} Use when: monitoring KR officer / major-shareholder buy/sell activity. For US insiders use get_edgar_insider_trades. For institutional holdings use get_edgar_13f. Errors: unknown company -> use search_dart_company; a filter with no matches returns count 0 (not an error). Input parameters: - `company` (string, required): KR 6-digit stock code (e.g. '005930'), company name, or DART corp_code - `limit` (integer): Number of most-recent reports (default 20) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `tx_type` (string): 'all' (default), 'buy' = acquisitions (change > 0), 'sell' = disposals (change < 0) Output parameters: - `company` (object) - `count` (number|null) - `notes` (array) - `summary` (object) - `trades` (array) - `tx_type` ### `search_edgar_company` (~360 tokens) Search SEC EDGAR Companies Search SEC EDGAR registrants (US-listed companies) by ticker, company name, or CIK. Returns the 10-digit zero-padded CIK needed by the other edgar_* tools. Not this tool for: Korean companies (use search_dart_company). Japan, Taiwan and Europe have no search tool — reach them through screen_companies or query_db on the companies table. Args: \- query (required): ticker ('AAPL', 'BRK-B' or 'BRK.B'), company-name fragment ('Berkshire'), or CIK number ('320193') \- limit: max results, 1-50 (default 10) Returns: {count, companies: [{cik, ticker, title}]} ranked exact-ticker > exact-name > prefix > substring. Examples: \- "find Apple's CIK" -> {query: 'AAPL'} \- "companies named Berkshire" -> {query: 'Berkshire', limit: 5} Use when: you need a CIK or to disambiguate a company name before calling get_edgar_financials/filings/insider_trades (those also accept tickers directly, so for an exact ticker you can skip this step). Don't use for: Korean companies (use search_dart_company) or private companies not registered with the SEC. Errors: no match -> error suggesting a shorter name fragment; only SEC registrants with a listed ticker are searchable. Input parameters: - `limit` (integer): Max matches to return (default 10) - `query` (string, required): Ticker (e.g. 'AAPL', 'BRK-B'), company-name fragment (e.g. 'Berkshire'), or CIK number Output parameters: - `companies` (array) - `count` (number) ### `get_edgar_financials` (~706 tokens) Get US Company Financials (SEC XBRL) Normalized annual (10-K) or quarterly (10-Q) financial statements for a US company, from SEC EDGAR XBRL company facts (US-GAAP). Values are raw USD (not scaled); eps_diluted is USD per share. Not this tool for: Korean statements (get_dart_financials), a KR-vs-US pair on one screen (compare_financials_kr_us), or ranking many companies at once (screen_companies, which reads the stored table and covers KR/US/TW/JP/EU). This tool requests one US company's SEC XBRL company facts through the source adapter; results may be reused from a process-local cache for up to 24 hours. data_as_of.generated_at is response creation time, not source retrieval time. Peer comparisons use separately dated database snapshots. Args: \- company (required): ticker / company name / CIK (e.g. 'AAPL', 'Microsoft', '789019') \- freq: 'annual' (default, from 10-K) or 'quarterly' (discrete Q1-Q3 from 10-Qs; Q4 is not reported separately) \- periods: how many most-recent periods, 1-12 (default 3) \- metrics: optional subset of [revenue, gross_profit, operating_income, net_income, eps_diluted, assets, liabilities, equity, cash_and_equivalents, operating_cash_flow] (default all) \- response_format: 'markdown' (default) or 'json' Returns NormalizedFinancials: {company:{name, id(CIK), ticker}, basis:'US-GAAP (10-K)', periods:[{period:'FY2024', fiscal_year, end, currency:'USD', metrics:{revenue, net_income, ...}}], notes}. periods are most-recent first; fiscal_year = calendar year of the period end date. Examples: \- "Apple's revenue and net income for the last 3 years" -> {company:'AAPL', metrics:['revenue','net_income']} \- "MSFT last 4 quarters" -> {company:'MSFT', freq:'quarterly', periods:4} Use when: you need US-GAAP fundamentals for a US-listed company. Don't use for: Korean companies (get_dart_financials), stock prices, or IFRS 20-F foreign private issuers (not supported). Errors: unknown company -> use search_edgar_company first; companies without us-gaap XBRL facts (funds, 20-F fi… Input parameters: - `company` (string, required): US company: ticker (e.g. 'AAPL', 'BRK-B' or 'BRK.B'), company name, or CIK number - `freq` (string): 'annual' = fiscal years from 10-K filings; 'quarterly' = discrete Q1-Q3 from 10-Q filings - `metrics` (array): Optional metric subset. Available: revenue, gross_profit, operating_income, net_income, eps_diluted, assets, liabilities, equity, cash_and_equivalents, operating_cash_flow. Default: all - `periods` (integer): Number of most-recent periods (default 3) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output Output parameters: - `basis` - `company` (object) - `data_as_of` - `notes` (array) - `peer_comparison` - `periods` (array) - `plan_limit` (object) ### `get_edgar_filings` (~504 tokens) List SEC Filings List a US company's recent SEC filings (10-K, 10-Q, 8-K, S-1, proxy statements, Form 4, ...) from the EDGAR submissions index. Returns metadata and document URLs only — it does NOT download filing contents; fetch the returned url yourself for the document text. Not this tool for: Korean filings (get_dart_filings) or a cross-market feed already stored here (get_disclosure_feed). Args: \- company (required): ticker / company name / CIK \- forms: optional form-type filter, e.g. ['10-K'] or ['10-K','10-Q','8-K'] (exact match, case-insensitive) \- from / to: optional YYYY-MM-DD filing-date range \- limit: max rows, 1-50 (default 20) Returns: {company:{cik, name, ticker}, count, filings:[{form, filingDate, accessionNumber, primaryDocument, items?, url}], notes?}. 8-K rows include 'items' (e.g. '2.02,9.01' = results of operations + exhibits). Coverage = the latest ~1000 filings per company. Examples: \- "Apple's latest annual report" -> {company:'AAPL', forms:['10-K'], limit:1} then fetch the url \- "Tesla 8-Ks this year" -> {company:'TSLA', forms:['8-K'], from:'2026-01-01'} Use when: you need filing dates, document links, or 8-K event items for a US company. Don't use for: Korean disclosures (get_dart_filings) or filing full-text search across all companies. Errors: unknown company -> use search_edgar_company; an empty result usually means the form/date filter is too narrow for the ~1000-filing window. Input parameters: - `company` (string, required): US company: ticker (e.g. 'AAPL', 'BRK-B' or 'BRK.B'), company name, or CIK number - `forms` (array): Form types to include, e.g. ['10-K','8-K']. Omit for all forms - `from` (string): Earliest filing date, YYYY-MM-DD - `limit` (integer): Max filings to return (default 20) - `to` (string): Latest filing date, YYYY-MM-DD Output parameters: - `company` (object) - `count` (number|null) - `filings` (array) - `notes` (array) ### `get_edgar_insider_trades` (~632 tokens) Get Insider Trades (SEC Form 4) Latest insider transactions for a US company, parsed from SEC Form 4 filings, with a buy-vs-sell summary and an optional buy/sell filter. Each trade lists the reporting insider, their relationship, and non-derivative (common stock) transactions. Not this tool for: Korean insiders (get_dart_insider_trades) or institutional managers, which are a different kind of holder entirely (get_edgar_13f). Insider BUYS (open-market purchases, code P) are a stronger sentiment signal than sells (code S), which happen for many reasons (diversification, taxes). Use tx_type to monitor one side. Args: \- company (required): ticker / company name / CIK \- limit: number of most-recent Form 4 filings to parse, 1-25 (default 10) \- tx_type: 'all' (default) | 'buy' (code P purchases only) | 'sell' (code S sales only) Returns: {company:{cik, name, ticker}, tx_type, summary:{buys:{count,shares,value}, sells:{count,shares,value}}, count, trades:[{filedAt, owner, relationship, url, transactions:[{date, code, shares, price_per_share, acquired_or_disposed, shares_owned_after}]}], notes}. summary totals cover the whole fetched window regardless of the filter; value = shares x price where a price is reported. Transaction codes: P=open-market purchase, S=open-market sale, M=option exercise, F=shares withheld for tax, A=award/grant, G=gift. acquired_or_disposed: A=acquired, D=disposed. Examples: \- "insider BUYING at Apple" -> {company:'AAPL', tx_type:'buy'} \- "recent insider SELLING at Nvidia" -> {company:'NVDA', tx_type:'sell'} \- "all TSLA insider activity, more history" -> {company:'TSLA', limit:25} Use when: monitoring insider buy/sell activity (officers, directors, 10% owners) for a US-listed company. Larger 'limit' widens the time window. Don't use for: institutional holdings (use get_edgar_13f), Korean companies, or derivative-only detail (option grids are skipped). Errors: unknown company -> use search_edgar_company; a filter with no matching transactions returns count 0 (not… Input parameters: - `company` (string, required): US company: ticker (e.g. 'AAPL', 'BRK-B' or 'BRK.B'), company name, or CIK number - `limit` (integer): Number of most-recent Form 4 filings to parse (default 10) - `tx_type` (string): 'all' (default), 'buy' = open-market purchases (code P) only, 'sell' = sales (code S) only Output parameters: - `company` (object) - `count` (number|null) - `notes` (array) - `summary` (object) - `trades` (array) - `tx_type` ### `get_crypto_ticker` (~419 tokens) Get Crypto Ticker Fetch the current public ticker (last/bid/ask/24h stats) for a crypto trading pair on one exchange. No API key needed. Coinbase, OKX, Upbit and Kraken market data delivery is unavailable pending written redistribution permission. Other exchanges remain under individual rights review; public access is not a redistribution licence. Args: \- symbol: 'BASE/QUOTE' pair, e.g. 'BTC/USDT', 'ETH/USDT', 'BTC/KRW' (default BTC/USDT) \- exchange: binance | upbit | bithumb | coinbase | kraken | okx | bybit | gateio (default binance) Returns: {exchange, symbol, last, bid, ask, high_24h, low_24h, base_volume_24h, quote_volume_24h, timestamp}. Prices are in the QUOTE currency (raw numbers, no scaling). Cached ~10s. Examples: \- "current bitcoin price" -> {symbol:'BTC/USDT'} \- "BTC price in Korea" -> {symbol:'BTC/KRW', exchange:'bithumb'} \- Don't use for candles/history (get_crypto_ohlcv) or cross-exchange premium (compare_crypto_exchanges). Errors: unknown symbol -> check BASE/QUOTE format and the exchange's market list (upbit/bithumb use KRW quotes); geo-blocked exchange -> choose an available source after reviewing its delivery restrictions. Input parameters: - `exchange` (string): Exchange: binance | upbit | bithumb | coinbase | kraken | okx | bybit | gateio (default binance). Coinbase, OKX, Upbit and Kraken market data delivery is unavailable pending written redistribution pe… - `symbol` (string): Trading pair as BASE/QUOTE, e.g. 'BTC/USDT' or 'BTC/KRW' Output parameters: - `ask` - `base_volume_24h` - `bid` - `exchange` (string) - `high_24h` - `last` (number|null) - `low_24h` - `quote_volume_24h` - `symbol` (string) - `timestamp` (string|null) ### `get_crypto_ohlcv` (~545 tokens) Get Crypto OHLCV Candles Fetch OHLCV candlestick data (open/high/low/close/volume) for a crypto pair. No API key needed. Coinbase, OKX, Upbit and Kraken market data delivery is unavailable pending written redistribution permission. Other exchanges remain under individual rights review; public access is not a redistribution licence. Args: \- symbol: 'BASE/QUOTE' pair (default BTC/USDT) \- exchange: binance | upbit | bithumb | coinbase | kraken | okx | bybit | gateio (default binance) \- timeframe: 1m | 5m | 15m | 1h | 4h | 1d | 1w (default 1d) \- since: YYYY-MM-DD start date (optional; exchange returns candles from this date forward) \- limit: 1-500 candles (default 100) \- response_format: 'markdown' (default) or 'json' Returns: {exchange, symbol, timeframe, columns:["ts_iso","open","high","low","close","volume"], rows:[[...], ...]}. Rows ascend by time; prices in QUOTE currency. Cached ~5min. Examples: \- "BTC daily candles for the last 30 days" -> {symbol:'BTC/USDT', timeframe:'1d', limit:30} \- "ETH/KRW hourly since July 1" -> {symbol:'ETH/KRW', exchange:'bithumb', timeframe:'1h', since:'2026-07-01'} \- Don't use for a single current price — use get_crypto_ticker. Errors: unknown symbol -> check BASE/QUOTE and the exchange's markets; unsupported timeframe on an exchange returns the exchange's error. Input parameters: - `exchange` (string): Exchange: binance | upbit | bithumb | coinbase | kraken | okx | bybit | gateio (default binance). Coinbase, OKX, Upbit and Kraken market data delivery is unavailable pending written redistribution pe… - `limit` (integer): Number of candles, 1-500 (default 100) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `since` (string): Start date YYYY-MM-DD (optional) - `symbol` (string): Trading pair as BASE/QUOTE, e.g. 'BTC/USDT' - `timeframe` (string): Candle interval (default 1d) Output parameters: - `columns` (array) - `exchange` (string) - `rows` (array) - `symbol` (string) - `timeframe` (string|null) ### `compare_crypto_exchanges` (~718 tokens) Compare Crypto Price Across Exchanges (Kimchi Premium) Compare the price of one crypto asset on two exchanges, converting both legs to USD, and report the premium of leg B over leg A. Coinbase, OKX, Upbit and Kraken market data delivery is unavailable pending written redistribution permission. Other exchanges remain under individual rights review; public access is not a redistribution licence. The unchanged default second leg is Upbit/KRW and therefore currently returns a rights error. Select another available exchange explicitly. Example calculation: the Korean "kimchi premium" — e.g. base:'BTC', exchange_a:'binance', quote_a:'USDT', exchange_b:'bithumb', quote_b:'KRW' -> premium_pct is how much more expensive BTC is on bithumb (in USD terms) than on binance. Args: \- base: asset symbol, e.g. 'BTC', 'ETH', 'XRP' (default BTC) \- exchange_a / quote_a: first leg (defaults binance / USDT) \- exchange_b / quote_b: second leg (defaults upbit / KRW) \- Supported quotes: USD, USDT, USDC (treated as 1 USD, noted in output) and KRW (converted with the latest Federal Reserve H.10 KRW-per-USD noon buying rate). Returns: {base, legs:[{exchange, symbol, last, last_usd}], premium_pct, fx:{pair:'USD/KRW', rate, date, source:'Federal Reserve H.10'}, notes}. premium_pct = (leg_b_usd / leg_a_usd - 1) * 100. Examples: \- "compare BTC on two available exchanges" -> {exchange_a:'binance', quote_a:'USDT', exchange_b:'bybit', quote_b:'USDT'} \- "ETH premium bithumb vs binance" -> {base:'ETH', exchange_a:'binance', quote_a:'USDT', exchange_b:'bithumb', quote_b:'KRW'} \- Don't use for a single price (get_crypto_ticker) or history (get_crypto_ohlcv). Errors: unknown symbol on either exchange -> check the exchange's market list (upbit/bithumb list KRW pairs only); unsupported quote currency lists the supported ones; an unavailable H.10 release blocks KRW conversion with a hint. Input parameters: - `base` (string): Base asset symbol, e.g. 'BTC', 'ETH' - `exchange_a` (string): First-leg exchange: binance | upbit | bithumb | coinbase | kraken | okx | bybit | gateio (default binance). Coinbase, OKX, Upbit and Kraken market data delivery is unavailable pending written redistr… - `exchange_b` (string): Second-leg exchange: binance | upbit | bithumb | coinbase | kraken | okx | bybit | gateio (default upbit). Coinbase, OKX, Upbit and Kraken market data delivery is unavailable pending written redistri… - `quote_a` (string): First-leg quote currency (USD | USDT | USDC | KRW) - `quote_b` (string): Second-leg quote currency (USD | USDT | USDC | KRW) Output parameters: - `base` (string|null) - `fx` - `legs` (array) - `notes` (array) - `premium_pct` (number|null) ### `compare_financials_kr_us` (~498 tokens) Compare KR vs US Company Financials Compare annual financial statements of a Korean listed company (source: OpenDART, K-IFRS) and a US listed company (source: SEC EDGAR, US-GAAP) side by side, with KRW values converted to USD using Federal Reserve H.10 annual-average exchange rates. Args: \- kr_company: Korean company name / 6-digit stock code / DART corp_code (e.g. '삼성전자', '005930') \- us_company: US ticker / name / CIK (e.g. 'AAPL', 'Apple') \- years: number of recent fiscal years, 1-5 (default 3) \- metrics: subset of [revenue, gross_profit, operating_income, net_income, eps_diluted, assets, liabilities, equity, cash_and_equivalents, operating_cash_flow] \- response_format: 'markdown' (default) or 'json' Returns per-metric, per-year rows: {fiscal_year, kr_krw, kr_usd, us_usd, ratio_kr_over_us} plus the FX rates used and accounting-basis caveats. Examples: \- "삼성전자 vs Apple 최근 3년 매출·영업이익 비교" -> {kr_company:'삼성전자', us_company:'AAPL', metrics:['revenue','operating_income']} \- Don't use for quarterly data (annual only) or non-KR/US companies. Errors: unknown company names suggest using search_dart_company / search_edgar_company first. Input parameters: - `kr_company` (string, required): Korean company: name (e.g. '삼성전자'), 6-digit stock code (e.g. '005930'), or 8-digit DART corp_code - `metrics` (array): Metrics to compare (default: revenue, operating_income, net_income, assets, equity). Available: revenue, gross_profit, operating_income, net_income, eps_diluted, assets, liabilities, equity, cash_and… - `response_format` (string): 'markdown' for tables, 'json' for compact machine-readable output - `us_company` (string, required): US company: ticker (e.g. 'AAPL'), company name, or CIK - `years` (integer): How many recent fiscal years to compare (default 3) Output parameters: - `comparison` (array) - `fx` - `kr` (object) - `metrics` (array) - `notes` (array) - `us` ### `get_db_schema` (~415 tokens) FinBridge DB Schema Inspect the schema of the local finbridge database (SQLite with ingested KR/US company fundamentals, filings, and daily prices): tables, views, columns, per-table row counts (counted in the background and refreshed every 30 minutes; null with rows_note "counting…" right after a server start), and ready-to-run example queries for query_db. Read this before writing a query_db statement. It returns no company data itself — get_db_schema describes the tables, query_db runs the SELECT. Args: (none) Returns: {tables: [{name, columns: [{name, type}], rows}], views: [{name, columns: [{name, type}]}], examples: [sql_string]} Key objects: \- companies: KR companies have source='dart' + stock_code (6-digit), US companies source='edgar' + ticker \- financials: one row per company x fiscal_year x quarter (quarter=0 = annual); raw unscaled KRW/USD amounts \- prices_daily: daily OHLCV per company_id \- views v_financials (financials joined with company name/ticker/stock_code) and v_latest_annual (latest annual row per company) — prefer these in query_db Examples: \- Call before writing SQL for query_db, to learn table/column names. \- Check row counts to see how much data the nightly ingest has loaded. Use when: preparing a query_db, or checking ingest coverage. Don't use for market data itself (get_stock_prices / get_valuation / the screeners read the same tables with the right joins already done). FinBridge has no real-time equity quote tool — equity prices here are end-of-day closes from the nightly ingest; the only live data is crypto (get_crypto_ticker) and regulator filings (get_dart_filings / get_edgar_filings). Errors: 'database has not been built yet' — the ingest pipeline has not run on the server. Output parameters: - `examples` (array) - `rows_note` (string) - `tables` (array) - `views` (array) ### `query_db` (~639 tokens) FinBridge DB Read-Only SQL Run a single read-only SELECT query against the local finbridge database (ingested KR/US fundamentals, filings, daily prices). The statement must start with SELECT or WITH; multiple statements, PRAGMA, and any write/DDL keywords (INSERT/UPDATE/DELETE/DROP/ALTER/CREATE/ATTACH/...) are rejected. The query runs in a separate read-only process with SQLite authorization, a 2-second deadline, two concurrent queries per server process, and a 1 MB result budget. Free accounts cannot query raw history or history views; the latest-annual snapshot remains available. The escape hatch for questions no dedicated tool answers — Japan, Taiwan and Europe are largely reachable only this way. Prefer screen_companies for ordinary fundamental screens (it handles per-market period and currency rules that a hand-written query will get wrong), and call get_db_schema first for the table shapes. Args: \- sql: one SELECT (or WITH ... SELECT) statement. A single trailing ';' is tolerated. \- limit: max rows returned, 1-500 (default 50) \- response_format: 'markdown' (default, table) or 'json' (compact) Returns: {columns: [name], rows: [[cell, ...]], row_count, truncated} — truncated=true means more rows matched than 'limit'. Examples (v_financials / v_latest_annual views are the easiest entry points): \- Largest companies by latest annual revenue: "SELECT name, ticker, stock_code, fiscal_year, revenue FROM v_latest_annual ORDER BY revenue DESC LIMIT 10" \- Samsung Electronics annual trend: "SELECT fiscal_year, revenue, operating_income, net_income FROM v_financials WHERE stock_code = '005930' AND quarter = 0 ORDER BY fiscal_year DESC" \- KR vs US company counts: "SELECT source, COUNT(*) AS n FROM companies GROUP BY source" \- Recent Samsung Electronics closes: "SELECT date, close FROM prices_daily p JOIN companies c ON c.id = p.company_id WHERE c.stock_code = '005930' ORDER BY date DESC LIMIT 20" (prices_daily holds KR, US, TW; US history starts 2023-03-28) Use when: custom aggreg… Input parameters: - `limit` (integer): Max rows returned, 1-500 (default 50) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `sql` (string, required): A single read-only SELECT (or WITH ... SELECT) statement Output parameters: - `columns` (array) - `row_count` (number) - `rows` (array) - `truncated` (boolean) ### `screen_companies` (~1430 tokens) Screen Companies (FinBridge DB) Screen companies across five markets on annual fundamentals stored in the local finbridge database: Korea (DART), the US (SEC EDGAR), Taiwan (TWSE/TPEx), Japan (EDINET) and Europe (ESEF/IFRS). Filters and sorting run on standard metrics plus derived ratios; Annual rows (quarter=0) are the default. When a single market has no annual rows and fiscal_year is omitted, the screen falls back to that market's latest reported period. This fallback is not used for market='all'; do not compare a partial-year result with annual revenue. Base amounts are in each company's reporting currency — KRW, USD, TWD, JPY, or for Europe whatever the filer reports in (EUR, DKK, SEK, NOK, PLN, ...) — so absolute-value thresholds are market-dependent and cross-market (market='all') screens work best with ratio metrics (margins, roe, debt_ratio). Not this tool for: price or technical signals (screen_technical and the four named strategy screens), funds (screen_etfs), one company in depth (get_valuation), or statements straight from the regulator (get_dart_financials / get_edgar_financials). Coverage note: Taiwan carries only the latest reported period, because TWSE publishes a snapshot rather than history, and it has no annual row at all until an FY Q4 statement publishes — so roe, psr and the 3-year CAGRs are empty for every Taiwanese company, and cash / operating cash flow are unavailable there at any depth (the TWSE OpenAPI publishes no cash-flow statement and its balance sheet carries no cash line). Screen Taiwan on revenue, margins, EPS and the balance-sheet totals; use market='kr' or 'us' when the screen depends on a return, a multiple or a growth rate. Europe is still loading and is thinner than the others: about 1 in 8 rows has no operating_income (the filer tags it with a company extension rather than the IFRS concept) and about 1 in 5 has no revenue (banks and investment entities report interest revenue or fair-value gains, not a single IFRS revenue total — we leave the column em… Input parameters: - `filters` (array): Up to 5 metric filters, ANDed together - `fiscal_year` (integer): Specific fiscal year; omit to use each company's latest annual report - `limit` (integer): Max rows, 1-100 (default 20) - `market` (string): Market: 'kr' (DART), 'us' (EDGAR), 'tw' (TWSE/TPEx), 'jp' (EDINET), 'eu' (ESEF), or 'all' (default) - `order` (string): Sort direction (default desc) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `sort_by` (string): Metric to sort by (default revenue) Output parameters: - `count` (number) - `data_as_of` - `fiscal_year` (number|string) - `market` (string) - `notes` - `order` - `period` (string|null) - `rows` (array) - `sort_by` ### `get_stock_prices` (~711 tokens) Daily Stock Prices (FinBridge DB) Get daily OHLCV price history from the local finbridge database (populated by the nightly ingest jobs). Rows are returned newest first. Listed equities and ETFs. Crypto has its own feed (get_crypto_ohlcv); Japan and Europe carry no prices at all. Price coverage by market — we only store what we have redistribution rights to: \- Korea (DART + Financial Services Commission): full daily history, corporate-action adjusted. SERVED. \- Taiwan (TWSE OpenAPI, Open Government Data License): daily history. SERVED. \- US (Databento EQUS.SUMMARY): daily history from 2023-03-28. SERVED. Split-adjusted; dividend-adjusted closes exist where SEC-reported dividends do (adj_close). \- Japan: NOT served. EDINET publishes disclosure documents, not prices, so we hold Japanese filings and the company master but no quotes. Args: \- company: a ticker (US 'AAPL', TW/JP 4-digit '2330'), a KR 6-digit stock code ('005930'), or a company name in the local language or English ('TSMC', 'Toyota', '삼성전자'). Resolution priority: exact ticker > 6-digit KR code > exact name (name or English name) > partial name (multiple partial matches return a candidate list error). \- from / to: optional YYYY-MM-DD range bounds (inclusive) \- limit: max rows, 1-500 (default 60) \- response_format: 'markdown' (default) or 'json' Account limits: a free account includes the most recent 130 trading sessions of each name. Results follow the current account's history entitlement. When the window is trimmed the response carries a plan_limit field saying so. Returns: {company: {name, source, ticker|stock_code}, count, truncated, prices: [{date, open, high, low, close, volume}]} — newest date first; truncated=true means older rows exist beyond 'limit'. Examples: \- {company: '005930', limit: 30} -> last 30 KR trading days for Samsung Electronics \- {company: '005930', from: '2026-01-01', to: '2026-06-30'} -> Samsung Electronics H1 2026 Use when: historical closes/volumes for charting or return calculations… Input parameters: - `company` (string, required): KR 6-digit stock code (e.g. '005930') or company name - `from` (string): Start date YYYY-MM-DD (inclusive) - `limit` (integer): Max rows, 1-500 (default 60), newest first - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `to` (string): End date YYYY-MM-DD (inclusive) Output parameters: - `company` (object) - `count` (number) - `data_as_of` - `data_notes` (object) - `plan_limit` (object) - `prices` (array) - `truncated` (boolean) ### `screen_etfs` (~1120 tokens) Screen ETFs (FinBridge DB) Screen exchange-traded funds in the local finbridge database on the things that actually distinguish an ETF: premium/discount to NAV, fund size (AUM), the index it tracks, price momentum, and — for US funds — the audited calendar-year TOTAL return from the fund's own prospectus. Funds only. Operating companies are screened by screen_companies (fundamentals) or screen_technical / the four named strategy screens (price signals). ⚠These funds are excluded from screen_companies by construction: that tool ranks on annual financial statements, which funds do not file. Coverage differs by market and the response says so per row: \- KR (1,170 listed ETFs): NAV, AUM (net assets, KRW), listed units and the tracked index come from the same daily feed as prices, 2020-01-02 onward. premium_pct is close/NAV-1 computed on the SAME day (mixing dates would be meaningless). \- US (5,868 ETFs): no NAV or AUM source exists that we may redistribute, so those fields are null. Instead total_return_pct carries the fund's audited calendar-year total return (distributions reinvested) from SEC prospectus data — the only distribution-inclusive number available. ⚠ret_20d / ret_120d are PRICE returns in every market: ETF distributions are not in the daily bars, so income funds look worse than they were. For US funds compare against total_return_pct to see the gap. ⚠aum is in the listing currency (KRW today). Do not rank across markets on it. ⚠total_return_pct is pinned to ONE calendar year across all rows (reported as total_return_year), because prospectus refresh dates differ per fund — ranking a 2024 figure against a 2025 one would be a silently wrong table. Args: \- market: 'kr', 'us', or 'all' (default) \- min_aum: minimum net assets in listing currency (KR only; e.g. 100000000000 = 1,000억) \- max_abs_premium_pct: keep funds trading within this |premium| of NAV, e.g. 0.5 \- min_premium_pct: keep funds at or above this premium (negative values find discounts) \- min_price, min_vo… Input parameters: - `index_contains` (string): Substring of the tracked index name ('TR' for total-return indices) - `limit` (integer): Max rows, 1-100 (default 20) - `market` (string): Market: 'kr', 'us', or 'all' (default) - `max_abs_premium_pct` (number): Keep funds within this |premium to NAV| in percent - `min_aum` (number): Minimum net assets in listing currency (KR only; US is null) - `min_premium_pct` (number): Keep funds at or above this premium in percent (negative finds discounts) - `min_price` (number): Minimum last close in listing currency - `min_volume` (number): Minimum 20-session average volume - `name_contains` (string): Substring of the fund name or ticker - `order` (string): Sort direction (default desc) - `response_format` (string): 'markdown' for a table, 'json' for compact output - `sort_by` (string): Sort key (default aum) - `total_return_year` (integer): Calendar year for total_return_pct; omit for the best-covered year (the response says which) Output parameters: - `count` (number) - `data_as_of` - `market` (string) - `order` - `rows` (array) - `sort_by` (string|null) - `total_return_year` (number|null) ### `get_tw_insider_transfers` (~840 tokens) Taiwan Insider Share-Transfer Pre-Announcements Taiwan insider share-transfer filings from TWSE (上市) and TPEx (上櫃), served from the local finbridge database. ⚠These are PRE-ANNOUNCEMENTS, not executed trades. Taiwan requires directors, supervisors, managers and 10% shareholders to declare a transfer BEFORE selling (內部人持股轉讓事前申報). There is no "sold" table at all — a declaration says what someone intends to transfer and by when. What does exist is the opposite: an 未轉讓 (not-transferred) table listing declarations whose window expired without a sale, with the filer's stated reason. This tool returns both. This is why it is a separate tool from get_dart_insider_trades (Korea) and get_edgar_insider_trades (US Form 4), which report trades that already happened. Do not compare the numbers across those tools as if they were the same event. ⚠Coverage is short and has permanent holes. The upstream endpoints publish only the CURRENT day's table — there is no historical query — so our history starts when we began collecting and any day the collector missed is unrecoverable. The response's coverage.first_report_date and coverage.days say exactly how much history exists; "no rows" for an earlier date means we never had it, not that nobody filed. ⚠No rankings or aggregates in this version (no "most-sold-by-insiders this month"). A few days of snapshots is not a sample. Units are SHARES (股) — not the thousands of shares used by Taiwan margin data. No monetary conversion is done: planned shares times a closing price is not a transaction value. Role, method and reason strings are returned in the original Chinese so they can be checked against the source. Args: \- company: optional filter — TW 4-digit code, '2330.TW', 'tw:2330', or the company name \- from / to: report_date range (YYYY-MM-DD) \- role: substring of the declarant's role in Chinese (董事 / 監察人 / 經理人 / 大股東 / 法人董事代表人) \- min_shares: minimum planned_shares (applies to the transfer table only) \- include_untransferred: also return expired declarations that were no… Input parameters: - `company` (string): TW company filter: 4-digit code, '2330.TW', 'tw:2330', or name - `from` (string): Earliest report date (YYYY-MM-DD) - `include_untransferred` (boolean): Also return expired declarations that were not acted on (default true) - `limit` (integer): Max rows per table, 1-200 (default 50) - `min_shares` (number): Minimum planned shares (股); transfer table only - `response_format` (string): 'markdown' for tables, 'json' for compact output - `role` (string): Substring of the declarant role in Chinese (董事 / 監察人 / 經理人 / 大股東) - `to` (string): Latest report date (YYYY-MM-DD) Output parameters: - `company` (object) - `coverage` (object) - `data_as_of` - `market` (string) - `notes` (array) - `page_url` - `range` (object) - `transfers` (array) - `untransferred` (array) ### `get_technicals` (~699 tokens) Technical Indicators (FinBridge DB) Latest technical-indicator snapshot for a single KR or US company from the local finbridge database (indicators_latest, refreshed by the nightly 'indicators' ingest from daily prices), plus an optional on-demand historical series and a plain-language signal summary. One company at a time. To rank many companies on the same indicators use screen_technical; for valuation multiples on one company use get_valuation. Indicators: SMA 5/20/60/120, EMA 12/26, RSI(14, Wilder), MACD(12,26,9), Bollinger(20,2), ATR(14), 52-week high/low and % distance, returns over 1/5/20/60/120/250 trading days, 20-day volume ratio, above-SMA20/60 flags, and SMA20xSMA60 golden/dead cross (within the last 3 sessions). Args: \- company: US ticker (e.g. 'AAPL'), KR 6-digit stock code (e.g. '005930'), or company name. Resolution: exact ticker > 6-digit code > exact name > partial name. \- history: 0-250 (default 0). 0 = latest snapshot only; >0 recomputes the last N sessions of close/sma20/sma60/rsi14/macd on the fly (not stored). \- response_format: 'markdown' (default) or 'json'. Returns: {company:{name,source,ticker|stock_code}, as_of, indicators:{...all snapshot fields...}, signals:[text], history:[{date,close,sma20,sma60,rsi14,macd}], notes}. Examples: \- {company: 'AAPL'} -> Apple's latest snapshot + signal summary \- {company: '005930', history: 60} -> Samsung Electronics snapshot + last 60 sessions of sma/rsi/macd Use when: reading one company's momentum/trend/overbought-oversold state, or charting an indicator series. Don't use to rank many companies (use screen_technical). FinBridge has no real-time equity quote tool — equity prices here are end-of-day closes from the nightly ingest; the only live data is crypto (get_crypto_ticker) and regulator filings (get_dart_filings / get_edgar_filings). Notes: KR/US/TW prices are adjusted for corporate actions but not dividends (indicators around dividend events may be slightly distorted); US history starts 2023-03-28 (volume from 2024-… Input parameters: - `company` (string, required): US ticker (e.g. 'AAPL'), KR 6-digit stock code (e.g. '005930'), or company name - `history` (integer): 0 = latest snapshot only; 1-250 = also return that many recent sessions of close/sma20/sma60/rsi14/macd - `response_format` (string): 'markdown' for tables, 'json' for compact machine-readable output Output parameters: - `as_of` - `company` (object) - `data_as_of` - `history` (array) - `indicators` (object) - `notes` - `peer_comparison` - `signals` (array) ### `screen_technical` (~1041 tokens) Screen by Technical Signals (FinBridge DB) Screen KR/US companies by technical signals over the latest indicator snapshots (v_indicators / indicators_latest, refreshed nightly). Signals and the sort key are fixed whitelists mapped to SQL predicates; every threshold is bound as a parameter, so inputs are never interpolated into SQL. This is the open-ended technical screen: you pick the signals and thresholds. The four named strategies are fixed checklists instead (screen_minervini, screen_canslim, screen_kell, screen_schwartz). Not this tool for: fundamentals (screen_companies) or funds (screen_etfs). Args: \- market: 'kr' (DART), 'us' (EDGAR), or 'all' (default) \- signals: any of golden_cross, dead_cross, rsi_oversold (RSI<30), rsi_overbought (RSI>70), near_52w_high (within 3% of high), near_52w_low, above_sma20, volume_surge (vol_ratio>=2), macd_bullish (macd_hist>0), rs_leader (RS rating >=80 vs home market), rs_outperform (RS rating >=60). ANDed together; omit for none. \- min_price: optional minimum close; min_vol_avg20: optional minimum 20-day average volume (liquidity filter) \- sort_by: ret_1d|ret_5d|ret_20d|ret_60d|ret_120d|ret_250d|rsi14|vol_ratio|pct_from_52w_hi|pct_from_52w_lo|close|atr14|rs_pctile|rs_120d (default ret_20d) \- order: 'asc'|'desc' (default 'desc'); limit: 1-100 (default 20); response_format: 'markdown'|'json' Relative strength (rs_pctile 1-99, rs_120d) measures each stock vs its OWN national market (KR vs the KR universe, US vs the US universe): rs_pctile is the national percentile of blended 3/6/12-month momentum (IBD-style; 99=strongest); rs_120d is 6-month excess return in pp over the national median. Returns: {count, market, signals, sort_by, order, rows:[{name, source, ticker|stock_code, as_of, close, rsi14, macd_hist, ret_5d, ret_20d, ret_60d, vol_ratio, pct_from_52w_hi, pct_from_52w_lo, golden_cross, dead_cross, above_sma20, rs_pctile, rs_120d}]}. Examples: \- Oversold KR names by 20-day return: {market:'kr', signals:['rsi_oversold'], sort_by:'ret_20d', order:'a… Input parameters: - `limit` (integer): Max rows, 1-100 (default 20) - `market` (string): Market: 'kr' (default), 'us', 'tw', or 'all'. Japan has no redistributable price source, so it is not screenable. - `min_price` (number): Minimum close price filter - `min_vol_avg20` (number): Minimum 20-day average volume (liquidity filter) - `order` (string): Sort direction (default desc) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `signals` (array): Technical signals to require (ANDed): golden_cross, dead_cross, rsi_oversold, rsi_overbought, near_52w_high, near_52w_low, above_sma20, volume_surge, macd_bullish, rs_leader (RS>=80), rs_outperform (… - `sort_by` (string): Column to sort by (default ret_20d) Output parameters: - `count` (number) - `criteria` (object) - `data_as_of` - `market` (string) - `notes` - `order` - `rows` (array) - `signals` (array) - `sort_by` (string|null) - `us_note` ### `get_valuation` (~774 tokens) Company Valuation (FinBridge DB) Get the latest valuation snapshot for one KR, US, or Taiwan company from the local finbridge database: market cap (latest close x shares) with PER, PBR, PSR, ROE, debt ratio, and 3-year revenue/net-income CAGR, joined to the company's latest annual fundamentals. Includes metric-level calculation basis, dates, sources, missing reasons, and 1-2 same-market percentile hints. Computed by the nightly valuation ingest job. Share counts: KR uses data.go.kr listed shares, US prefers SEC-reported shares, and Taiwan uses exchange-reported shares; the nightly job can fall back to net_income / eps_diluted when a positive result is available. PER prefers price / eps_diluted, falling back to market_cap / net_income. Taiwan exchange-published PER/PBR replace derived values when present. Any derived ratio whose required denominator is null or <= 0 is returned as null. Args: \- company: US ticker (e.g. 'AAPL'), KR 6-digit stock code (e.g. '005930'), or company name. Resolution priority: exact ticker > 6-digit code > exact name > partial name (multiple partial matches return a candidate-list error). \- per_multiples: optional 1-5 positive user-supplied PER assumptions (maximum 1000) \- pbr_multiples: optional 1-5 positive user-supplied PBR assumptions (maximum 100) \- response_format: 'markdown' (default) or 'json' Returns the existing valuation fields plus metric_evidence and multiple_scenarios. Ratios are plain numbers; roe/debt_ratio/CAGR and scenario upside/downside are in percent. A scenario is arithmetic from the user's multiple, not a target-price recommendation. If no multiple is supplied, no multiple or target price is invented. Examples: \- {company: '005930'} -> Samsung Electronics PER/PBR/ROE plus "PER in the cheapest N% of the KR market" \- {company: 'AAPL'} -> Apple valuation snapshot with US-market percentiles Caveats: if statements are in another currency than the listing (Korean listings reporting in USD/CNY/JPY), statement values are converted at one Fed… Input parameters: - `company` (string, required): US ticker (e.g. 'AAPL'), KR 6-digit stock code (e.g. '005930'), or company name - `pbr_multiples` (array): Optional 1-5 positive PBR assumptions supplied by the user; no default is invented - `per_multiples` (array): Optional 1-5 positive PER assumptions supplied by the user; no default is invented - `response_format` (string): 'markdown' for a table + interpretation, 'json' for compact machine-readable output Output parameters: - `as_of` - `company` (object) - `currency` - `data_as_of` - `debt_ratio` - `fiscal_year` (number|null) - `fx_conversion` - `interpretation` - `market_cap` - `metric_evidence` - `multiple_scenarios` - `ni_cagr_3y` - `notes` - `pbr` - `peer_comparison` - `peer_context` - `per` - `price` - `psr` - `rev_cagr_3y` - `roe` - `shares` - `ttm` - `updated_at` ### `screen_minervini` (~1248 tokens) Minervini Trend Template Screener (FinBridge DB) Screen KR, US and/or TW stocks that pass Mark Minervini's 8-point Trend Template (from "Trade Like a Stock Market Wizard"), evaluated on the nightly indicators_latest snapshot (daily corporate-action-adjusted KR prices). Returns stage-2 uptrend leaders, sorted by relative strength by default. One of four named strategy screens (this one, screen_canslim, screen_kell, screen_schwartz), each a fixed published checklist. Not this tool for: thresholds you choose yourself (screen_technical), fundamentals (screen_companies) or funds (screen_etfs). The 8 criteria (all required): 1\. Price above the 150-day and 200-day moving averages 2\. 150-day MA above the 200-day MA 3\. 200-day MA rising (vs ~1 month ago) [can be relaxed via require_sma200_rising] 4\. 50-day MA above both the 150- and 200-day MAs 5\. Price above the 50-day MA 6\. Price at least 'above_low_pct'% above its 52-week low (default 25) 7\. Price within 'near_high_pct'% of its 52-week high (default 25) 8\. RS rating >= 'rs_min' (default 70), where RS is the national percentile (1-99) of blended 3/6/12-month momentum vs the stock's own market Optionally also require a Volatility Contraction Pattern base via require_vcp. VCP detection here is an APPROXIMATION (heuristic swing/contraction count, not a discretionary chart read) and can miss valid bases or flag false positives. Args: \- market: 'kr' (DART/KOSPI+KOSDAQ), 'us' (EDGAR), or 'all' (default) \- rs_min: minimum RS percentile 1-99 (default 70; Minervini prefers higher) \- near_high_pct: max % below the 52-week high (default 25; smaller = tighter/closer to high) \- above_low_pct: min % above the 52-week low (default 25) \- require_sma200_rising: require criterion 3 (default true) \- require_vcp: also require a heuristically-detected VCP base (vcp_setup=1) (default false; VCP is approximate) \- min_vol_avg20: optional minimum 20-day average volume (liquidity filter; recommended to exclude illiquid microcaps) \- min_price: optional minimum… Input parameters: - `above_low_pct` (number): Min % above the 52-week low (default 25) - `limit` (integer): Max rows, 1-50 (default 20) - `market` (string): Market: 'kr' (default), 'us', 'tw', or 'all'. Japan has no redistributable price source, so it is not screenable. - `min_price` (number): Minimum close price (Minervini avoids low-priced stocks; e.g. 10 for US$, 5000 for KRW) - `min_vol_avg20` (number): Minimum 20-day average volume (liquidity filter) - `near_high_pct` (number): Max % below the 52-week high (default 25) - `order` (string): Sort direction (default desc) - `require_sma200_rising` (boolean): Require the 200-day MA to be rising (criterion 3) - `require_vcp` (boolean): Also require a heuristically-detected VCP base (vcp_setup=1). VCP detection is approximate. - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `rs_min` (integer): Minimum RS percentile (default 70) - `sort_by` (string): Sort column (default rs_pctile) Output parameters: - `count` (number) - `criteria` (object) - `data_as_of` - `market` (string) - `notes` - `order` - `rows` (array) - `signals` (array) - `sort_by` (string|null) - `us_note` ### `screen_canslim` (~1420 tokens) CAN SLIM Screener (FinBridge DB) Screen KR and/or US stocks against William O'Neil's CAN SLIM checklist (as taught by David Ryan), joining the nightly valuation_latest (earnings/sales growth, ROE, PER) and indicators_latest (relative strength, distance from the 52-week high) snapshots. Returns fundamentally strong momentum leaders, sorted by RS by default. One of four named strategy screens (this one, screen_minervini, screen_kell, screen_schwartz), each a fixed published checklist. Not this tool for: thresholds you choose yourself (screen_technical), fundamentals (screen_companies) or funds (screen_etfs). Only C, A, N, S, L are coded as filters — I (institutional sponsorship) and M (market direction) require fund-flow and index-level data that cannot be evaluated from a single stock's snapshot, so they are intentionally omitted: C — Current quarterly earnings: latest-quarter diluted-EPS YoY >= c_min (default 25). Quarter codes compare like-for-like a year apart (1=Q1, 2=cumulative half, 3=Q3). A — Annual earnings & quality: latest annual diluted-EPS YoY >= a_min (default 25) AND ROE >= roe_min (default 17) N — New highs: price within near_high_pct% of the 52-week high (default 15) S — Sales: latest annual revenue YoY > 0 when require_sales is true (default true) L — Leader: RS rating (national percentile 1-99) >= rs_min (default 80) A metric that is NULL (e.g. growth base was a loss, so the sign-flipped percentage is dropped) fails its comparison and the stock is excluded. Args: \- market: 'kr' (DART/KOSPI+KOSDAQ), 'us' (EDGAR), or 'all' (default) \- c_min: min latest-quarter EPS YoY %, CAN SLIM C (default 25) \- a_min: min latest-annual EPS YoY %, CAN SLIM A (default 25) \- roe_min: min ROE %, quality gate under A (default 17) \- rs_min: min RS percentile 1-99, CAN SLIM L (default 80) \- near_high_pct: max % below the 52-week high, CAN SLIM N (default 15; smaller = closer to the high) \- require_sales: require positive annual revenue growth, CAN SLIM S (default true) \- min_… Input parameters: - `a_min` (number): Min latest-annual EPS YoY % — CAN SLIM A (default 25) - `c_min` (number): Min latest-quarter EPS YoY % — CAN SLIM C (default 25) - `limit` (integer): Max rows, 1-50 (default 20) - `market` (string): Market: 'kr' (default), 'us', or 'all'. ⚠Taiwan is not offered here — TWSE publishes a cumulative snapshot with no quarterly EPS growth or ROE, so every row would fail C/A silently. - `min_price` (number): Min close price (O'Neil avoids low-priced stocks; e.g. 10 for US$, 5000 for KRW) - `min_vol_avg20` (number): Min 20-day average volume (liquidity filter) - `near_high_pct` (number): Max % below the 52-week high — CAN SLIM N (default 15) - `order` (string): Sort direction (default desc) - `require_sales` (boolean): Require positive annual revenue growth — CAN SLIM S (default true) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `roe_min` (number): Min ROE % — quality gate under CAN SLIM A (default 17) - `rs_min` (integer): Min RS percentile 1-99 — CAN SLIM L (default 80) - `sort_by` (string): Sort column (default rs_pctile) Output parameters: - `count` (number) - `criteria` (object) - `data_as_of` - `market` (string) - `notes` - `order` - `rows` (array) - `signals` (array) - `sort_by` (string|null) - `us_note` ### `screen_kell` (~1146 tokens) Oliver Kell Cycle Screener — approximation (FinBridge DB) Screen KR, US and/or TW stocks for an Oliver Kell "Cycle of Price Action" long setup, evaluated on the nightly indicators_latest snapshot (daily corporate-action-adjusted KR prices). One of four named strategy screens (this one, screen_minervini, screen_canslim, screen_schwartz), each a fixed published checklist. Not this tool for: thresholds you choose yourself (screen_technical), fundamentals (screen_companies) or funds (screen_etfs). APPROXIMATION: Oliver Kell's method is discretionary — his full cycle (reversal extension, EMA crossback, wedge pop, base-n-break, exhaustion) is a chart read, not a formula. This screener only proxies ONE phase: "a relative-strength leader in an uptrend, riding its short-term EMAs and not over-extended". It will miss real Kell setups and flag stocks that are not. Conditions (all required): \- close > 20-day EMA (uptrend, holding the 20EMA) \- price is 0..'max_ext_pct'% above the 10-day EMA (above support but not exhausted) \- RS percentile >= 'rs_min' (a leader) \- if require_ema_stack: 10-day EMA > 20-day EMA (rising short-term stack) Args: \- market: 'kr', 'us', or 'all' (default) \- rs_min: minimum RS percentile 1-99 (default 80; Kell trades leaders) \- max_ext_pct: max % above the 10-day EMA before treating it as over-extended (default 15) \- require_ema_stack: require 10EMA > 20EMA (default true) \- min_vol_avg20: optional minimum 20-day average volume (liquidity filter) \- min_price: optional minimum close price (avoid low-priced stocks; e.g. 10 for US$, 5000 for KRW) \- sort_by: rs_pctile|pct_from_ema10|ret_20d|ret_5d|macd_hist|close (default rs_pctile) \- order: 'asc'|'desc' (default 'desc'); limit: 1-50 (default 20); response_format: 'markdown'|'json' Returns: {count, market, criteria:{rs_min, max_ext_pct, require_ema_stack}, rows:[{name, source, ticker|stock_code, as_of, close, ema10, ema20, pct_from_ema10, macd_hist, rs_pctile, ret_20d}]}. Examples: \- US leaders on EMA support: {market:'us', min_vol_a… Input parameters: - `limit` (integer): Max rows, 1-50 (default 20) - `market` (string): Market: 'kr' (default), 'us', 'tw', or 'all'. Japan has no redistributable price source, so it is not screenable. - `max_ext_pct` (number): Max % above the 10-day EMA before over-extended (default 15) - `min_price` (number): Minimum close price (avoid low-priced stocks; e.g. 10 for US$, 5000 for KRW) - `min_vol_avg20` (number): Minimum 20-day average volume (liquidity filter) - `order` (string): Sort direction (default desc) - `require_ema_stack` (boolean): Require 10-day EMA > 20-day EMA (default true) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `rs_min` (integer): Minimum RS percentile (default 80) - `sort_by` (string): Sort column (default rs_pctile) Output parameters: - `count` (number) - `criteria` (object) - `data_as_of` - `market` (string) - `notes` - `order` - `rows` (array) - `signals` (array) - `sort_by` (string|null) - `us_note` ### `screen_schwartz` (~1073 tokens) Marty Schwartz 10-EMA + MACD Screener — approximation (FinBridge DB) Screen KR, US and/or TW stocks for a Marty Schwartz short-term momentum setup, evaluated on the nightly indicators_latest snapshot (daily corporate-action-adjusted KR prices). One of four named strategy screens (this one, screen_minervini, screen_canslim, screen_kell), each a fixed published checklist. Not this tool for: thresholds you choose yourself (screen_technical), fundamentals (screen_companies) or funds (screen_etfs). APPROXIMATION: Marty Schwartz is a discretionary short-term trader; this screener only proxies his "10-day EMA green light + MACD momentum" principle. It is not his full method (which includes intraday timing, tape reading, and risk discretion). Expect false positives and misses. Conditions (all required): \- close > 10-day EMA (Schwartz's "green light") \- if require_macd_bull: MACD histogram > 0 (momentum bullish) \- RS percentile >= 'rs_min' \- price <= 'max_ext_pct'% above the 10-day EMA (not over-extended) Args: \- market: 'kr', 'us', or 'all' (default) \- rs_min: minimum RS percentile 1-99 (default 60) \- require_macd_bull: require MACD histogram > 0 (default true) \- max_ext_pct: max % above the 10-day EMA before over-extended (default 12) \- min_vol_avg20: optional minimum 20-day average volume (liquidity filter) \- min_price: optional minimum close price (avoid low-priced stocks; e.g. 10 for US$, 5000 for KRW) \- sort_by: rs_pctile|pct_from_ema10|ret_20d|ret_5d|macd_hist|close (default rs_pctile) \- order: 'asc'|'desc' (default 'desc'); limit: 1-50 (default 20); response_format: 'markdown'|'json' Returns: {count, market, criteria:{rs_min, require_macd_bull, max_ext_pct}, rows:[{name, source, ticker|stock_code, as_of, close, ema10, ema20, pct_from_ema10, macd_hist, rs_pctile, ret_20d}]}. Examples: \- US short-term momentum, liquid: {market:'us', min_vol_avg20: 500000} \- KR names on a fresh 10EMA green light, tight: {market:'kr', rs_min: 70, max_ext_pct: 6} Use when: shortlisting short-term momentum names on a 10-E… Input parameters: - `limit` (integer): Max rows, 1-50 (default 20) - `market` (string): Market: 'kr' (default), 'us', 'tw', or 'all'. Japan has no redistributable price source, so it is not screenable. - `max_ext_pct` (number): Max % above the 10-day EMA before over-extended (default 12) - `min_price` (number): Minimum close price (avoid low-priced stocks; e.g. 10 for US$, 5000 for KRW) - `min_vol_avg20` (number): Minimum 20-day average volume (liquidity filter) - `order` (string): Sort direction (default desc) - `require_macd_bull` (boolean): Require MACD histogram > 0 (default true) - `response_format` (string): 'markdown' for a table, 'json' for compact machine-readable output - `rs_min` (integer): Minimum RS percentile (default 60) - `sort_by` (string): Sort column (default rs_pctile) Output parameters: - `count` (number) - `criteria` (object) - `data_as_of` - `market` (string) - `notes` - `order` - `rows` (array) - `signals` (array) - `sort_by` (string|null) - `us_note` ### `get_disclosure_feed` (~591 tokens) Disclosure Feed (FinBridge DB) Recent regulatory disclosures from the local finbridge database (filings table, refreshed nightly + intraday for KR), newest first — positioned as a faster-than-news primary source. By default returns only MATERIAL filings: US Form 8-K (current reports) and KR 주요사항보고서 (major events: capital raises, M&A, convertible bonds, buybacks, etc.). Args: \- market: 'kr' (DART), 'us' (EDGAR), or 'all' (default) \- company: optional — restrict to one company (US ticker, KR 6-digit code, or name) \- material_only: default true (8-K / KR type-B only); false = all filing types \- forms: optional explicit form_type filter (e.g. ['10-K','8-K'] or ['A','B']); overrides material_only \- days: look-back window in days, 1-120 (default 14); or use from/to \- from/to: optional explicit YYYY-MM-DD range (overrides days) \- limit: 1-100 (default 30); response_format: 'markdown'|'json' Returns: {count, market, since, rows:[{source, company_name, form_type, title, filed_date, url, items?}]}. 'items' (8-K item codes) is included when available. Examples: \- Latest US material events this week: {market:'us', days:7} \- Samsung's recent major-event filings: {company:'005930', material_only:true, days:90} \- All of a company's filings: {company:'AAPL', material_only:false} Use when: scanning for catalysts / breaking corporate events, or one company's recent filings. Don't use for filing BODIES (open the url) or for financial statement values (get_dart_financials / get_edgar_financials / query_db). Notes: Filing metadata only; bodies are at the linked source URLs. Not investment advice. Errors: empty result is not an error (count 0). Input parameters: - `company` (string): Optional company filter: US ticker, KR 6-digit code, or name - `days` (integer): Look-back window in days (default 14) - `forms` (array): Explicit form_type filter; overrides material_only - `from` (string): Explicit start date YYYY-MM-DD (overrides days) - `limit` (integer): Max rows (default 30) - `market` (string): Market: 'kr', 'us', or 'all' (default) - `material_only` (boolean): Only material filings (US 8-K / KR type-B). Default true - `response_format` (string): 'markdown' or 'json' - `to` (string): Explicit end date YYYY-MM-DD Output parameters: - `company` - `count` (number) - `market` (string|null) - `rows` (array) - `since` ### `get_edgar_13f` (~328 tokens) Get Institutional Holdings (SEC Form 13F) Quarter-end institutional manager holdings reconstructed from SEC 13F-HR and 13F-HR/A (RESTATEMENT or NEW HOLDINGS), for the latest reportDate in recent submissions. Pass a manager name or CIK, not an issuer ticker. top=1–50 (default 20) limits displayed rows. response_format=markdown or json. Returns reported security rows with separate class, PUT/CALL, SH/PRN, discretion and other-manager fields; no ticker mapping or reverse ownership lookup. Values normalize each filing to USD using the 2023-01-03 filing-date boundary. Missing numbers stay null. Duplicate/shared reporting, incomplete amendment chains and confidential omissions withhold totals/weights. sources carries accession, primary/table URLs, report/filed/acceptance/fetch times and amendment evidence. prior_period is a distinct reportDate; no prior omits changes. Unverified corporate actions, missing rows, options/principal and incomplete reports withhold change signals with explicit comparison_exclusions. Empty changes does not establish no activity. 13F covers disclosed Section 13(f) positions, not a complete/current portfolio; 45 days is a filing deadline, not a freshness guarantee. Not investment advice. Input parameters: - `filer` (string, required): Institutional manager name ('Berkshire Hathaway Inc', 'Bridgewater Associates') or CIK number ('1067983') - `response_format` (string): 'markdown' for tables, 'json' for compact machine-readable output - `top` (integer): Number of largest holdings by value to return (default 20) Output parameters: - `calculation_version` - `changes` (array) - `comparison_exclusions` (array) - `comparison_status` - `filed` - `filer` (object) - `generated_at` - `holdings` (array) - `index_warnings` (array) - `notes` (array) - `num_holdings` - `period` - `prior_period` - `prior_reconstruction_status` - `prior_sources` (array) - `reconstruction_status` - `sources` (array) - `total_value` (number|null) - `value_unit` ## Diagnostics Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/kr-gronox-finbridge/mcp#diagnostics ## Score history - 2026-09-20: 81 - 2026-09-19: 80 - 2026-09-18: 80 - 2026-09-17: 79 - 2026-09-16: 79 - 2026-09-15: 78 - 2026-09-14: 78 - 2026-09-13: 77 - 2026-09-12: 78 - 2026-09-11: 78 - 2026-09-10: 78 - 2026-09-09: 77 - 2026-09-08: 77 - 2026-09-07: 76 - 2026-09-06: 38 - 2026-09-05: 38 - 2026-09-04: 38 - 2026-09-03: 38 - 2026-09-02: 38 - 2026-09-01: 38 - 2026-08-31: 38 - 2026-08-30: 38 ## Common questions ### What is the FinBridge MCP server? FinBridge is an MCP server listed in the public MCP registry as kr.gronox/finbridge. Korean stock research MCP: DART financials, global filings, daily prices and research tools. This page covers its hosted endpoint (https://mcp.gronox.kr/mcp). ### Is the FinBridge MCP server safe to use? FinBridge scores 81 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the FinBridge MCP server expose? FinBridge exposes 44 tools: real_estate_get_coverage, real_estate_list_regions, real_estate_search_trades, real_estate_summarize_trades, import_portfolio, and 39 more. Their descriptions and schemas cost roughly 28,551 tokens of context every time the server is loaded. ### Does the FinBridge MCP server require authentication? Yes. FinBridge asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything. ### Is the FinBridge MCP server still maintained? FinBridge is still listed as active in the MCP registry. We last reached this channel on 20 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ## Links - Remote endpoint: https://mcp.gronox.kr/mcp - Repository: https://github.com/Jakechj/finbridge-mcp - Website: https://www.gronox.kr/ - Changelog RSS feed: https://verifymcp.io/servers/kr-gronox-finbridge/mcp.xml - Changelog JSON feed: https://verifymcp.io/servers/kr-gronox-finbridge/mcp.json - HTML version of this page: https://verifymcp.io/servers/kr-gronox-finbridge/mcp