_ registry / mcp streamable-http · checked 2h ago

valuation-api

https://market.finance-tools.io

Registry code: 36a6eb0d89b474bf

api record

Deterministic profitability and market-value analysis tools for AI agents — margins, ROA, ROE, ROCE, ROIC, EPS, P/E, P/B, dividend yield and payout ratio via Model Context Protocol. Useful for corporate finance, equity analysis, financial analysis, quantitative analysis, financial formulas and financial modeling.

from a public catalogue that lists it, not from the operator

endpoint
https://market.finance-tools.io/mcp
protocol
streamable-http ·2024-11-05
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is valuation-api live?
Yes — it answered the hub's last check (checked 2h ago). It answered 98% of checks over the last 30 days.
Is valuation-api free to use?
Yes — the hub reached it with no key and no payment.
What tools does valuation-api have?
14 tools: calculate_net_margin, calculate_pb_ratio, calculate_pe_ratio, calculate_price_to_sales, calculate_return_on_capital_employed, calculate_return_on_assets, calculate_eps, calculate_payout_ratio, ….
Is valuation-api safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
97.7%

90 days 98.7%· all time 98.7%

latency
94ms

last good check

priced tools
0

of 14 tools

_ answered our checks, 90 days 232 checks · signed record
  • degraded → live
  • live → degraded· timeout after 20000ms
  • degraded → live
  • live → degraded· timeout after 20000ms
  • degraded → live
_ what it is for
used for
  • calculate profit margins from financials
  • calculate return on equity and assets
  • calculate p/e and p/b ratios
  • calculate dividend yield and payout ratio
takes → gives
data → data
tools
14 reads
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

inferred, not observed

Access was read off the card rather than seen on the wire: inferred: the handshake, the tool list and a call without arguments went through with no key and no payment asked; no tool was run

_ what it can do 14 tools
14 never probed 0 of 14 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • calculate_net_margin reads unknown 4h ago

    Calculate net margin: net income divided by net sales — the share of every revenue pound/dollar that reaches the bottom line. Formula: Net Margin = Net Income / Net Sales. WHEN TO USE: Use for the all-in profitability picture after operating costs, interest, tax and other items. WHEN NOT TO USE: Do NOT use alone — net margin is affected by capital structure and tax; compare alongside gross and operating margins. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { net_margin: decimal (e.g. 0.12 = 12%), net_margin_pct: number (e.g. 12.0), inputs }. PARAMETERS: net_income (required): Net income after tax, e.g. 120000. May be negative. net_sales (required): Net sales / revenue, e.g. 1000000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "net_income",
        "net_sales"
      ],
      "properties": {
        "net_sales": {
          "type": "number",
          "description": "Net sales / revenue, e.g. 1000000. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "net_income": {
          "type": "number",
          "description": "Net income after tax, e.g. 120000. May be negative."
        }
      }
    }
    arguments 18 lines
  • calculate_pb_ratio reads unknown 2h ago

    Calculate the price-to-book (P/B) ratio: share price divided by book value per share — how much investors pay relative to accounting net asset value. Formula: P/B = Share Price / Book Value Per Share. WHEN TO USE: Use for valuing asset-heavy or financial companies where book value is a meaningful anchor; P/B < 1 can indicate undervaluation or low returns on assets. WHEN NOT TO USE: Do NOT use for asset-light businesses (intangibles make book value meaningless) or where book value is negative. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { pb_ratio: number (e.g. 1.4 = 1.4x), inputs }. PARAMETERS: share_price (required): Current share price, e.g. 45.00. Must be > 0. book_value_per_share (required): Book value per share (shareholders’ equity / shares), e.g. 32.00. Must be > 0 for a meaningful ratio.

    mcp-tool

    {
      "type": "object",
      "required": [
        "share_price",
        "book_value_per_share"
      ],
      "properties": {
        "share_price": {
          "type": "number",
          "description": "Current share price, e.g. 45.00. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "book_value_per_share": {
          "type": "number",
          "description": "Book value per share (shareholders’ equity / shares), e.g. 32.00. Must be > 0 for a meaningful ratio.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 19 lines
  • calculate_pe_ratio reads unknown 2h ago

    Calculate the price-to-earnings (P/E) ratio: share price divided by earnings per share — how much investors pay per unit of earnings. Formula: P/E = Share Price / EPS. WHEN TO USE: Use for relative valuation against peers, sector averages, or a company’s own history. Higher P/E = market expects higher growth. WHEN NOT TO USE: Do NOT use when EPS is negative or near zero (ratio becomes meaningless), and prefer forward P/E for growth companies. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { pe_ratio: number (e.g. 18.5 = 18.5x), earnings_yield: decimal (e.g. 0.054 = 5.4%), earnings_yield_pct: number (e.g. 5.4), inputs }. The earnings yield is the reciprocal of the P/E ratio, returned so a client gets both figures from one call. PARAMETERS: share_price (required): Current share price in currency units, e.g. 45.00. Must be > 0. earnings_per_share (required): Earnings per share (trailing or forward), e.g. 2.43. Must be > 0 for a meaningful ratio.

    mcp-tool

    {
      "type": "object",
      "required": [
        "share_price",
        "earnings_per_share"
      ],
      "properties": {
        "share_price": {
          "type": "number",
          "description": "Current share price in currency units, e.g. 45.00. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "earnings_per_share": {
          "type": "number",
          "description": "Earnings per share (trailing or forward), e.g. 2.43. Must be > 0 for a meaningful ratio.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 19 lines
  • calculate_price_to_sales reads unknown 2h ago

    Calculate the price-to-sales (P/S) ratio: market capitalisation divided by revenue — how much investors pay per unit of sales. Formula: Price-to-Sales = Market Capitalisation / Revenue. WHEN TO USE: Use for valuing companies with no (or negative) earnings where P/E is meaningless — high-growth, early-stage, or cyclical-trough businesses. WHEN NOT TO USE: Do NOT use in isolation — P/S ignores profitability entirely; pair it with margin context (e.g. calculate_net_margin) and compare against peers. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { price_to_sales: number (e.g. 3.0 = 3.0x), inputs }. PARAMETERS: market_capitalization (required): Market capitalisation (share price x shares outstanding), e.g. 9000000. Must be > 0. revenue (required): Revenue (net sales) over the trailing period, e.g. 3000000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "market_capitalization",
        "revenue"
      ],
      "properties": {
        "revenue": {
          "type": "number",
          "description": "Revenue (net sales) over the trailing period, e.g. 3000000. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "market_capitalization": {
          "type": "number",
          "description": "Market capitalisation (share price x shares outstanding), e.g. 9000000. Must be > 0.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 19 lines
  • calculate_return_on_capital_employed reads unknown 17h ago

    Calculate return on capital employed (ROCE): EBIT divided by capital employed (total assets minus current liabilities) — return generated by the capital actually deployed in the business. Formula: ROCE = EBIT / (Total Assets - Current Liabilities). WHEN TO USE: Use to compare profitability across companies with different capital structures — EBIT (pre-financing) over all capital employed. WHEN NOT TO USE: Do NOT use when capital employed is near zero or negative; prefer ROIC for after-tax operating returns. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { return_on_capital_employed: decimal (e.g. 0.22 = 22%), return_on_capital_employed_pct: number (e.g. 22.0), inputs }. PARAMETERS: ebit (required): Earnings before interest and taxes, e.g. 220000. May be negative. total_assets (required): Total assets, e.g. 1200000. Must be > 0. current_liabilities (required): Total current liabilities, e.g. 200000. Must be >= 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "ebit",
        "total_assets",
        "current_liabilities"
      ],
      "properties": {
        "ebit": {
          "type": "number",
          "description": "Earnings before interest and taxes, e.g. 220000. May be negative."
        },
        "total_assets": {
          "type": "number",
          "description": "Total assets, e.g. 1200000. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "current_liabilities": {
          "type": "number",
          "minimum": 0,
          "description": "Total current liabilities, e.g. 200000. Must be >= 0."
        }
      }
    }
    arguments 24 lines
  • calculate_return_on_assets reads unknown never probed

    Calculate return on assets (ROA): net income divided by average total assets — how efficiently a company converts its asset base into profit. Formula: ROA = Net Income / Average Total Assets. WHEN TO USE: Use to measure management’s efficiency in deploying all assets, independent of how they are financed. WHEN NOT TO USE: Do NOT compare ROA across industries with different asset intensity; use ROIC for a cleaner operating view. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { return_on_assets: decimal (e.g. 0.08 = 8%), return_on_assets_pct: number (e.g. 8.0), inputs }. PARAMETERS: net_income (required): Net income after tax, e.g. 84000. May be negative. begin_total_assets (required): Total assets at period start, e.g. 1000000. Must be > 0. end_total_assets (required): Total assets at period end, e.g. 1100000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "net_income",
        "begin_total_assets",
        "end_total_assets"
      ],
      "properties": {
        "net_income": {
          "type": "number",
          "description": "Net income after tax, e.g. 84000. May be negative."
        },
        "end_total_assets": {
          "type": "number",
          "description": "Total assets at period end, e.g. 1100000. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "begin_total_assets": {
          "type": "number",
          "description": "Total assets at period start, e.g. 1000000. Must be > 0.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 24 lines
  • calculate_eps reads unknown 13h ago

    Calculate earnings per share (EPS): net income divided by weighted average shares outstanding — profit attributable to each share. Formula: EPS = Net Income / Weighted Average Shares Outstanding. WHEN TO USE: Use as the denominator for P/E and payout ratios and to track per-share profitability over time. WHEN NOT TO USE: Do NOT use basic share count when convertible securities exist — use diluted shares for a conservative EPS. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { eps: number (currency per share, e.g. 1.25), inputs }. PARAMETERS: net_income (required): Net income attributable to common shareholders, e.g. 1250000. May be negative. weighted_avg_shares_outstanding (required): Weighted average shares outstanding during the period, e.g. 1000000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "net_income",
        "weighted_avg_shares_outstanding"
      ],
      "properties": {
        "net_income": {
          "type": "number",
          "description": "Net income attributable to common shareholders, e.g. 1250000. May be negative."
        },
        "weighted_avg_shares_outstanding": {
          "type": "number",
          "description": "Weighted average shares outstanding during the period, e.g. 1000000. Must be > 0.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 18 lines
  • calculate_payout_ratio reads unknown never probed

    Calculate the payout ratio: dividends per share divided by earnings per share — the share of profits distributed as dividends. Formula: Payout Ratio = Dividends Per Share / EPS. WHEN TO USE: Use to judge dividend sustainability: payout above 100% means dividends exceed earnings (funded by debt or reserves). WHEN NOT TO USE: Do NOT use when EPS is negative (ratio is meaningless), and note young growth companies legitimately pay little or nothing. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { payout_ratio: decimal (e.g. 0.55 = 55%), payout_ratio_pct: number (e.g. 55.0), inputs }. PARAMETERS: dividends_per_share (required): Dividends per share in the period, e.g. 1.34. Must be >= 0. earnings_per_share (required): Earnings per share, e.g. 2.43. Must be > 0 for a meaningful ratio.

    mcp-tool

    {
      "type": "object",
      "required": [
        "dividends_per_share",
        "earnings_per_share"
      ],
      "properties": {
        "earnings_per_share": {
          "type": "number",
          "description": "Earnings per share, e.g. 2.43. Must be > 0 for a meaningful ratio.",
          "exclusiveMinimum": 0
        },
        "dividends_per_share": {
          "type": "number",
          "minimum": 0,
          "description": "Dividends per share in the period, e.g. 1.34. Must be >= 0."
        }
      }
    }
    arguments 19 lines
  • calculate_gross_margin reads unknown 4h ago

    Calculate gross margin: gross profit divided by net sales — the share of revenue retained after the direct cost of goods sold. Formula: Gross Margin = Gross Profit / Net Sales. WHEN TO USE: Use to assess product-level economics and pricing power before operating expenses are considered. WHEN NOT TO USE: Do NOT use gross margin to compare companies with different cost classification practices (COGS boundary varies). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { gross_margin: decimal (e.g. 0.40 = 40%), gross_margin_pct: number (e.g. 40.0), inputs }. PARAMETERS: gross_profit (required): Gross profit = net sales - COGS, e.g. 400000. Must be >= 0. net_sales (required): Net sales / revenue, e.g. 1000000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "gross_profit",
        "net_sales"
      ],
      "properties": {
        "net_sales": {
          "type": "number",
          "description": "Net sales / revenue, e.g. 1000000. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "gross_profit": {
          "type": "number",
          "minimum": 0,
          "description": "Gross profit = net sales - COGS, e.g. 400000. Must be >= 0."
        }
      }
    }
    arguments 19 lines
  • calculate_operating_margin reads unknown 4h ago

    Calculate operating margin: operating income divided by net sales — profitability from core operations before financing and tax. Formula: Operating Margin = Operating Income / Net Sales. WHEN TO USE: Use to compare core business profitability across peers and over time, independent of capital structure. WHEN NOT TO USE: Do NOT use when one-off items distort operating income — consider normalised EBIT instead. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { operating_margin: decimal (e.g. 0.18 = 18%), operating_margin_pct: number (e.g. 18.0), inputs }. PARAMETERS: operating_income (required): Operating income / EBIT, e.g. 180000. May be negative. net_sales (required): Net sales / revenue, e.g. 1000000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "operating_income",
        "net_sales"
      ],
      "properties": {
        "net_sales": {
          "type": "number",
          "description": "Net sales / revenue, e.g. 1000000. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "operating_income": {
          "type": "number",
          "description": "Operating income / EBIT, e.g. 180000. May be negative."
        }
      }
    }
    arguments 18 lines
  • calculate_dividend_yield reads unknown 13h ago

    Calculate dividend yield: annual dividends per share divided by share price — the cash return a shareholder receives from dividends. Formula: Dividend Yield = Annual Dividends Per Share / Share Price. WHEN TO USE: Use to compare income return against bond yields or peer dividend policies; a yield far above peers can signal a depressed price or unsustainable payout. WHEN NOT TO USE: Do NOT annualise a one-off special dividend as if it were regular income. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { dividend_yield: decimal (e.g. 0.035 = 3.5%), dividend_yield_pct: number (e.g. 3.5), inputs }. PARAMETERS: annual_dividends_per_share (required): Annual dividends per share, e.g. 1.58. Must be >= 0. share_price (required): Current share price, e.g. 45.00. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "annual_dividends_per_share",
        "share_price"
      ],
      "properties": {
        "share_price": {
          "type": "number",
          "description": "Current share price, e.g. 45.00. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "annual_dividends_per_share": {
          "type": "number",
          "minimum": 0,
          "description": "Annual dividends per share, e.g. 1.58. Must be >= 0."
        }
      }
    }
    arguments 19 lines
  • calculate_ebitda_margin reads unknown 13h ago

    Calculate the EBITDA margin: EBITDA divided by revenue — operating profitability before interest, tax, depreciation and amortisation, expressed as a share of sales. Formula: EBITDA Margin = EBITDA / Revenue. WHEN TO USE: Use to compare core operating profitability across companies with different capital structures, tax regimes and depreciation policies. WHEN NOT TO USE: Do NOT use when EBITDA is negative (the margin is negative and less meaningful); EBITDA also ignores capital intensity, so pair with return or free-cash-flow metrics. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { ebitda_margin: decimal (e.g. 0.25 = 25%), ebitda_margin_pct: number (e.g. 25.0), inputs }. PARAMETERS: ebitda (required): Earnings before interest, tax, depreciation and amortisation, e.g. 800000. revenue (required): Revenue (net sales) over the same period, e.g. 3200000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "ebitda",
        "revenue"
      ],
      "properties": {
        "ebitda": {
          "type": "number",
          "description": "Earnings before interest, tax, depreciation and amortisation, e.g. 800000."
        },
        "revenue": {
          "type": "number",
          "description": "Revenue (net sales) over the same period, e.g. 3200000. Must be > 0.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 18 lines
  • calculate_return_on_equity reads unknown 17h ago

    Calculate return on equity (ROE): net income divided by average shareholders’ equity — the return earned on the owners’ invested capital. Formula: ROE = Net Income / Average Shareholders’ Equity. WHEN TO USE: Use to assess how well management generates returns for shareholders; decompose via DuPont (margin x turnover x leverage) for drivers. WHEN NOT TO USE: Do NOT use when equity is small or negative (distress / heavy buybacks) — ROE explodes or inverts and misleads. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { return_on_equity: decimal (e.g. 0.15 = 15%), return_on_equity_pct: number (e.g. 15.0), inputs }. PARAMETERS: net_income (required): Net income after tax, e.g. 150000. May be negative. begin_equity (required): Shareholders’ equity at period start, e.g. 950000. Must be > 0. end_equity (required): Shareholders’ equity at period end, e.g. 1050000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "net_income",
        "begin_equity",
        "end_equity"
      ],
      "properties": {
        "end_equity": {
          "type": "number",
          "description": "Shareholders’ equity at period end, e.g. 1050000. Must be > 0.",
          "exclusiveMinimum": 0
        },
        "net_income": {
          "type": "number",
          "description": "Net income after tax, e.g. 150000. May be negative."
        },
        "begin_equity": {
          "type": "number",
          "description": "Shareholders’ equity at period start, e.g. 950000. Must be > 0.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 24 lines
  • calculate_return_on_invested_capital reads unknown 17h ago

    Calculate return on invested capital (ROIC): NOPAT divided by invested capital — the after-tax operating return on capital invested in the business. Formula: ROIC = NOPAT / Invested Capital. WHEN TO USE: Use to assess value creation: ROIC above the cost of capital creates value; below it destroys value. Core metric for investors. WHEN NOT TO USE: Do NOT use if you lack a clean NOPAT or invested capital figure — inconsistent definitions make ROIC incomparable. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { return_on_invested_capital: decimal (e.g. 0.18 = 18%), return_on_invested_capital_pct: number (e.g. 18.0), inputs }. PARAMETERS: nopat (required): Net operating profit after tax = EBIT x (1 - tax rate), e.g. 180000. May be negative. invested_capital (required): Invested capital (equity + debt - cash, or operating assets - operating liabilities), e.g. 1000000. Must be > 0.

    mcp-tool

    {
      "type": "object",
      "required": [
        "nopat",
        "invested_capital"
      ],
      "properties": {
        "nopat": {
          "type": "number",
          "description": "Net operating profit after tax = EBIT x (1 - tax rate), e.g. 180000. May be negative."
        },
        "invested_capital": {
          "type": "number",
          "description": "Invested capital (equity + debt - cash, or operating assets - operating liabilities), e.g. 1000000. Must be > 0.",
          "exclusiveMinimum": 0
        }
      }
    }
    arguments 18 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id 36a6eb0d89b474bf.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/36a6eb0d89b474bf/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/36a6eb0d89b474bf/badge.svg)](https://brick.blue/agent/36a6eb0d89b474bf?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.

_ also on finance-tools.io 4 entries

Served from the same domain, which is what was measured. Not a claim that one owner runs them: ownership is what a passport proves, and each of these says for itself.