Stockbit MCP

Evaluate stored alert rules against current Stockbit bars and report which fired. Fetches only the symbols with rules, and only as much history as the slowest indicator needs. A rule that fires is recorded so it does not fire again for the same bar. `reason` on a rule that did not fire distinguishes 'condition-false' from 'warming-up' — the second means the comparison could not be made, which is NOT the same as a no. It covers two situations: not enough history yet, which more bars fix; or an operand the SERIES DOES NOT CARRY — a response can omit `volume`, and where a bar is missing it the value is absent rather than zero. The second never resolves by waiting, however much history arrives, because the field is not in the payload. Check `volume` is present on the bars before widening the window.

Create a price or indicator alert on an IDX stock, stored on this machine. The condition uses the SAME grammar as `pine_script` signals and is evaluated with the same indicator maths, so an alert and the Pine alertcondition for it agree. Reference a declared series (sma20, sma50, rsi14, macdLine, macdSignal, bbUpper…), a price field (close, high, low, volume, hl2…), or a number. Declare what you reference via `overlays`/`panels` — the tool refuses a condition it cannot evaluate rather than storing a rule that silently never fires. A field the SERIES does not carry is a separate matter from one you did not declare. Of the referenceable price fields, `volume` is the one a response can omit: where a bar is missing it the value reads as absent rather than as zero, and a condition referencing it is UNJUDGEABLE on that bar — reported as warming up, not as false. That is deliberate: a rule comparing volume against a figure the response never sent would otherwise fire, or not fire, on a zero nobody reported. Alerts fire once per bar. Nothing is delivered automatically — `alert_check` evaluates them; there is no background daemon yet.

Delete an alert rule by id, or disable it instead with `disable_only`.

List the alert rules stored on this machine, with when each last fired.

Weigh several readings of one IDX stock into a single lean — bullish, neutral or bearish — with a confidence score and the evidence behind both. CONFIDENCE IS NOT A PROBABILITY. It measures how complete and internally consistent the evidence is — how many pillars were readable, whether they agree, how far the composite sits from neutral, and how fresh the data is. It STOPS AT 90 by construction, because nothing in this data source could justify claiming more about a future price. Four weighted pillars: broker flow and positioning (0.35 — the signal no other data source has), trend across daily/weekly/monthly (0.30), valuation (0.20), candlestick patterns (0.15). A pillar that cannot be read is reported as MISSING, contributes nothing, and its weight is redistributed — it never lands as a neutral vote, because 'we could not see it' and 'we looked and it was balanced' are different answers. WHAT IT CANNOT DO: there is no analyst consensus or price target anywhere in this server, so nothing here reflects what analysts forecast. Valuation is scored against ABSOLUTE bands, not sector peers — treat it as weak for banks, property and cyclicals. Community sentiment is counted, never scored. FLOOR-LOCKED STOCKS: when the last close sits on the auto-rejection floor, broker accumulation-versus-distribution carries no information; the flow pillar is downgraded and says so. Read that as unreliable, not as bearish. COST: about 27 upstream requests at the default 260 bars — 22 bar pages (12 rows each) plus five single-shot reads — issued sequentially. Use `technicals` or `timeframe_alignment` if you only want the numbers.

Run a trading strategy over Stockbit's own daily history and report what it would actually have done: every trade, an equity curve, and metrics (return, CAGR, Sharpe, max drawdown, win rate, profit factor, expectancy, exposure) against buy-and-hold over the SAME window. Use a preset name, or supply your own entry/exit in the same condition grammar alert_create and pine_script use — so a backtested rule, a live alert and a TradingView strategy are one object rather than three that drift. The execution model is deliberately pessimistic and it matters: signals are read at the bar CLOSE and filled at the NEXT bar's open (never at the price the signal was computed from); a bar that hits both stop and target resolves to the STOP; a gap through a level fills at the open, not the level; and a session locked by IDX auto-rejection (high === low) cannot be filled at all. Costs default to Indonesian retail: 0.15% to buy, 0.25% to sell (the extra 0.1% is the sale tax), plus 0.1% slippage, in whole 100-share lots. ALWAYS read `warnings` before quoting a number. Under ten trades it says so, and it means it. Set walk_forward for an out-of-sample check. Long-only: retail shorting is not available on IDX.

A typed accumulation/distribution reading for one IDX stock, computed from the same broker summary broker_summary returns: net buy and net sell totals for the window, the top accumulators and distributors, and how concentrated each side is. It returns no verdict, no score and no price forecast. A broker code is a pipe carrying thousands of unrelated clients, not a person — the bandar-check skill has the rest of what this cannot prove, and reading it before drawing a conclusion is the difference between flow and a story. SIGNS: values are IDR, volumes are LOTS. Sell figures are NEGATIVE — `sellValueIdr`, `sellLots`, and `netValueIdr` on anything in `topDistributors` — because that is how Stockbit sends them. Do not negate them again. `netValueIdr` is `buyValueIdr` minus the MAGNITUDE of `sellValueIdr`: how lopsided the two sides are, not how much was bought. Near zero is the normal reading of a complete NET table, since both sides describe the same trades from opposite ends. A large magnitude means they do not cover the same trades — usually truncation, sometimes GROSS. `limit` applies PER SIDE, so equal list lengths prove nothing; check whether `buyersListed` or `sellersListed` has REACHED `limit`, and if so raise it and see whether the totals move. `topDistributors` is largest seller FIRST, by size of flow. Concentration shares are fractions of one side taken on magnitudes, so both sides are positive; a null share means the question cannot be asked — that side is empty, or none of its figures could be read. `unreadable.buyers` / `.sellers` count listed brokers left out of that side's totals, so `buyers: 1` against `buyersListed: 16` means every buy figure covers 15 brokers. Broker codes come back bare unless you pass `resolve_names: true`, which adds each house as `name` on the two lists by joining against the cached `brokers` directory. Best-effort: if the directory cannot be read every figure is unchanged and `names.note` says why, and a code the directory does…

Which STOCKS one broker traded, and how much of each. This is the reverse lookup of broker_summary: that tool fixes a stock and lists brokers, this one fixes a broker and lists stocks. Chain them to answer what neither answers alone — take the biggest net seller of a stock from broker_summary, then ask here what else that broker was distributing. `broker_code` is the two-letter code (YP, CC, XL); use the `brokers` tool to find one by name. An unknown or malformed code is rejected before any request goes out. CHOOSING THE WINDOW. Pass `period` for a preset, or `from`+`to` (YYYY-MM-DD) for an exact range; both ends are required together. Omit both and you get the server's default, which measured 2026-09-01 was that single day. Rows are per stock PER DAY, so a multi-day window returns several rows for the same ticker — one per session it traded. The `period` NAME never goes on the wire. This endpoint answers 400 to `period` on every spelling and every value (measured 2026-09-01), but it accepts `from`/`to`, so a preset is resolved into a date pair here and the dates are sent. That resolution is this server's own calendar arithmetic, checked against Stockbit's: asked for LAST_7_DAYS and LAST_3_MONTHS, broker_summary resolved them to the same dates this does. YEAR_TO_DATE it starts on January 1st where Stockbit starts on the first trading day — a difference that cannot move a figure, because a window padded with days the exchange was shut contains no extra trades (measured: a Saturday start and the following Monday returned identical rows). You never have to trust that arithmetic. `request` echoes the dates actually sent and `from`/`to` on the result are the window the SERVER says it served. FILTERS: `market_types` and `investor_types` each take a LIST, and each value is sent as its own repeated parameter. Passing several boards means the union of those boards. Omit a filter and it is not sent at all, in which case the server picks the default and this tool cannot tell…

Broker-to-broker flow for an IDX stock, ALWAYS rendered as an SVG diagram laid out BUYER -> SELLER exactly like Stockbit's own Broker Distribution: top buyers on the left, the sellers they bought from on the right. Each seller's bar is that seller's TOTAL, so a partly-filled bar means the buyers shown account for only part of what it sold. For each top broker, WHICH brokers were on the other side of their trades and how much moved between them. broker_summary says how much a broker accumulated; this shows who they accumulated it from. Returns the diagram as an image AND writes a .svg file, reporting the path in `savedTo` (pass `save_path` to choose where). It deliberately does NOT return a table of numbers — the picture is the output. Use broker_summary for per-broker figures. DATES: pass a `period` preset, or BOTH `from` and `to` (YYYY-MM-DD). from/to override period. data_type=VALUE is IDR, VOLUME is LOTS (1 lot = 100 shares); the summary states which. REQUIRES a Stockbit account with at least Rp 10,000,000 total balance — Stockbit gates this feature. If the account does not qualify the tool returns an error saying so. An empty diagram on a weekend or public holiday is expected, not an error.

Broker summary for an IDX stock: which brokers net-bought/sold, in lots and IDR value, with foreign/local/govt classification. This is the core bandarmology signal — TradingView has no equivalent. DATES: omit from/to for the latest completed session. Supply BOTH from and to (YYYY-MM-DD) for a historical window — the server aggregates net flow across it in one request, so a multi-month range is as cheap as one day. For a single past day pass the same date twice. Both ends are required; a half-specified range is rejected because the API would silently return the latest session instead. An empty result for a weekend or public holiday is expected, not an error. SIGNS: sell-side rows carry NEGATIVE `netLots` and `netValueIdr`, because that is how Stockbit sends them. Do not negate them again. A row omits `netLots` or `netValueIdr` when that figure could not be read — missing on the wire, empty, or in a format this server refuses to guess at. Absent is NOT zero, it means unknown, so do not sum these rows without checking. `unreadable` on the envelope names the wire keys and counts, per side, how many listed brokers a total over these rows would miss. `resolve_names: true` adds the securities house to each row as `name`, joining against the `brokers` directory so you do not have to. The directory is cached for five minutes, so this is usually free. It is best-effort: if the directory cannot be read the rows and every figure on them are unchanged and `names.note` says why, and a code the directory does not carry simply has no `name` — an unresolved code is not a nameless broker.

Cash in the trading account, and the buying power that is not the same number. `cashIdr` is the balance. `buyingPowerIdr` is what an order can actually spend, which on an Indonesian retail account is routinely LARGER than the cash balance because of the trading limit. Use buying power to judge affordability; quoting cash where buying power was meant understates what the user can do, and the reverse overstates it. `settlement` breaks the balance into T+0/T+1/T+2 buckets when the `balance/cash/info` endpoint answered. Its absence with `settlementUnavailable` set means that second request failed, not that the account has no unsettled cash. Requires the trading session (`stockbit-auth trading-login`). IN PAPER MODE this reads a LOCAL LEDGER, not the brokerage, so NO trading session and NO PIN are needed however the line above reads — do not send the user to a terminal. The result says "PAPER ACCOUNT"; say so rather than reporting these figures as the user's actual account. PENDING VERIFICATION: this endpoint has not been observed live.

Financial statements (structured tables; the large HTML report is stripped). data_type/report_type/statement_type are integer selectors matching Stockbit's UI toggles.

Key statistics for a company (valuation, size, performance metrics).

Open a browser window so the user can sign in to Stockbit. Nothing else here works until they have. ASK THE USER FIRST, then call with `confirm: true`. This opens a real, visible window on their machine; where the client supports elicitation they are also asked directly. It returns in about a second, BEFORE the login finishes — a person takes minutes and every client has a tool-call timeout. Tell them to sign in in the window that opened, then call `status` to see whether it worked. Do not call this again while `status` says a login is in progress. The captured token goes straight to the keychain (or the encrypted file store off macOS). It is never returned here and never shown to you. If the browser is ALREADY signed in to Stockbit, it no longer waits fifteen minutes for a form that will never appear: it reads the credential out of the browser's own session and finishes in seconds, and if there is nothing usable there it signs that profile out and re-opens the login page. A credential read out of the browser that way is PROVEN against Stockbit before `status` calls it captured — nothing logged in, so its expiry says nothing about whether it works. That proof rotates the token, which stales the browser session the chartbit tools drive; a login that showed a real form is trusted without it. `switch_account: true` is for signing in as a DIFFERENT account — it clears the browser's Stockbit session first and never reuses what was there. Ask the user before using it; it signs them out of Stockbit in that browser profile. Refuses when STOCKBIT_NO_BROWSER is set (to anything but 0/false/no/off), and names the terminal command instead. It also refuses if a session is already stored, unless `force: true` (which `switch_account` implies). This does NOT log in to the trading account: that needs a 6-digit PIN typed at the user's own terminal via `stockbit-auth trading-login`, and no tool here accepts a PIN.

Clear stored Stockbit credentials from this machine. ASK THE USER FIRST, then call with `confirm: true`. There is no undo: logging back in means signing in again in a browser (and, for the trading session, re-entering the 6-digit PIN at a terminal). `scope` picks what to clear — `main` (market data), `trading` (the securities session, which is also ended at Stockbit's end), `eipo`, or `all` (the default). Any scope covering `main` also clears the stored WEBSITE session (the browser cookies the chart tools run on) and the shared access-token cache. Both are usable Stockbit credentials on their own, so a logout that left them would not be one. `remove_browser_profile: true` also deletes the saved browser profile. That profile is a SECOND copy of the session — it holds Stockbit cookies — so on a shared or lost machine, clearing the token without it is not really logging out.

The market movers behind Stockbit's own Movers dialog — the market-wide ranking. This is a DIFFERENT endpoint from top_movers, which reads the hotlist, and the difference is not cosmetic: measured 2026-09-01, the hotlist served NINE symbols while this served FIFTY, including structured warrants. Different universes. A symbol in one and not the other is expected, and a disagreement is not evidence that either is wrong. For a market-wide ranking, this is the one to use. `view` selects the tab, and the vocabulary is CLOSED to the eight members the server was seen to accept: topGainer, topLoser, topValue, topVolume, topFrequency, netForeignBuy, netForeignSell, bigMoneyNetValue. Each was echoed back verbatim on 2026-09-01, against a control value that answers 400 — so this endpoint rejects members it does not know rather than silently serving its default, which is what makes the echo trustworthy. The result's `view` is that echo: what the server says it SERVED, not what you asked for. The UI's ninth tab, IEP/IEV, is NOT a view — ten spellings of it were refused. It is a field: every row carries `iepIev` with the indicative equilibrium price and volume. Those are only meaningful during pre-opening (08:45-09:00 WIB) and read zero outside it. `limit` is honoured, but the service caps the answer at 50 rows however large it is. `page` is ignored, and the payload's own pagination block reads all zeros on every call, so it is not reported rather than passed through as a fake answer about whether more rows exist. Every row carries `readFrom` naming the wire key each value came from, `unmappedKeys` for anything this projection does not recognise, and the raw row. `foreign` says which session the net-foreign figures are from. `foreign.isShown` is the service's own flag for whether they mean anything yet: it reads false intraday and true after the ~18:00 WIB broker release on the same day. Foreign figures carrying yesterday's date before that release are correct and unpublished, n…

Where the IDX trading day currently is: pre-opening, session 1, the midday break, session 2, post-closing, or shut. Call this BEFORE concluding that an empty movers list, a still order queue or a silent tape means something is broken. Outside 09:00-16:00 WIB (Mon-Fri, excluding IDX holidays) every live feed in this server is legitimately empty. Takes no arguments and is cached for 5 seconds only, because a stale session flag makes every judgement built on it wrong. PENDING VERIFICATION: this response shape has not been observed live.

News posts, market-wide or for one symbol. There is no separate news endpoint: news IS the stream with category=STREAM_CATEGORY_NEWS, and the Stockbit symbol page's News tab is exactly this call with a symbol. So `news` routes to the per-symbol stream when given a symbol and to the market-wide one when not, and fixes the category — pass `stream` a category instead if you want anything else. This is community- and media-written Indonesian text, not market data. Use it for sentiment and as a pointer to a source; never quote a price, a ratio or an earnings figure from a post. Headlines are Indonesian-language and mostly link out to the publisher; the link, image and publisher fields are not named by this projection, so read `raw` for them. from_date/to_date are YYYY-MM-DD and calendar-checked. Paging is a CURSOR, not an offset: there is no page number or `offset`. Take `nextCursor` from the result and send it as last_stream_id to get the rows AFTER the ones you have seen; calling again without it returns the same rows. `nextCursor` is null when the page is empty or its last row carried no id, which means the walk cannot be continued rather than that it has ended. An empty `items` with a non-null `source` is a genuine zero — a quiet symbol or a narrow keyword — and not a reason to retry.

Full order-book depth ladder for a symbol. UNITS, AND THEY ARE MIXED IN ONE RESPONSE. `volume` here is SHARES (e.g. 3,545,526,000) while `technicals`' `volumeLots` for the same symbol and session is LOTS (35,488,071). They reconcile at exactly 100 shares per lot — the IDX lot size — and neither figure is wrong. Worse, this same payload labels its `total_bid_offer` depth figures `lot` while carrying `volume` in shares a few keys away. Two units under similar names in one response is a silent-wrong-answer generator: check which one you are holding before comparing anything, and never compare `volume` here against `volumeLots` there without the ×100. `market_data[]` carries the per-board split (All Market / Regular / Nego / Cash). It is also the answer for anything price_market looks like it should do — that route cannot be called. FOREIGN FLOW HAS NO DATE ON THIS PAYLOAD. `fbuy`/`fsell`/`fnet` arrive with nothing saying which session they are from, and foreign flow publishes at roughly 18:00 WIB, so before that release they are the PREVIOUS session's. price_bands surfaces this as an explicitly null `dataAsOf` with a note; market_movers carries the date for real as `foreign.sessionDate`.

Orders currently on the book: what is working, what is partially filled, what was rejected. Pass `symbol` to filter to one stock. `request` echoes the filter that was actually sent, so an empty result can be told apart from a filter that did not apply. `side` is buy or sell only when the wire said so in a word this server recognises; `sideRaw` always carries what it actually said. If `side` is absent, quote `sideRaw` rather than guessing the direction of someone's order. Requires the trading session (`stockbit-auth trading-login`). IN PAPER MODE this reads a LOCAL LEDGER, not the brokerage, so NO trading session and NO PIN are needed however the line above reads — do not send the user to a terminal. The result says "PAPER ACCOUNT"; say so rather than reporting these figures as the user's actual account. PENDING VERIFICATION: this endpoint has not been observed live.

Candlestick patterns on an IDX stock's daily bars — 16 classic formations with the prior trend they were read against. The prior trend is PART of the pattern, not decoration: a hammer and a hanging man are the same candle, as are an inverted hammer and a shooting star, and only what came before them tells the two apart. Set ignore_context to see the raw shapes anyway. `confidence` scores how closely the candle matches the TEXTBOOK PROPORTIONS. It is not a probability, it is not backtested, and it says nothing about what happened next — use `backtest` for that question.

The user's ACTUAL stock holdings at Stockbit Sekuritas — what they own right now, at what average price, and what it is worth. This is the account, not a watchlist: `watchlist` is a list of symbols someone is following, this is money at risk. Read it before offering any opinion that touches position sizing, concentration or whether to add. An opinion about BBRI means something different to someone holding 40% of their portfolio in it. `totals` carries the account-level figures from the summary endpoint. If the summary request fails the holdings are still returned and `totalsUnavailable` says why — do not report the portfolio as unreadable in that case. LOTS AND SHARES: 1 lot = 100 shares. Each is reported only when a wire key whose name says which one carried it; `derived` lists any that this server computed from the other. A derived figure is arithmetic, not a reading. Requires the trading session (`stockbit-auth trading-login`). IN PAPER MODE this reads a LOCAL LEDGER, not the brokerage, so NO trading session and NO PIN are needed however the line above reads — do not send the user to a terminal. The result says "PAPER ACCOUNT"; say so rather than reporting these figures as the user's actual account. PENDING VERIFICATION: this endpoint has not been observed live.

ONE symbol's position: how much of it the user holds, at what average price, and what it is worth now. Cheaper than `portfolio` when the question is about a single stock. `holding: null` means the account holds none of this symbol. That is a normal answer and the correct one to relay — it is not an error and not a failed lookup. Requires the trading session (`stockbit-auth trading-login`). IN PAPER MODE this reads a LOCAL LEDGER, not the brokerage, so NO trading session and NO PIN are needed however the line above reads — do not send the user to a terminal. The result says "PAPER ACCOUNT"; say so rather than reporting these figures as the user's actual account. PENDING VERIFICATION: this endpoint has not been observed live.

How many lots to buy, given what you are willing to lose. Pure arithmetic — it reads no account, checks no buying power, and places nothing. Give `entry_price`, `stop_price` (which must be BELOW the entry — IDX retail has no short selling), and EITHER `risk_idr` OR `account_idr` with `risk_pct`. Not both: they can disagree. Lots are floored, never rounded up, so the risk is at most the number you gave. Returns the position value, what is actually at risk after flooring, the round-trip commission, the break-even price with commission included, and 1R/2R/3R targets on the tick grid. It CHECKS that entry and stop sit on the IDX price grid — an off-grid limit is rejected by the exchange rather than rounded — and, if you pass `ara` and `arb` from `price_bands`, that neither is outside today's auto-rejection band. Commission defaults to the published retail rate (0.15% / 0.25%) and `feeSource` says so; pass `fee_buy_pct` and `fee_sell_pct`, or read them from `trading_info`, for this account's. This is a plan, not a permission. Use `order_preview` for the real checks — buying power, tradability, and the caps in the trading policy.

The IDX auto-rejection band (ARA/ARB) and the session's foreign flow for a stock. A stock at its ARA has no seller at any price and one at its ARB has no buyer — "1,200 and rising" means something different when 1,200 IS the ceiling. Costs no extra request: these fields already arrive inside the orderbook response. A field that was not in the payload is reported as null and named in `missing`, never as zero — zero is a real value for foreign net flow.

Candlestick chart for an IDX stock, ALWAYS rendered as an SVG: daily candles with volume, optional overlays (SMA/EMA/Bollinger) and sub-panels (RSI, MACD), plus support/resistance levels drawn on. Returns the image AND writes a .svg, reporting the path in `savedTo`. Use `technicals` for the numbers; this is the picture. `annotations` draws your own levels, zones, trend lines and markers, which is how you show the evidence behind an analysis. Drawing happens on this render only — nothing is written to the Stockbit account. The result counts yours and this tool's apart. `autoLevels` is the support/resistance this tool detected itself (`show_levels`, on by default); `annotationsDrawn` counts YOUR annotations by kind — level, zone, trend, marker — so you can confirm each one landed. `annotationsNotDrawn` names the ones that did not, by their index in your array and why: a date outside the plotted window, or a kind that arrived without the fields it needs. It is never silently empty about something that was skipped. Whenever this draws, it also opens the symbol's Stockbit chart in the user's own default browser so they can compare the drawing against the live chart in their own session. `stockbitUrl` in the result is that page; pass `open_in_stockbit: false` to skip opening it.

Real-time quote for an IDX symbol: last price, change, and best bid/offer. Also resolves the symbol's internal company id.

Financial ratios for a company.

Run a condition across many IDX stocks at once — alert_check for stocks you have no rules for. COST: bars are the expensive part. Throughput is capped at roughly 6.6 upstream requests a second, so a 20-symbol moving-average screen takes ~15s and anything referencing sma200 takes ~50s. Defaults are set at that honest ceiling; raising max_symbols much past 30 will time out before it finishes. A SECOND scan over an overlapping universe is far cheaper — bar pages are cached for six hours once settled — so sweep broadly once, then iterate on the condition. Misses distinguish `condition-false` from `warming-up` and `no-data`. `warming-up` means the comparison could not be made: either not enough history yet, or an operand the series does not carry — a response that omits `volume` leaves it absent rather than zero, and no amount of extra history will settle that. Truncation is always reported with its reason, so a capped sweep never reads as a complete one.

Stockbit's stock screener — the user's own saved screens, and the results of running one. Call with no arguments to list saved screens; pass `template_id` (and the `type` from the listing) to RUN one and get the matching stocks with their metric values. Running a screen is a read: nothing is created, edited or saved. This is IDX-specific in a way no TradingView screener can match — the metric catalogue includes a Bandarmology group built on broker-level flow. Use `catalogue` to see what can be screened on, or `presets` for Stockbit's built-in Guru screens.

Month-by-month seasonal price behaviour for one IDX stock: how it has done in each calendar month across Stockbit's fixed ten-year lookback, in ONE request. `year` is the END of that lookback, not a number of years — omit it and the current year is sent, because the endpoint rejects the request outright without one. `back_year` is passed through unchanged. Stockbit's own client sends it and this project has not observed whether it means a start year or a count of years back, so do not read meaning into it; it is accepted so the parameter is reachable, not because its effect is known. PENDING: the response shape is unverified, so nothing is renamed — `data` is exactly what Stockbit returned. Read the field names out of it rather than assuming any. An empty or null `data` means Stockbit has no seasonality series for that symbol and year, which is normal for recently listed companies; it is not an error and not a reading of zero. This is a price-history statistic, not a forecast, and it says nothing about why a month was strong.

Is this server working, and what do I run if it is not? Call this FIRST whenever anything looks wrong, and call it after logging in to confirm it took. Reports the version and Node, which of the three sessions are stored (NEVER the tokens themselves), how long the stored market-data token claims it has left, the trading mode and why, the IDX session clock in WIB, and a `nextStep` naming the single next command. It answers with no session at all — that is the state every new user is in, and the answer is the useful one. Each session also carries a `health`: `ok` / `failing` / `expired` / `not-stored` / `unknown`, derived from what actually happened the last time that credential was used. **`failing` means present and unexpired but REJECTED by Stockbit** — revoked, or superseded by another login. That is the case an expiry check cannot see, and it costs no requests. `live: true` is NOT free and is rarely what you want. It refreshes the market-data token, which ROTATES the refresh-token family and therefore ENDS the user’s Stockbit website session — the one the chart tools run on. Use `health` instead; only pass `live: true` if the user explicitly asks to prove the token with a real request. The `market` block reports the IDX clock in WIB with a UTC sibling on each field, and does not model public holidays; call `market_session` for that. `server.update` says whether a newer release of this server exists. It costs ONE request to the npm registry — not to Stockbit, carrying only the package name — cached for a day and made by this tool alone. `isOutdated: true` matters: npx caches a resolved tree under a version RANGE, so a user can run a build that is weeks old and nothing else will say so. `latest` and `isOutdated` are ABSENT when the check could not run, which means unknown, NOT up to date — read `update.note`. `STOCKBIT_NO_UPDATE_CHECK=1` turns the request off.

Run every built-in strategy over ONE stock's history and rank them — the bars are fetched once for all nine, so this costs the same as a single backtest. Ranked by return ABOVE buy-and-hold over the same window and costs, not by raw return: over a rising window every long-only strategy shows a profit, and the only question worth asking is whether the trading added anything to owning the stock. Taking the winner of nine on one window is a SELECTION, not a finding. Run `backtest` with walk_forward on the winner before believing it.

Posts from Stockbit's social stream: news, trading ideas, filed reports, insider posts, charts, polls and predictions. With no symbol this is the market-wide stream; with a symbol it is that company's stream, which is the same feed the Stockbit symbol page shows. This is community- and media-written Indonesian text, not market data. Use it for sentiment and as a pointer to a source; never quote a price, a ratio or an earnings figure from a post. category selects the tab and is sent verbatim: STREAM_CATEGORY_NEWS is the News tab, _REPORTS the filed-research tab, _INSIDER insider posts. STREAM_CATEGORY_LIKED and _SAVED are the signed-in account's own, not the market's, and the three *_WATCHLIST values scope the feed to the user's lists — watchlist_ids narrows that to named lists (ids come from the watchlist tools; they are numeric). report_type only narrows STREAM_CATEGORY_REPORTS. It is sent as given for any other category and Stockbit is free to ignore it there. from_date/to_date are YYYY-MM-DD and are calendar-checked before the request goes out, so a typo (2026-02-30, 20260803) fails loudly instead of quietly returning today. Either end may stand alone; an inverted pair is rejected. Paging is a CURSOR, not an offset: there is no page number or `offset`. Take `nextCursor` from the result and send it as last_stream_id to get the rows AFTER the ones you have seen; calling again without it returns the same rows. `nextCursor` is null when the page is empty or its last row carried no id, which means the walk cannot be continued rather than that it has ended. An empty `items` with a non-null `source` is a genuine zero — a quiet symbol or a narrow keyword — and not a reason to retry.

Technical indicator readings for an IDX stock, computed from daily bars: SMA/EMA, RSI, MACD, Bollinger Bands, ATR, and support/resistance levels found by pivot clustering. Returns NUMBERS for reasoning — use `price_chart` when you want the picture. Every reading reported is the latest defined value of its series. Deep history is paged 12 sessions at a time upstream, so a large `bars` is slow; `pagesFetched` reports what the query cost.

Whether the daily, weekly and monthly views of a stock agree, and what each one can actually support. Stockbit serves DAILY bars only — weekly and monthly here are resampled from those sessions, not exchange-published candles. There is NO 4H/1H/15m data: the intraday feed is a minutely close-only series for the current session, with no open, high, low or history. About 500 sessions are reachable, which is ~104 weekly and ~24 monthly bars — so a monthly RSI(14) is reported as null rather than computed from a window that has not converged. The `limits` field says what could not be computed and why; read it.

Stockbit's HOTLIST — a small curated list, NOT a market-wide ranking. Use market_movers for the market-wide one. This matters because the two look interchangeable and are not. Measured 2026-09-01, every call to this hotlist returned the SAME NINE symbols — at limit 5, 25, 50 and 100 alike. `limit` is sent and the service ignores it. So the ranking you get is a correct ordering over a nine-symbol universe, not the top of the exchange, and reading it as 'today's top gainers on IDX' overstates it by a wide margin. That also disposes of a reported bug: a contiguous descending run of nine changes is what a correct sort over nine symbols looks like. There is nothing wrong with the ordering; the universe is simply small, and this description is the fix. market_movers reads a different service and returned 50 rows for the same moment, including structured warrants. The two disagreeing is expected and is not evidence that either is wrong. Returns an empty list when the market is closed — that is expected, not an error.

Whether this server may place an order right now, and why not if it may not. Read it before offering to trade anything. Trading is OFF by default and the user turns it on themselves with `stockbit-auth trading-enable`; nothing this server does can turn it on, and no argument to any tool can override it. `policy.reason` is written for the user — relay it rather than paraphrasing. `policy.autoConfirmIgnored`, when present, means autoConfirm was configured but is not being honoured, and says why. `policy.elicitation` says whether a person is asked directly before an order: `required` refuses rather than send when no person can be reached, `when-available` (the default) asks wherever the client supports it, `never` does not ask at all. `rememberGrant` is the live "don't ask again" in THIS server process, if the user made one — it is held in memory, so no file can answer that question and this is the only place it is visible. This tool reads local configuration and makes no request, so it works with no trading session.

The user's own Stockbit watchlists, and the symbols in one. Call with no arguments to list them; pass `id` to read a list's contents. This is usually the universe a user means by "my stocks" — `scan` can sweep it directly with universe=watchlist. Note `volume` here is in SHARES, while daily bars report volume in LOTS (1 lot = 100 shares). The field is named `volumeShares` so the two are never compared by accident.

List the saved multi-step workflows and what each one needs. A workflow runs several tools in one call, always the same way — use it when the user wants a routine (a full look at one stock, a morning sweep, a bandarmology check) rather than a single reading.

Run a saved workflow by name — several tools in one call, the same way every time. Returns each step's output in order, with the time it took. A step that fails ABORTS the run and the result names which step and why, unless that step is marked optional (its error is recorded and the run continues). A capped fan-out reports how many items it skipped, so a partial sweep never reads as a complete one. Use `workflow_list` first to see names and required inputs.