Skip to main content
Glama
726,822 tools. Updated 2026-10-30 23:38

"fetch" matching MCP tools:

  • Fetch the full content for one id returned by `search`: a rental listing (rental:<uuid>), a plan set (plan:<uuid>) or a published page (page:<route>). Returns {id, title, text, url, metadata}. Always cite the url. Hosts that can call specific tools should prefer get_rental or the resources.
    ConnectorNo auth
  • [ChatGPT Connector compat] Fetch memory by ID. Exists to satisfy ChatGPT Deep Research's required `search`/`fetch` tool contract. Native MCP clients should fetch via `recall` + memory_id, or use the API's GET /memories/{id} endpoint directly. Returns a single memory with citation support (id, title, url, text fields). Args: id: Memory UUID to fetch ctx: MCP context Returns: Dict with id, title, url, text, metadata fields
    ConnectorOAuth
  • Purpose: ChatGPT-connector-standard document fetch by id from `search` results. Namespaces: `tool:{name}` returns the tool's full documentation and how to call it; `resource:{uri}` returns the resource's live data (core resources resolved server-side — also the bridge for clients without MCP resource support, e.g. Gemini); `signal:{market}:{symbol}` returns the symbol's latest combined signal. Triggers: ChatGPT connectors / Deep Research call this after `search`. Clients without MCP resource support can call it directly with a known resource id, e.g. fetch("resource:market://global/summary"). When to call: whenever the full content behind a search result id is needed. Prerequisites: a valid id — from `search` results or a known namespace id. Next steps: for tool docs, call the named tool via tools/call; for signals, get_signal_detail / explain_decision for deeper evidence. Caveats: uncovered resource uris return description-only text (no fabricated data). `text` is a JSON document for resource/signal ids. Output: {id, title, text, url, metadata, disclaimer, is_investment_advice, data_classification} — flat envelope, OpenAI fixed shape. Output nature: Observed signal state computed from live market prices each cycle. signal_score is an internal ranking score, not a probability; bias is its sign. Context for the user's question, not investment advice.
    ConnectorNo auth
  • Fetch one document's full extracted text by id (a file id from search / search_files / list_files), in the deep-research result shape. ALIAS: this is the SAME read as get_file (same data, same permissions, same audit, same size guard - large files are truncated) - use it when your client requires the id/title/text/url fetch contract (ChatGPT deep research); otherwise prefer get_file, which also serves download links and inline images. Read-only; audited.
    ConnectorNo auth
  • Fetch original text by an opaque id from search or document_outline. Pass ids unchanged. Navigation containers have citable=false and child ids, not source evidence. Historical page identifiers return migration guidance.
    ConnectorNo auth
  • Read one map document by the id a search result handed you. Ids: object:<name>, finding:<id> or finding:<finding_key> (stable across rescans), process:<object type>, metric:<name>, statement:<id> (run-scoped: search again after a rescan), playbook:<id>. It is the second half of the search/fetch pair that connector clients such as ChatGPT require, and returns id, title, text, url and metadata with the direct tools' data flattened to text. If your client can call the direct tools, use them instead (structured, no search first): get_object for an object you can name, get_process for a process, get_metric for a metric, list_findings for findings by status. Use fetch for a result search handed you, or a finding_key.
    ConnectorOAuth

Matching MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Fetches web pages and converts them to markdown for LLM consumption, supporting chunked reading and raw content extraction.
    MIT
  • A
    license
    A
    quality
    A
    maintenance
    Fetch URLs and return clean, LLM-ready markdown with metadata and layered prompt injection defense. Configurable timeouts, word limits, JS rendering, and link extraction. All-in-one MCP server + CLI.
    1
    24 PyPI
    2
    MIT

Matching MCP Connectors

  • web-fetch — fetch ONE public URL live from its origin, verbatim.

  • MCP server (stdio): fetch web pages as clean readable markdown via the AgentForge API

  • Free. Reads any single thing by its address, which looks like postclick://audit/<id> and comes from `search`, from `describe`, or from any other tool's answer. A plain id works too if that is all you have. `expand` is what makes this worth calling: pass `*` and you get everything attached in one go, which for an audit means the findings, the buyers and their walkthroughs, the competitor scan, the copy rewrites and the designs. Each arrives with its headline detail; the long write-ups are marked as withheld with the address to fetch them from, because all of them together run to well over a hundred thousand characters and would swamp the answer. Expand first to see the shape, then fetch the two or three that matter. For the audit as finished prose, `get_audit_report` is one call and reads better than any of this. For the audit written up as prose instead, `get_audit_report` is the one you want. For a picture, take the asset_id off a field here and pass it to `get_asset`.
    ConnectorNo auth
  • Fetch one search result by id. 'site:<site_id>' returns a readable summary of the site (title, live URL, status, storage, dates, first 100 files). 'file:<site_id>:<path>' returns the file's content as UTF-8 text when it is a text type of at most 1 MB, otherwise a short note pointing at its live URL. Returns {id, title, text, url, metadata}.
    ConnectorOAuth
  • Fetch one Silicon Analysts record by the id search returned — returns {id, title, text, url, metadata}. text is a compact, citable plain-text rendering of the record's CURRENT values (a dataset's points with value, range, data_type, confidence, source and date per point; a tool domain's current rows; an article's summary, takeaways, body and sources). metadata carries as_of, freshness, basis, data_types/confidence, source_count, cite_as (the house citation string) and license_url. USE THIS for: ChatGPT deep research / company knowledge and other search + fetch connector hosts reading a record found with search; getting a citable text summary of one dataset, series, tool domain or article. DO NOT USE for: filtered or structured pulls when you can call tools directly — metadata.structured_tool names the specialised tool (and arguments) behind the record, which returns typed fields and accepts filters. Id formats: dataset:<dataset_id> | dataset:<dataset_id>#<series_key> | article:<slug> | tool:<tool_name>. Unknown ids return INVALID_PARAMS. Tiering is exactly the underlying tool's: anonymous callers get current values only (no history), a free key adds a history preview, Pro the complete series — the metadata history_note says when a record was clamped; as on the website, a source note that restates a value your tier cannot see is withheld. Cite as metadata.cite_as.
    ConnectorNo auth
  • Fetch one development's detail using a known ID, slug or Projectory URL; no prior search or facet lookup is needed. Returns development-wide pricing, location, availability, enquiry action, payment plan, grouped unit types, evidence, media and a plain-text description marked as untrusted source material. Individual unit rows and raw HTML are omitted. Accepted forms: `project:jacob-co-beachfront-living`, `jacob-co-beachfront-living`, or `https://projectory.ae/projects/jacob-co-beachfront-living/`. Use `search` if only the project name is known.
    ConnectorNo auth
  • Read one result found via `search` as plain text with its public page URL, for quoting or citing it in an answer; this is the fetch half of the search/fetch pair. Pass the result's id exactly as search returned it (e.g. "course:..."). Returns {id, title, text, url, metadata}. A course's text is its public catalog summary (name, description, level, duration in hours, price, subjects, topics), not its lessons. A missing document, another site's content, and a type this connection cannot read all return the same not-found error; an id without a type prefix is rejected as invalid. To work with a course rather than quote it, use course_get for its settings record (ids, flags, dates, enrollment count) and course_content_get for its lessons as EditorJS blocks.
    ConnectorAPI key
  • Fetch one or more URLs and return their content as clean markdown. Use this to read articles, documentation, blog posts, or any page where you need the complete text, not just a snippet from search. Also supports PDF, DOCX, and other document formats. Costs 1 credit per URL. Max 10 URLs per request. Failed URLs are not charged. Set include_raw_html=true to also get the raw HTML source in each result. Useful for inspecting embedded URLs, data attributes, iframes, or script tags that are stripped during markdown conversion. May be null for non-HTML content (PDF, DOCX, etc.) and for some sites. Same cost. Returns: results (array of {title, url, content, raw_html, published_time, success, error}), credits_used, credits_remaining. Args: urls: List of URLs to fetch (max 10) include_raw_html: Include raw HTML source in each result (default false)
    ConnectorOAuth
  • Retrieve the full text of one FirmTape document by the id `search` returned: `session:YYYY-MM-DD` for a finished trading session, `page:/path` for an explainer or research page. A FirmTape URL or a bare YYYY-MM-DD trading day is accepted too. Use when: you hold an id from `search`, or a client that only speaks search/fetch (ChatGPT). Not for: structured numbers — get_session and get_levels answer the same day with fields instead of prose. Limits: public FirmTape documents only; long pages are truncated with a link to the rest.
    ConnectorNo auth
  • Fetch one Indian enactment by the `id` from a `search` result, returning `{id, title, text, url, metadata}`. Also accepts a source URL or a bare path. NOTE: the India corpus serves an enactment as publisher links rather than inline text, so `text` carries the title and `metadata` carries the PDF, HTML and plain-text URLs to read. Prefer `get_act_text` if you can call it.
    ConnectorNo auth
  • ChatGPT connector contract: fetch one article by the id returned from search. Returns the enriched digest (summary, per-ticker analysis, category, relevance) — not the full article body — plus the canonical alphai.io URL for citation. When the article has a published SEC earnings read, text also includes its reported metrics with year-over-year and sequential comparisons, segments, guidance, concerns and missing items. Raises not_found for an unknown id.
    ConnectorAPI key
  • USE WHEN you hold an id that `search` returned and want that record from Sato Hub, the daily-rebuilt index of what onchain and crypto AI agents are built from, as plain text to quote. Not for token prices, trading or investment advice. NOT FOR a directory slug (use onchain_agent_get_resource instead) or an id you made up (call `search` first). RETURNS (json): { id, title, text, url, metadata: { as_of, kind, sato_score?, source } }. text is plain prose to quote: for a listing, what it is, its category and chains, its Sato Score with the date (how open, active and verifiable it is — not a safety or returns grade), its last observed activity, and whether Sato Hub reproduced its install; for an answer, number or wiki page, the answer with its date. url is the canonical satohub.ai page to cite. An id without a prefix is read as the record with that exact slug, or a listing it names exactly (the same name written differently, a recorded alias, the listing's own name); such an answer is labelled { interpreted_as, requested, rule, note } and its text starts with the note. Anything else is a miss that serves nothing (not an error: { miss, candidates, suggestions } beside an empty record whose text says so): it lists the ids `search` ranks for it as candidates ({ candidates: [{ id, title, url }] }), each an exact fetch to make. Read-only. Example: { id: "resource:coinbase-agentkit" }
    ConnectorNo auth
  • Fetch one node in full by its shareable id (TASK-N/KNOW-N/COMP-N/DOC-N/DIAG-N/EPIC-N/NODE-N), with its edges — this is how you read a full body (recall/search return summaries). Pass version to fetch a historical snapshot instead of the current one.
    ConnectorOAuth
  • VERIFIABLE keyless web-read for autonomous agents. Every result ships a cryptographically SIGNED provenance receipt (EIP-191 over sha256(text)+url+status+time) — the wedge a free scraper structurally CANNOT match: Jina r.jina.ai is free+keyless too, but its bytes are HEARSAY (no proof of what/where/when). MERCURY's `attestation` is ecrecoverable OFFLINE, forever, by you OR any downstream agent you forward the bytes to — proving the content is genuine + untampered (key pinned at /.well-known/mercury-attestation). For RAG, trading and agent-to-agent commerce that need provenance, that is the gap between data and evidence. Beyond that it's the keyless web-read primitive — NO API key, NO signup, NO account, NO monthly plan, the one fetch SKU a fresh agent can onboard to by itself instead of stopping to ask a human for a key. Give a ?url= and get back clean readable page text + title + status. Agent-native extras (opt-in): ?format=markdown for structure-preserving markdown, ?links=1 for an outbound-link graph (crawl frontier), and the headline wedge — STRUCTURED EXTRACT: ?extract=title,price,author,publishedAt returns a clean JSON record { title, price, author, publishedAt }, an LLM-ready row not a wall of text. That is Firecrawl's paid 'JSON mode' (they need an LLM call + an API key for it) done here DETERMINISTICALLY from the page's own JSON-LD/OpenGraph/meta/microdata — keyless, no LLM, $0.003. (?extract=1 still returns the legacy description + wordCount.) The extracted record is folded into the SIGNED attestation too, so a buyer can prove the FIELDS — not just the raw bytes — are exactly what MERCURY resolved. You pay in-band over HTTP 402 (x402, USDC on Base mainnet) — the wedge those tools can't match: they ALL gate behind a human-created API key + a credit-card plan, so an agent can't onboard itself. This one an agent finds in the x402 Bazaar and pays with zero human in the loop. Honest charge-per-ATTEMPT: every call returns a structured result (success OR an ok:false failure with a reason) — never a silent charge-then-500. Follows redirects, SSRF-guarded, 5s timeout, 10MB cap. Pure data, no mint — delivers in prod. — $0.003/call
    ConnectorNo auth
  • Fetch the full published answer for a Pinnacle Ask result. `id` accepts a slug from `search`, an /ask path, or a full pinnacleblooms.org/ask URL. Returns the complete answer document (markdown), Everyday Therapy™ tip, what-to-watch guidance, FAQs, and the canonical URL to cite.
    ConnectorNo auth
  • Return bounded rows for a dataflow — the completion path for hosted clients. Use this when the client cannot execute a client-download plan locally (no shell/filesystem — e.g. a hosted store app or connector) but still needs actual values. ``fetch`` server-side downloads the exact GET/fan-out plan ``build_url`` would produce, concatenates it, runs one bounded literal-equality query, and releases the artifact — the raw dataset never enters model context. Clients that CAN execute locally should keep using ``ask``/``build_url`` and run the plan themselves; ``fetch`` is the affinity-free hosted shortcut, not the power path. POST-only selections have no hosted download path: ``fetch`` raises ``fetch_shape_unsupported`` and the caller must execute the ``build_url`` plan client-side. A rejected/over-length selection raises the same reason ``build_url`` would report; narrow the selection and retry. **``fetch`` does not page, deliberately.** It holds no dataset between calls: every call rebuilds the plan, re-downloads every part from the provider, and releases the artifact. An offset over that would be unsound as well as wasteful — there is no snapshot behind the cursor, so rows shifting upstream between calls would silently skip or duplicate observations, and N pages would mean N full downloads of the same dataflow from an agency that may rate-limit. When a result is ``truncated``, narrow it (``select``, ``where``, ``time_range``) or switch to ``stage_url`` + ``query_dataset``, which pages with ``offset`` over ONE immutable staged artifact and downloads once. Rows are ordered by series key, then period, before ``limit`` applies. A series with a period that cannot be placed unambiguously keeps the provider's order. ``no_records_for_selection`` is TERMINAL, not a fault: the request was well-formed and the source holds no observations for it. Widen the selection or state that no data exists — do not retry the same selection. Only ``upstream_origin_error`` (an origin fault) and ``upstream_rate_limited`` are worth retrying.
    ConnectorOAuth
  • Fetch one record by an id returned from search ("insurer:<slug>", "group:<slug>", "country:<slug>", "former:<slug>"), e.g. "insurer:micronesia-century-insurance-company-ltd". Returns the record as text with its regulator, class, verification level and register source, the page URL to cite, and the dataset version and licence in metadata. Absence from the directory does not establish absence of a licence. Provided for ChatGPT deep research and company knowledge; for ordinary questions prefer get_insurer, get_group or get_country_summary.
    ConnectorNo auth