Skip to main content
Glama
811,733 tools. Updated 2026-11-20 16:04

"Mermaid" matching MCP tools:

  • Revisa de forma básica un diagrama Mermaid sin renderizarlo: tipo de diagrama y dirección válidos, corchetes y comillas balanceados por línea, pares subgraph/end y loop/alt/opt/par…end, y aristas con destino. No es un analizador completo. Cuándo: hay que leer, construir o revisar con exactitud una URL, una cabecera HTTP, un token, una versión, un rango de IP, un documento HTML o Markdown o un archivo para agentes. No para: revisar de forma básica un texto DOT de Graphviz sin renderizarlo (dot-check). Efectos secundarios: ninguno (solo lectura, sin red, sin estado guardado). Determinista: la misma entrada da la misma salida. Límites: entrada JSON de hasta 64 KB, 1 s por llamada, resultado de hasta 1 MB. EN: Sanity-checks Mermaid diagram text without rendering it: known diagram type and direction, balanced brackets and quotes per line, subgraph/end and block (loop/alt/opt/par) pairing, and flowchart edges with a target. Not a full parser. [EN completo / full EN: inputSchema.description]
    ConnectorNo auth
  • Create a new versioned shared file in the caller's org. Shared files default to private. Call ``file_publish`` to generate the public share URL (``/s/{share_token}``). Each ``file_update`` creates a new immutable version row. Pass ``work_id`` to attach it to a task and/or ``project_id`` to attach it to a project (same ``shared_files`` row; project attachments are ``kind=artifact`` only). ``content_format='diagram'`` takes either diagram schema: - ``teamshared.diagram/v1`` — ``body: {format: mermaid, text: "..."}``, rendered as Mermaid. Best for flowcharts, sequences, and ER sketches. - ``teamshared.diagram/v2`` — ``body: {format: scene, layers: [...], nodes: [...], edges: [...]}``, rendered as a layered 3D scene where each layer is a plane (infra / software / data by convention), each node sits on one layer, and edges may cross layers. ``kind`` (default ``system``), ``view`` (``layers``), ``mode`` (``authored``) and ``body.camera`` are optional. Every node needs ``id`` and ``layer``; ``shape`` is ``box`` | ``cylinder`` | ``sphere`` | ``cone``; edges are ``{from, to, label?, kind?}`` with ``kind`` one of ``sync`` | ``async`` | ``data`` | ``depends``. Omit ``x``/``z`` to get an automatic grid on the plane. Caps: 8 layers, 300 nodes, 600 edges, 256 KiB. Unknown keys are rejected.
    ConnectorNo auth
  • Generate a Mermaid.js flowchart for human visual inspection only. NOT for orphan detection or programmatic analysis — use audit(mode=orphans) to find isolated memories. Output may be truncated for large domains; never infer graph properties (e.g. orphans) from a truncated result. Pass memory_id (memory ID) to see a single memory and all its direct connections. Pass domain to see the full domain graph (most-connected memories first, capped at limit, default 40 max 100). Returns JSON with mermaid, node_count, edge_count, nodes_shown, nodes_total, edges_shown, edges_total, truncated, memories([{id,label}]) and connections([{from,to,relationship}]). If client supports HTML widgets, prefer passing memories and connections to an interactive renderer rather than outputting raw mermaid. If not, output mermaid inside a ```mermaid code block. If truncated is true, note only most-connected memories are shown and nodes_total/edges_total reveal what was dropped.
    ConnectorAPI key
  • Use this when the user asks to save, file, keep, note, or remember THIS conversation (or part of it) into their Eigma wiki. It drafts the pages worth keeping and saves them to the user's Eigma review inbox in this one call, then ends the request. Only durable, learn-worthy knowledge becomes pages (skip look-up trivia, logistics, and small talk), so a conversation with nothing worth keeping yields no draft and nothing saved. Editing pages that ALREADY exist is eigma_suggest_edits' job. Give every page a fitting category_path: an existing chapter when one fits, and a new chapter when the concept belongs to none of them rather than forcing it into an unrelated one. To get that right, call eigma_resolve_pages FIRST, once, with every page you drafted: it returns, per draft, the existing pages it may duplicate and the wiki's real chapters. Reuse a returned page's title AND category_path exactly to update it, and for any page you update call eigma_read_page on it FIRST: saving REPLACES that page's body, so body_md must carry BOTH what the page already says AND what this conversation adds - every sentence you leave out is deleted from the user's wiki, and an update body written from the conversation alone destroys the page. Do not browse the whole wiki for this. Pass `nodes` (one object per page) plus the top-level `conversation` block. Every page object needs ALL of: `title` (the concept's plain canonical name as a 1-3 word noun phrase, with NO appended source or qualifier, so it matches and updates any existing page on that concept), `category_path` (the CHAPTER the page lives under, never the page's own title; normally ONE level, 2 only if unusually specific; reuse a fitting existing chapter over inventing a near-duplicate, and create a new chapter when none of them fits), `body_md` (a STRUCTURED page: a lead paragraph then ## sections; write math as LaTeX in $...$/$$...$$; ONLY if the chat used outside sources, add [^N] footnotes and one ## References section, each definition written as "[^N]: [label](url)" carrying the source's REAL link (a bare source name with no URL becomes a dead, unclickable reference)), `summary` (ONE short line), `links` (related concept titles, including exact existing-page titles, to connect the graph), and `quizzes` (1-3, REQUIRED, each an understanding-testing selection question {kind,prompt,options,answer}; no option may run more than half again as long as the shortest, reached by making each wrong option a MORE substantial claim, never by shortening the right one). Draft every page in FULL now: whatever you send is EXACTLY what lands in the user's review inbox, so a missing field saves an incomplete page. The body_md MAY also include a ```mermaid diagram and/or ONE self-contained ```animation widget (all JS/CSS inline, no external network); most pages need neither. This call SAVES the pages into the user's Eigma review inbox and returns a receipt listing what it saved as NEW or as an UPDATE; show that receipt to the user, then end your turn - unless the receipt itself says pages did not fit, in which case call this again with exactly those remaining pages first. This is the only call that WRITES (eigma_resolve_pages before it only looks things up). Saving the same pages twice is harmless (the server ignores a duplicate), so if the user asks again, simply call this again.
    ConnectorOAuth
  • Use this when the user asks to save, file, keep, note, or remember THIS conversation (or part of it) into their Eigma wiki. It drafts the pages worth keeping and saves them to the user's Eigma review inbox in this one call, then ends the request. Only durable, learn-worthy knowledge becomes pages (skip look-up trivia, logistics, and small talk), so a conversation with nothing worth keeping yields no draft and nothing saved. Editing pages that ALREADY exist is eigma_suggest_edits' job. Give every page a fitting category_path: an existing chapter when one fits, and a new chapter when the concept belongs to none of them rather than forcing it into an unrelated one. To get that right, call eigma_resolve_pages FIRST, once, with every page you drafted: it returns, per draft, the existing pages it may duplicate and the wiki's real chapters. Reuse a returned page's title AND category_path exactly to update it, and for any page you update call eigma_read_page on it FIRST: saving REPLACES that page's body, so body_md must carry BOTH what the page already says AND what this conversation adds - every sentence you leave out is deleted from the user's wiki, and an update body written from the conversation alone destroys the page. Do not browse the whole wiki for this. Pass `nodes` (one object per page) plus the top-level `conversation` block. Every page object needs ALL of: `title` (the concept's plain canonical name as a 1-3 word noun phrase, with NO appended source or qualifier, so it matches and updates any existing page on that concept), `category_path` (the CHAPTER the page lives under, never the page's own title; normally ONE level, 2 only if unusually specific; reuse a fitting existing chapter over inventing a near-duplicate, and create a new chapter when none of them fits), `body_md` (a STRUCTURED page: a lead paragraph then ## sections; write math as LaTeX in $...$/$$...$$; ONLY if the chat used outside sources, add [^N] footnotes and one ## References section, each definition written as "[^N]: [label](url)" carrying the source's REAL link (a bare source name with no URL becomes a dead, unclickable reference)), `summary` (ONE short line), `links` (related concept titles, including exact existing-page titles, to connect the graph), and `quizzes` (1-3, REQUIRED, each an understanding-testing selection question {kind,prompt,options,answer}; no option may run more than half again as long as the shortest, reached by making each wrong option a MORE substantial claim, never by shortening the right one). Draft every page in FULL now: whatever you send is EXACTLY what lands in the user's review inbox, so a missing field saves an incomplete page. The body_md MAY also include a ```mermaid diagram and/or ONE self-contained ```animation widget (all JS/CSS inline, no external network); most pages need neither. This call SAVES the pages into the user's Eigma review inbox and returns a receipt listing what it saved as NEW or as an UPDATE; show that receipt to the user, then end your turn - unless the receipt itself says pages did not fit, in which case call this again with exactly those remaining pages first. This is the only call that WRITES (eigma_resolve_pages before it only looks things up). Saving the same pages twice is harmless (the server ignores a duplicate), so if the user asks again, simply call this again.
    ConnectorOAuth
  • Attach a Mermaid diagram that explains the logic or structure behind a change, so the reviewer can follow it without reading the diff. OPTIONAL — add one only when it clarifies something a list of endpoints or screenshots cannot: a decision tree or branching rule, a multi-step flow, a state machine, a call sequence, or how the touched modules, tables or classes relate. Skip it for simple changes. **Types** (first line of `source`): `flowchart TD` (decision trees, flows, dependency maps), `stateDiagram-v2`, `sequenceDiagram`, `classDiagram`, `erDiagram`. No `%%{init}` directives or `click` handlers. **Keep it small:** about 15 nodes or fewer, short labels, one idea per diagram. Quote labels that contain punctuation, e.g. `A["No tax line?"]`. **Mark what changed** in flowcharts and state diagrams by tagging nodes `:::added`, `:::changed` or `:::removed` (e.g. `B["Retry with backoff"]:::changed`) — Damper colours them; do not add your own `classDef` colours. **Before/after:** for a changed flow pass `beforeSource` with the previous diagram. **Upserts by key** (default: slug of the title); calling again with the same key replaces the diagram. Never put secrets or real customer data in labels.
    ConnectorNo auth

Matching MCP Servers

Matching MCP Connectors

  • Render, verify, describe, and safely edit Mermaid diagrams through MCP.

  • Generate dynamic Mermaid diagrams and charts with AI assistance. Customize styles and export diagr…

  • Open an interactive ER diagram of a database schema on erddocs.com. Use it when the user wants to see, understand, review or document their database structure, or asks for an ER diagram. Pass the schema text exactly as it is in the project. It reads SQL dumps and DDL (PostgreSQL, MySQL, SQL Server, SQLite), Prisma schema.prisma, DBML, Mermaid erDiagram, PlantUML, Django models.py, SQLAlchemy models, Sequelize models, TypeORM entities and a folder of Laravel migrations (concatenate the files). For SQL, the structure is enough: no INSERT data. Returns a link. The user opens it in a browser and gets the diagram with every table and relation laid out, relations without declared foreign keys found by column name and drawn dashed, and a data dictionary. Nothing is stored on the server: the schema travels inside the link and is parsed in the user's browser. A link holds a schema of a few dozen tables (about 100–200 characters of link per table, depending on comments); for a larger one the tool says so and the user pastes it on erddocs.com instead.
    ConnectorNo auth
  • Change a diagram made earlier in this chat with create_diagram: add, remove, rename or reconnect steps, shorten labels, recolour, restructure. Pass its link (https://aiflowchart.io/import/…) and the change in plain English. Use this instead of create_diagram whenever the user wants to adjust a diagram they already have, so their earlier work is kept. Returns a link to the new version plus Mermaid code where available. Uses 1 AI credit.
    ConnectorNo auth
  • [cost: free (pure CPU, no network) | read-only, no persistence] Reduce a raw SIP trace to a compact form suitable for sending to an LLM. Preserves SDP bodies and routing/auth/dialog headers; prunes well-known noise (User-Agent, Server, Allow, Accept-*, Date, P-* informational, etc.). Expected input format: raw SIP messages separated by blank lines, each starting with a request line (`INVITE sip:...@... SIP/2.0`) or status line (`SIP/2.0 200 OK`). PCAP-decoded text from sngrep / ngrep / tcpdump / tshark, syslog with SIP body, sipflow's own export format, or a hand-pasted INVITE/200 dialog all work. Annotation lines like `# [timestamp] sender -> receiver` or ngrep-style `U <ip>:<port> -> <ip>:<port>` between blocks are tolerated. Safe to run on production traces - the input is processed in-memory and is not persisted or sent off-server. Pair with: `detect_sip_stack` to identify the vendor, then `search_sip_docs(vendor=...)` for vendor-grounded analysis; `render_sip_ladder` to visualize the trace as a Mermaid call-flow ladder; `lint_sip_request` / `parse_sip_message` to mechanically validate any single message in the trace.
    ConnectorNo auth
  • Replace a workspace's doc body. Takes EITHER TipTap JSON (`content`) OR Markdown (`markdown`): pass markdown when you're producing prose from scratch (CommonMark + GFM is the format every LLM emits natively), pass TipTap JSON when you need structural edits to an existing doc (round-trip from get_doc, mutate, write back). Beyond CommonMark + GFM, the markdown layer recognizes: - **![alt text](https://…)** → inline image. Use an HTTPS URL (HTTP fires browser mixed-content warnings; data: URIs are rejected by `allowBase64: false`). For an image on your own machine, put it in a `files` surface of THIS workspace with `upload_file` (for a file on your machine or over ~3 MB, `create_file_upload` first and pass its `url` to `upload_file`; make the surface with `create_surface` kind `files` if there is none), then embed the `url` that `upload_file` returns. Never embed a `create_file_upload` url in a doc: that staged link is temporary and is deleted once the file is uploaded or left unused, so the image would break. Never ask for a public host. Renders block-feeling via CSS (max-width 100%, rounded corners, drop shadow) even though the underlying node is inline. The `alt` text is the accessible label and shows in place of the image if the URL fails to load — always include it. - A **lone video-file URL on its own line** (extension `.mp4` / `.m4v` / `.webm` / `.mov` / `.mkv`, signed-params + timestamp fragments tolerated) → native HTML5 `<video controls preload="metadata">` player. Source URL is referenced directly: no iframe, no transcoding, no quality loss. Any HTTPS URL to the video file works. For a video on your own machine, call `create_video_upload` (one file, up to 100 MB), run the curl it returns and use the `url` from its response. Sample shape: a paragraph containing only that URL. Mid-paragraph URLs stay as plain links — surrounding prose disqualifies the auto-promotion (matches the oEmbed convention). - **```mermaid** fenced code → diagram (15 sub-types: flowchart, sequence, gantt, ER, state, class, mindmap, timeline, pie, quadrant, sankey, XY-chart, packet, block, journey) - **$x$** inline math, **$$x$$** block math (LaTeX, KaTeX-rendered, scripts/href disabled) - **> [!NOTE]** / **[!TIP]** / **[!IMPORTANT]** / **[!WARNING]** / **[!CAUTION]** GFM-style callouts - **```svg** fenced code → sanitized SVG embed (the universal escape hatch for custom diagrams; scripts and event handlers stripped at write time) - **<details><summary>X</summary>BODY</details>** → collapsible toggle - **[[slug]]** / **[[org/slug]]** / **[[slug#surface-slug]]** / **[[slug#row-id]]** / **[[slug|display]]** → cross-references to another workspace, surface, or row. `[[slug#surface-slug]]` opens that surface, linking to `/<org>/<slug>?surface=<surface-slug>`. Resolved against your accessible workspace set; targets you can't see render as plain text on the reader's side (no info leak). Every cross-ref creates a Backlink row so the target's 'referenced from' sidebar shows this doc. - **[@Label](dock:mention/<kind>/<id>)** → @-mention of a user or agent. `<kind>` is `agent` or `human`; `<id>` is the principal id. Optional query params `?org=<slug>` (agents) or `?email=<addr>` (humans) for renderer hints. Mentioning a human writes a `doc_mention` row to their inbox + sends a deep-link email; mentioning an agent fires the `doc.mention_added` webhook so the agent service can wake up and reply. Re-saving a doc that already mentions someone does NOT re-fire — only newly-added mentions notify (computed from a diff against the previous body). Use this to ping a person or agent when a doc you wrote needs their eyes. - A **lone URL on its own line** from a safelisted provider (YouTube, Vimeo, Loom, Figma, CodePen, GitHub gists) → sandboxed iframe embed. Other URLs stay as regular links. Surrounding prose disqualifies the auto-embed. Per-format caps: max 50 Mermaid diagrams (30 KB source each), max 500 math expressions (8 KB source each), max 50 SVG blocks (100 KB source each post-sanitize), max 200 cross-refs per doc, max 500 @-mentions per doc, max 20 embeds per doc, max 20 videos per doc, max 200 images per doc. Last-write-wins; no CRDT merge. Emits doc.updated + doc.heading_added + doc.mention_added events as applicable. Requires editor role. Multi-surface workspaces optionally accept `surface_slug` to write to a specific doc surface; omitted writes the primary doc surface. Append-only updates have a dedicated `append_doc_section` tool that doesn't require fetching the body first.
    ConnectorNo auth
  • Apply a list of structured edit ops to an existing Mermaid `source` and return the edited diagram. This is the declarative counterpart to `execute`: plain JSON in, plain JSON out, no sandbox. Prefer it for straightforward edits; reserve `execute` for logic the ops don't express. Returns { ok, family, source, verify:{ ok, warnings } } on success, or { ok:false, family, opIndex, error } — where `error` names the offending field and lists the valid ones — when an op is malformed or cannot apply. Ops apply in order and are all-or-nothing: the first failing op stops the batch (its position is `opIndex`) and the input is left untouched. Each op is { "kind": <op>, …fields }. Call `describe_sdk` for the detected family before authoring unfamiliar ops; it returns compact signatures or exact field types, enum values, defaults, and constraints. Set mode to source-preserving for supported edits to opaque Class or Flowchart source. Exact edited bytes and portability warnings are retained; unsupported operations still fail atomically. This mode does not promise portable export.
    ConnectorNo auth
  • Publish an artifact — deploys its committed files (git HEAD; uncommitted edits are not included) to a live public URL. Works for app AND markdown artifacts; an asset artifact cannot be published (tell the user so and share its artifactUrl instead). Publishing makes the content PUBLIC to the world. It is NOT needed for sharing — the artifact is already visible at its artifactUrl to everyone who can reach it, and liveUrl is NOT an editor. Call this only when the user explicitly asked to publish/deploy; otherwise share that URL and offer publishing as a follow-up question. Requires a sessionId from a previously created artifact (via artifact-create). **What goes live:** - app: the running web application. - markdown: one document. liveUrl renders the initial file (README.md if present, else the first .md lexicographically); the raw source is at <liveUrl without the query string>/index.md (Content-Type: text/markdown) — give the user that path when they want the markdown. Other .md files are served raw at their own paths, each with a rendered .html sibling. ```mermaid fences render as diagrams; the .md keeps the fence. accTitle/accDescr label a diagram. **Modes:** - "webapp" (default): Deploys to a live URL; use it for both app and markdown artifacts. Returns { success, liveUrl, subdomain }. - "designSystem": NOT available over MCP — always fails with an enterprise contact link, whatever you pass. Do not offer it as a capability. **Returns:** { success, liveUrl, subdomain }
    Connector
    Destructive
    OAuth
  • Use this when the user asks to organize, verify, cite, add sources, merge, dedupe, move, rename, delete, restructure, refine, or add quizzes to pages that ALREADY exist in their Eigma wiki. This is the ONE tool for every edit to the existing wiki; new pages from the current conversation come from eigma_save_notes instead. It writes: this one call queues the changes into the user's Eigma review inbox, and nothing touches the wiki until the user accepts each change there. Call it ONCE per request and relay the receipt it returns. Put every change from this request into ONE call with ONE `ops` array; each op is an object {kind, ...} where kind is move, merge, delete, rename, update_page, edit_quizzes, or add_page. Reference each page by its EXACT title + category_path (verbatim from eigma_browse_wiki or eigma_read_page); an id is valid only when it came from reading that page. A verify, cite, or add-sources request is an update_page op whose body_md carries the corrected page with inline [^n] citations and a ## References section (each definition written as "[^N]: [label](url)" carrying the source's REAL link (a bare source name with no URL becomes a dead, unclickable reference)): draft it and send it here rather than answering in prose. If nothing needs changing, propose nothing. A refine op MAY add a ```mermaid or ```svg diagram or ONE self-contained ```animation widget (inline CSS/JS, no external network) to a body_md; most pages need neither.
    Connector
    Destructive
    OAuth
  • Use this when the user asks to organize, verify, cite, add sources, merge, dedupe, move, rename, delete, restructure, refine, or add quizzes to pages that ALREADY exist in their Eigma wiki. This is the ONE tool for every edit to the existing wiki; new pages from the current conversation come from eigma_save_notes instead. It writes: this one call queues the changes into the user's Eigma review inbox, and nothing touches the wiki until the user accepts each change there. Call it ONCE per request and relay the receipt it returns. Put every change from this request into ONE call with ONE `ops` array; each op is an object {kind, ...} where kind is move, merge, delete, rename, update_page, edit_quizzes, or add_page. Reference each page by its EXACT title + category_path (verbatim from eigma_browse_wiki or eigma_read_page); an id is valid only when it came from reading that page. A verify, cite, or add-sources request is an update_page op whose body_md carries the corrected page with inline [^n] citations and a ## References section (each definition written as "[^N]: [label](url)" carrying the source's REAL link (a bare source name with no URL becomes a dead, unclickable reference)): draft it and send it here rather than answering in prose. If nothing needs changing, propose nothing. A refine op MAY add a ```mermaid or ```svg diagram or ONE self-contained ```animation widget (inline CSS/JS, no external network) to a body_md; most pages need neither.
    Connector
    Destructive
    OAuth
  • MONEYFLOW GRAPH EDGES out of an Arbitrum (arb, ARB, Arbitrum One, L2) address: one row per counterparty — Source → Target, total Amount, Currency. Building block for a MoneyFlow DIAGRAM. HOW TO DRAW: call this per address/hop, collect the edges, and emit a Mermaid `graph LR` (one node per address; each edge labeled with Amount+Currency). NOT choosing which counterparty to follow next → use arbitrum_trace_next_hop. Pass the Target addresses to labels_for_addresses to flag CEX / mixer / bridge nodes and STOP expanding those branches. Pass a currency to avoid spam-token noise; call WITHOUT a currency filter to spot a token → USDT off-ramp at the edge. For raw per-transfer rows use arbitrum_transfers_out. Each edge carries the token Contract — pin one exact token with the contract param. On a very high-traffic address (an exchange or bridge hub) this aggregates a lot of history and can take tens of seconds — narrow it with contract or currency to one token to make it far faster. Amounts here are TOKEN UNITS, never USD - no USD value is available in this data, so there is no usd filter and totals for different tokens must not be compared or added together. For a ranking you can reason about, pin ONE token with contract, or bound the range with min_amount / max_amount. `Symbol_NonAscii` = 1 flags a symbol that is not plain ASCII: normal for CJK / emoji names, but also how a scam token impersonates a major one with Cyrillic or Greek look-alike letters - never treat such a token as the asset it resembles. In the top arrays it is the `symbol_nonascii` field of each entry. Bound one period with after_time / before_time. First_Seen / Last_Seen give each edge's first and last transfer. A transaction's own transfer is TOP-LEVEL, not internal, and is always counted. ETH moved by contract code deeper inside a transaction (an internal transfer) is left out unless you pass include_internal=1.
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of a Bitcoin Cash (bch, BCH, mainnet) address: Source → Target (real recipients of the address's spends, excluding change), total Amount (BCH). Building block for a MoneyFlow DIAGRAM — call per address/hop, collect edges, render Mermaid `graph LR`. Merge same-owner Targets via bch_related_addresses. NOT one transaction's outputs → use bch_tx_flow. NOT its spending transactions one by one → use bch_sent_from_address. Returns up to limit rows (default 20, at most 1000), one per recipient of its spends. The edges carry no labels: identify the Targets with labels_for_addresses(chain='bitcoin-cash') (many addresses in one call) and stop at exchange / mixer nodes. A counterparty shown as m-… or d-… is a script placeholder, not an address: it cannot be traced further. Amount is the FULL value of those outputs; Pro_Rata_Amount is the part of it this address paid for - its own input value divided by the total input value of the same transaction. When the address signs a transaction together with other addresses, every output of it is credited to each of them in full, so Amount can be many times the money this address ever moved (over a hundred times on an address that keeps co-signing with a large wallet). The rows are therefore RANKED by Pro_Rata_Amount, and that is the figure to add up or to compare between Targets. Own_Input_BCH on every row is what the address itself put into the transactions read: the Pro_Rata_Amount of all its edges adds up to at most that, the rest being fees and change it paid back to itself. SCOPE: reads the address's most recent max_txs spending transactions (default 1000, at most 2000); Amount, Pro_Rata_Amount and Txs cover those transactions only. Two scope columns on every row state what was covered: how many of those transactions were read and the time of the oldest one. Next_Cursor is set whenever the batch was full, so older transactions may exist - pass it as cursor (same address and max_txs) to continue with the next older batch; an empty Next_Cursor means the history ends here. The outputs of those transactions come from a copy of the transaction data that misses a few whole blocks (a handful a month), so an edge can be absent; bch_tx_flow and bch_sent_from_address read the complete data. When nothing matched in the transactions read, ONE row comes back with an empty Target that carries only these scope columns - that means no edge in this batch, not in the whole history. Each row: Source, Target, Currency, Amount, Pro_Rata_Amount, Txs, Own_Input_BCH, Spend_Txs_Scanned, Oldest_Spend_Time, Next_Cursor.
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of a Dash (dash, DASH, mainnet) address: Source → Target (recipients of the address's spends; change outputs to other addresses are included, see below), total Amount (DASH). Building block for a MoneyFlow DIAGRAM — call per address/hop, collect edges, render Mermaid `graph LR`. Merge same-owner Targets via dash_related_addresses. NOT one transaction's outputs → use dash_tx_flow. NOT its spending transactions one by one → use dash_sent_from_address. Returns up to limit rows (default 20, at most 1000), one per recipient of its spends. Address labels are not available for this chain, so exchange / mixer / service nodes cannot be flagged and there is no label-based stop condition. A counterparty shown as m-… or d-… is a script placeholder, not an address: it cannot be traced further. Change detection is not available on Dash: no output is classified as change (nearly every Note is unknown), so the change a wallet pays to another of its own addresses counts as a payment - Targets, Top_Receivers and tx_flow outputs can include such change. Outputs back to the address itself are still left out; dash_related_addresses shows likely same-owner addresses, and dash_tx_flow marks an output paid back to one of the transaction's own input addresses as change_to_input_address, which is the only change signal Dash has. Amount is the FULL value of those outputs; Pro_Rata_Amount is the part of it this address paid for - its own input value divided by the total input value of the same transaction. When the address signs a transaction together with other addresses, every output of it is credited to each of them in full, so Amount can be many times the money this address ever moved (over a hundred times on an address that keeps co-signing with a large wallet). The rows are therefore RANKED by Pro_Rata_Amount, and that is the figure to add up or to compare between Targets. Own_Input_DASH on every row is what the address itself put into the transactions read: the Pro_Rata_Amount of all its edges adds up to at most that, the rest being fees and change it paid back to itself. SCOPE: reads the address's most recent max_txs spending transactions (default 1000, at most 2000); Amount, Pro_Rata_Amount and Txs cover those transactions only. Two scope columns on every row state what was covered: how many of those transactions were read and the time of the oldest one. Next_Cursor is set whenever the batch was full, so older transactions may exist - pass it as cursor (same address and max_txs) to continue with the next older batch; an empty Next_Cursor means the history ends here. The outputs of those transactions come from a copy of the transaction data that misses a few whole blocks (a handful a month), so an edge can be absent; dash_tx_flow and dash_sent_from_address read the complete data. When nothing matched in the transactions read, ONE row comes back with an empty Target that carries only these scope columns - that means no edge in this batch, not in the whole history. Each row: Source, Target, Currency, Amount, Pro_Rata_Amount, Txs, Own_Input_DASH, Spend_Txs_Scanned, Oldest_Spend_Time, Next_Cursor.
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of an Ethereum (eth, ETH, mainnet, L1) address: one row per counterparty — Source → Target, total Amount, Currency. NOT choosing which counterparty to follow next → use eth_trace_next_hop. Building block for a MoneyFlow DIAGRAM. HOW TO DRAW: call this per address/hop, collect the edges, and emit a Mermaid `graph LR` (one node per address; each edge labeled with Amount+Currency). Pass the Target addresses to labels_for_addresses to flag CEX / mixer / bridge nodes and STOP expanding those branches. Pass a currency to avoid spam-token noise; call WITHOUT a currency filter to spot a token → USDT off-ramp at the edge. For raw per-transfer rows use eth_transfers_out. Each edge carries the token Contract — pin one exact token with the contract param. On a very high-traffic address (an exchange or bridge hub) this aggregates a lot of history and can take tens of seconds — narrow it with contract or currency to one token to make it far faster. Amount is in TOKEN UNITS and totals for different tokens must not be compared or added together. Amount_Usd values the edge in US dollars (to the cent) at each transfer's own time, summed over the period; it is set only for the native coin and a few major tokens, and is empty - never zero - for any other token, or when the stored price looks unreliable. Usd_Priced_Share is the share of the edge's amount that could be priced (0 to 1); when it is below 1 Amount_Usd covers only that priced part, and Unpriced_Transfers counts the transfers left unpriced. Filter edges by US dollars with min_usd, and set order_by=usd to rank by Amount_Usd, unpriced edges last, instead of by token amount. For a token-unit ranking pin ONE token with contract, or bound the range with min_amount / max_amount. `Symbol_NonAscii` = 1 flags a symbol that is not plain ASCII: normal for CJK / emoji names, but also how a scam token impersonates a major one with Cyrillic or Greek look-alike letters - never treat such a token as the asset it resembles. In the top arrays it is the `symbol_nonascii` field of each entry. Bound one period with after_time / before_time. First_Seen / Last_Seen give each edge's first and last transfer. A transaction's own transfer is TOP-LEVEL, not internal, and is always counted. ETH moved by contract code deeper inside a transaction (an internal transfer) is left out unless you pass include_internal=1. NOT a multi-hop trace - this is ONE address's direct outgoing edges. To FOLLOW the money across up to 3 hops in a single call (USD-valued, labelled, with exchange / mixer / bridge stops), use flow_graph (chain=ethereum).
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of a Litecoin (ltc, LTC, mainnet) address: Source → Target (real recipients of the address's spends, excluding change), total Amount (LTC). Building block for a MoneyFlow DIAGRAM — call per address/hop, collect edges, render Mermaid `graph LR`. Merge same-owner Targets via ltc_related_addresses. NOT one transaction's outputs → use ltc_tx_flow. NOT its spending transactions one by one → use ltc_sent_from_address. Returns up to limit rows (default 20, at most 1000), one per recipient of its spends. The edges carry no labels: identify the Targets with labels_for_addresses(chain='litecoin') (many addresses in one call) and stop at exchange / mixer nodes. A counterparty shown as m-… or d-… is a script placeholder, not an address: it cannot be traced further. About one Litecoin output in seven is not classified (Note unknown) and counts as a payment, so a few change outputs can appear among the recipients. Amount is the FULL value of those outputs; Pro_Rata_Amount is the part of it this address paid for - its own input value divided by the total input value of the same transaction. When the address signs a transaction together with other addresses, every output of it is credited to each of them in full, so Amount can be many times the money this address ever moved (over a hundred times on an address that keeps co-signing with a large wallet). The rows are therefore RANKED by Pro_Rata_Amount, and that is the figure to add up or to compare between Targets. Own_Input_LTC on every row is what the address itself put into the transactions read: the Pro_Rata_Amount of all its edges adds up to at most that, the rest being fees and change it paid back to itself. SCOPE: reads the address's most recent max_txs spending transactions (default 1000, at most 2000); Amount, Pro_Rata_Amount and Txs cover those transactions only. Two scope columns on every row state what was covered: how many of those transactions were read and the time of the oldest one. Next_Cursor is set whenever the batch was full, so older transactions may exist - pass it as cursor (same address and max_txs) to continue with the next older batch; an empty Next_Cursor means the history ends here. The outputs of those transactions come from a copy of the transaction data that misses a few whole blocks (a handful a month), so an edge can be absent; ltc_tx_flow and ltc_sent_from_address read the complete data. When nothing matched in the transactions read, ONE row comes back with an empty Target that carries only these scope columns - that means no edge in this batch, not in the whole history. Each row: Source, Target, Currency, Amount, Pro_Rata_Amount, Txs, Own_Input_LTC, Spend_Txs_Scanned, Oldest_Spend_Time, Next_Cursor.
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of a Polygon (matic, POL, MATIC, PoS) address: one row per counterparty — Source → Target, total Amount, Currency. NOT choosing which counterparty to follow next → use matic_trace_next_hop. Building block for a MoneyFlow DIAGRAM. HOW TO DRAW: call this per address/hop, collect the edges, and emit a Mermaid `graph LR` (one node per address; each edge labeled with Amount+Currency). Pass the Target addresses to labels_for_addresses to flag CEX / mixer / bridge nodes and STOP expanding those branches. Pass a currency to avoid spam-token noise; call WITHOUT a currency filter to spot a token → USDT off-ramp at the edge. For raw per-transfer rows use matic_transfers_out. Each edge carries the token Contract — pin one exact token with the contract param. On a very high-traffic address (an exchange or bridge hub) this aggregates a lot of history and can take tens of seconds — narrow it with contract or currency to one token to make it far faster. Amounts here are TOKEN UNITS, never USD - no USD value is available in this data, so there is no usd filter and totals for different tokens must not be compared or added together. For a ranking you can reason about, pin ONE token with contract, or bound the range with min_amount / max_amount. `Symbol_NonAscii` = 1 flags a symbol that is not plain ASCII: normal for CJK / emoji names, but also how a scam token impersonates a major one with Cyrillic or Greek look-alike letters - never treat such a token as the asset it resembles. In the top arrays it is the `symbol_nonascii` field of each entry. Bound one period with after_time / before_time. First_Seen / Last_Seen give each edge's first and last transfer. A transaction's own transfer is TOP-LEVEL, not internal, and is always counted. POL moved by contract code deeper inside a transaction (an internal transfer) is left out unless you pass include_internal=1.
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of a Robinhood (robinhood, rh, Robinhood Chain) address: one row per counterparty — Source → Target, total Amount, Currency. Building block for a MoneyFlow DIAGRAM. HOW TO DRAW: call this per address/hop, collect the edges, and emit a Mermaid `graph LR` (one node per address; each edge labeled with Amount+Currency). NOT choosing which counterparty to follow next → use robinhood_trace_next_hop. Address labels are not available on this chain, so flag a service node from its own profile (robinhood_address_profile) and STOP expanding that branch. Pass a currency to avoid spam-token noise; call WITHOUT a currency filter to spot a token → USDT off-ramp at the edge. For raw per-transfer rows use robinhood_transfers_out. Each edge carries the token Contract — pin one exact token with the contract param. On a very high-traffic address (an exchange or bridge hub) this aggregates a lot of history and can take tens of seconds — narrow it with contract or currency to one token to make it far faster. Amounts here are TOKEN UNITS, never USD - no USD value is available in this data, so there is no usd filter and totals for different tokens must not be compared or added together. For a ranking you can reason about, pin ONE token with contract, or bound the range with min_amount / max_amount. `Symbol_NonAscii` = 1 flags a symbol that is not plain ASCII: normal for CJK / emoji names, but also how a scam token impersonates a major one with Cyrillic or Greek look-alike letters - never treat such a token as the asset it resembles. In the top arrays it is the `symbol_nonascii` field of each entry. Bound one period with after_time / before_time. First_Seen / Last_Seen give each edge's first and last transfer. A transaction's own transfer is TOP-LEVEL, not internal, and is always counted. ETH moved by contract code deeper inside a transaction (an internal transfer) is left out unless you pass include_internal=1.
    ConnectorOAuth