Skip to main content
Glama

Server Details

Crawl and scrape websites to clean markdown, and track what changed between crawls.

Ownership verified
Status
Healthy
Uptime
95.5% over the last 24 hours
Last Tested
Transport
Streamable HTTP · MCP 2025-11-25
URL
Repository
mesharc-org/mesharc-python
GitHub Stars
0
Server Listing
MeshArc
ChatGPT
–
Claude
–

TDQS

A4.5/5.0

Scored across 22 tools

Disambiguation4/5

Most tools occupy clearly distinct niches (map_site for URL discovery, crawl_site for one-off site crawls, scrape_urls for known URLs, search_web for live search, list_pages for stored pages), and the descriptions explicitly cross-reference each other to steer selection. There is still some residual overlap between crawl_site/create_project/start_run and between get_job/list_runs/get_changes, so an agent must read the guidance carefully rather than picking on name alone.

Naming Consistency5/5

Every one of the 22 tools follows the same verb_noun snake_case convention: list_*, get_*, create_*, update_*, delete_*, archive_*, cancel_*, pause_*, start_*, run_*, continue_*, map_*, scrape_*, search_*, crawl_*. No camelCase or stray verbs, and the verb accurately signals the operation (read-only list/get vs mutating create/update/delete).

Tool Count4/5

22 tools is at the heavy end, but the server spans five real sub-domains (projects, runs/changes, one-off fetching, search/agent, monitors), and each tool maps to a distinct operation rather than duplicating another. Nothing feels like filler, though a tighter surface (e.g. folding monitor pause into an update tool) would trim it.

Completeness4/5

Project lifecycle is fully covered (list/get/create/update/archive/delete), runs have start/list/cancel plus change diffing, and fetch/search/agent paths each have both an initiation and a get_job/cancel_job follow-up. The main gap is monitors: create, list and pause exist but there is no delete_monitor or update_monitor, and there is no way to list all jobs globally, so a monitor can never be permanently removed.

Publisher details

Operator
MeshArc · Publisher source
Operator website
https://mesharc.dev
Vendor relationship
First-party · Publisher source
Privacy policy
Not provided
Restrictions
A MeshArc account is needed; fetching pages uses credits (free plan available). · Publisher source

Available Tools

22 tools
archive_projectArchive a projectA
DestructiveIdempotent
Inspect

Archive a project: it stops running, no longer counts toward the plan's projects, and is deleted for good after 30 days unless someone restores it in the MeshArc app. Use it when the person wants a project gone and delete_project is refused with admin_only -- a connected app never has admin -- or to free a slot after create_project is refused with plan_limit. Nothing is lost on the day it is archived. Inputs: project_id from list_projects. confirm_name must repeat the project's name exactly as get_project shows it, or nothing is archived. Effect: it answers with the project, archived true and purgeAt the day it goes. Archiving twice keeps the first date. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: project_id (required), confirm_name (required). Returns: A project, as get_project, create_project and update_project answer with it; ge…

cancel_jobCancel a running jobA
DestructiveIdempotent
Inspect

Stop a crawl, run, batch or agent run that is still going. Use it when the work should not finish: a crawl started too wide, a run blocking the next start_run (which answers 409 meanwhile), a batch of the wrong URLs, an agent run on the wrong question. To check a job without stopping it use get_job. Inputs: kind and id come from the 'job' object, or a crawl_site crawl_id with kind='crawl'. A run also needs project_id; list_runs shows which run is still going. Effect: queued work is dropped and the page in hand finishes; an agent run stops before its next step, and the pages and model tokens it used stay charged. Pages already read stay. A stop cannot be undone; run the work again to resume. A finished job is left alone, so asking twice is harmless. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: id (required), kind (required), project_id. Returns: What a cancel did.

continue_agentContinue a stopped agent runAInspect

Carry on an agent run that stopped at its credit limit (status credit_limit) with a new budget. It starts a new run on the same thread that resumes where the stopped one was, keeps the pages it read and answers in full. Use it when run_agent or get_job answered status 'credit_limit' and data.partial is not enough. A run that finished, failed or was cancelled cannot be carried on: ask run_agent again. Inputs: id is the stopped run's id, from its answer. max_credits and max_steps are the new run's own, e.g. max_credits=4000; omitted, they are the stopped run's. Cost: the pages the stopped run read are not paid for again. New pages are charged as they are read, a refused page free, and the model's tokens at the model provider's price plus 20%, within max_credits. Timing: it returns at once with the new run's job, as run_agent does. Call get_job(kind='agent', id=...) with the new id every 30 to 60 seconds; cancel_job stops it. Calling continue_agent again for a run already carried on returns the run that carried it on, not a new one. Refusals: code conflict for a run that did not stop at its credit limit (or was carried on meanwhile, by another call), not_found for an unknown id, expired past its 7-day keep date. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: id (required), max_steps, max_credits. Returns: An agent run: its answer and the pages it rests on once finished, or a job whil…

crawl_siteCrawl a whole site onceA
Idempotent
Inspect

Crawl a site once from a start URL, following links and the sitemap, and return the pages read. No project is set up. Use it for a site or section whose page URLs you do not know; for known URLs use scrape_urls. To watch the site afterwards, pass the crawl_id to create_project. Inputs: include_paths=['/blog/*'] reads the blog index and everything under it; paths match the URL path, never the host. Excluded pages do not count toward limit. limit=200 with max_depth=3 suits one section. config takes the keys get_project lists when called with no project_id. Cost: 1 to 4 credits per page, by the engine that read it; refused pages are free. Timing: it waits for the crawl, minutes for a large limit. If it outlasts the connection's time limit, a job comes back for get_job, and calling again returns the same crawl. The crawl is kept for a day. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: url (required), limit, config, max_depth, +2 more. Returns: A crawl: the pages read, as an index plus excerpts, or a job when it is still g…

create_monitorKeep a search or question on a scheduleAInspect

Keep a web search or an agent question and run it again on a schedule, each run compared with the last one that answered: new, dropped and moved results for a search, the answer's added, changed and removed values for a question. Use it when the person asks to keep watching, monitoring or tracking something on the web -- a brand's mentions, a ranking, a competitor's prices. To watch a whole site's pages use create_project; to ask once use search_web or run_agent. Inputs: kind 'search' with query (news=true for news results), or kind 'agent' with prompt and optional urls, schema and allowed_domains (omitted, it stays on the sites of urls, as run_agent does). schedule is hourly, daily or weekly. follow_rows=true follows a list answer record by record (read with get_monitor_rows). Cost: each run is charged as the search or agent run it is -- a results page 1 to 4 credits, an agent run up to max_credits -- and the first run starts now. max_credits_per_month skips runs once the month has spent that much. Effect: it answers with the monitor; list_monitors shows its runs. pause_monitor stops it. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: kind (required), schedule (required), name, news, +8 more. Returns: One monitor: a search or an agent question kept on a schedule, and its latest r…

create_projectCreate a watched projectAInspect

Create a project: a site MeshArc re-crawls on a schedule, comparing each run with the last to record pages added, modified and removed. Use it when asked to monitor or track a site; for a one-off read use crawl_site. Check list_projects first so the site is not added twice. Inputs: seed starts a new project, e.g. 'example.com'. crawl_id instead keeps a crawl_site crawl from the last day as the first run, with no second fetch; it keeps that crawl's settings, so config goes only with seed -- except its page limit: the crawl's limit was how much to look at once, so the project gets a project's default (100, within the plan), which update_project changes. The usual config keys are include_paths (one section, e.g. ['/blog/*']), exclude_paths, max_pages and render_js; get_project with no project_id lists them all. Cost: creating reads robots.txt and the sitemaps but no pages, so it is free. Each run spends credits per page, and any schedule but 'manual' runs on its own. Caps: max_credits_per_run stops a run at that many credits, keeping what it read; max_credits_per_month skips scheduled runs once the month has spent that many. 0 or omitted is no cap. Refusals: an unknown config key, or a plan already at its project limit (code plan_limit). Values above the plan's caps are lowered to them. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: name, seed, config, crawl_id, +3 more. Returns: A project, as get_project, create_project and update_project answer with it; ge…

delete_projectDelete a projectA
DestructiveIdempotent
Inspect

Delete a project for good, with everything its runs stored. Use it only when the person asks for the project to go, e.g. to free a slot after create_project is refused with plan_limit. To stop a run use cancel_job; to stop scheduled runs set schedule to 'manual' with update_project. Inputs: project_id from list_projects. confirm_name must repeat the project's name exactly as get_project shows it, or nothing is deleted. Effect: its runs, pages, change records and webhook history are removed for good, and a run in progress stops. Credits already spent stay spent. A second call answers 404. Needs an admin API key. A connected app (OAuth) never has one: it is refused with code admin_only and told where to delete instead.

Inputs: project_id (required), confirm_name (required). Returns: What a delete removed.

get_changesGet what changed in a runA
Read-onlyIdempotent
Inspect

Report what changed in a project run against the run just before it, or against any run you name: pages added, modified and removed, field changes, and coverage. Use it to answer 'what changed on the site', or 'since last month' with against. list_pages shows every page whether or not it changed, and list_pages with url one page's text and versions. Inputs: project_id from list_projects. run_id from list_runs picks the run; empty means the latest finished full run -- a newer start_run re-crawl of listed pages is not the default, and is named as newerPartialRun with the id to pass as run_id. against, another run's id from list_runs, compares the two directly instead of with the run just before. A run still going answers 409. Safeguards: removals are withheld when a run reached under 90% of the site, so a blocked crawl never reports pages as gone. A project's first run is a baseline with nothing to compare. Read-only and free: it reads stored data and never fetches.

Inputs: project_id (required), run_id, against. Returns: A run's change record against the run before it, or against the run named in `a…

get_jobFollow a long-running jobA
Read-onlyIdempotent
Inspect

Check on a crawl, run, batch, web search or agent run a tool handed back as a job, and return its result once finished. Call it when a tool answered with status 'running' and a job; repeating that tool is not needed. To stop a crawl, run, batch or agent run use cancel_job. For a project's stored pages use list_pages. Inputs: kind, id and project_id come from the 'job' object; a crawl_site crawl_id is a crawl's id. For a crawl, url reads one page in full, even mid-crawl, and cursor from the last answer reads the next window. Behaviour: it answers at once and never waits, so call it again every 10 to 30 seconds while the status is 'running', or every 30 to 60 for an agent run. A finished crawl answers as crawl_site does (up to 50 pages excerpted per window), a batch as scrape_urls, a search as search_web, an agent run as run_agent, a run with its record. A scraping search whose pages are still landing answers with its results and the job. A crawl expires a day after it started unless kept, then answers 404; an agent run is kept 7 days, then answers with status 'expired'. Read-only and free: it reads stored data and never fetches.

Inputs: id (required), kind (required), url, cursor, +1 more. Returns: A job's state, or its result once finished: a crawl gives crawl_site's answer,…

get_monitor_rowsRead a monitor's recordsA
Read-onlyIdempotent
Inspect

Read the records an agent monitor follows -- one per item its answer lists, e.g. each plan of a pricing page -- as they stand, with the page each value was read on; and, with changes=true, what moved: records added, a column changed (before and after), records gone. Use it for a monitor made with follow_rows=true, to answer what changed or what the list is now. list_monitors shows a run's summary; this is the record-level detail. Inputs: monitor_id from list_monitors. active=false lists the records gone instead. q keeps records holding it. limit is 1 to 500 (100 by default). Read-only and free: it reads stored data and never fetches.

Inputs: monitor_id (required), q, limit, active, +1 more. Returns: The records an agent monitor follows, and what moved among them.

get_projectGet a project, or the settingsA
Read-onlyIdempotent
Inspect

Read one project in full, or with no project_id the settings any project can take. Read a project before update_project to see its current values. Read the settings before create_project, update_project or any config argument: keys are exact, and a guessed name is refused. list_projects is the lighter way to find a project. Inputs: project_id is the hex id from list_projects, not a name or URL. An unknown id answers 404. Webhooks: a project's answer includes its webhook URL, the events sent there, and the last 10 deliveries with their status and error, to see whether the endpoint is receiving them. update_project sets them and sends a test. Secrets: the webhook signing secret is never returned, and chat_url comes back masked. Read-only and free: it reads stored data and never fetches.

Inputs: project_id. Returns: A project, as get_project, create_project and update_project answer with it; ge…

list_monitorsList monitors and their runsA
Read-onlyIdempotent
Inspect

List the workspace's monitors -- searches and agent questions kept on a schedule -- each with its schedule, status, next run, this month's spend and what its last run found; or, with monitor_id, one monitor with its latest runs. Call it to find a monitor_id, to see whether a kept search or question found something new, or to check spend. A run's refId is the search or agent run it made: get_job(kind='search' or 'agent', id=refId) reads it in full. Inputs: kind keeps 'search' or 'agent' ones; monitor_id reads one, with up to runs of its runs (10 by default). Read-only and free: it reads stored data and never fetches.

Inputs: kind, runs, monitor_id. Returns: The workspace's monitors.

list_pagesList, search or read a run's pagesA
Read-onlyIdempotent
Inspect

List the pages a project run stored; with q, find the pages whose text or markup matches; with url, read one page in full, with its versions across runs. Use it for what a project's runs stored: what a run covered, which pages say something, one page's text. search_web searches the live web instead, get_job reads a crawl_site crawl, scrape_urls fetches a live copy, and get_changes lists only what changed. Inputs: project_id from list_projects. q='free trial' needs both words, q='"free trial"' the phrase; mode='selector' takes CSS such as 'form#signup' and needs a run that kept html (the rawHtml format); a selector search names the pages it could not search. url is an address, not a search term: scheme and trailing slash may differ or be left out, and a path alone is the project's own site; the rest must match, query string included. Give q or url, not both. run_id from list_runs picks the run; empty is the latest full run, and a newer re-crawl of listed pages is named as newerPartialRun. Limits: a listing has up to 500 rows, shallowest first, so use q to reach pages past them. A page read in full has each body capped at 12,000 characters, and a URL the runs did not store answers 404. Read-only and free: it reads stored data and never fetches.

Inputs: project_id (required), q, url, mode, +1 more. Returns: A run's pages; with q the pages that match; with url one page in full.

list_projectsList all projectsA
Read-onlyIdempotent
Inspect

List every project in the workspace, the sites it watches over time, each with its id, name, host, schedule, page count, coverage, last run and status; and the workspace's plan and the credits it has left. Call it first to find the project_id the other project tools take, to check a site is not already watched before create_project, or to see whether there are credits for a large crawl. get_project reads one project in full. Results: every project in one answer, oldest first, with no paging. A key limited to some projects sees only those. Read-only and free: it reads stored data and never fetches.

Inputs: no named parameters. Returns: Every project the key can see.

list_runsList a project's runsA
Read-onlyIdempotent
Inspect

List a project's runs, newest first, with each run's id, status, trigger, pages read and pages changed. Use it to find a run_id for list_pages or get_changes, to check whether a run is still going before start_run, or to find the run to stop with cancel_job. get_project shows only the last run. Inputs: project_id from list_projects. limit=5 finds the latest few; runs past the limit cannot be paged. Errors: an unknown project answers 404. Read-only and free: it reads stored data and never fetches.

Inputs: project_id (required), limit. Returns: A project's runs, newest first.

map_siteMap a site's declared URLsAInspect

List the URLs a site declares in its sitemaps (found through robots.txt and the well-known paths, each index file walked to its children) without fetching any page. Use it first, to see how big a site is and what sections it has (paths counts its URLs by first path segment), before crawl_site or create_project. It cannot read content (scrape_urls and crawl_site do), and it misses pages a site links to but does not declare. Inputs: any page of the site works as url, since discovery starts at the root. search='/blog/' keeps the blog's URLs; it is a plain case-insensitive substring, not a glob, applied before limit. Cost: 1 credit per sitemap file read (usually 1 in total), never per URL. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: url (required), limit, search. Returns: The URLs a site's sitemaps declare.

pause_monitorPause or resume a monitorA
Idempotent
Inspect

Pause a monitor so it makes no more scheduled runs, or resume it. Use it when the person wants a kept search or question to stop for now, or to start again. A paused monitor keeps its runs and records; nothing is deleted. Inputs: monitor_id from list_monitors. resume=true starts it again: a slot that passed while it was paused runs once, at the next tick. Effect: it answers with the monitor. A run under way finishes. Nothing is fetched and no credits are spent by pausing. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: monitor_id (required), resume. Returns: One monitor: a search or an agent question kept on a schedule, and its latest r…

run_agentRun a research agentAInspect

Hand a research question to an agent that searches the web, maps sites and reads pages on its own, then answers with the sources it used. Use it for questions that need several pages or sites to answer. When you know what to fetch, search_web and scrape_urls are quicker and cheaper. Inputs: prompt says what to find, e.g. 'the monthly price of each plan on example.com'. urls gives pages to start from, e.g. ['https://example.com/pricing']. schema shapes the answer, e.g. {"type": "object", "properties": {"plans": {"type": "array"}}}; without one the answer is {"text": ...}. allowed_domains=['example.com'] keeps it to those sites; with urls and no allowed_domains it stays on the sites of urls, as a page could tell it to go elsewhere, and allowed_domains=[] lets it read any site. Cost: pages are charged as they are read, and a page the site refuses is free; the model's tokens at the model provider's price plus 20%. A question answered from one page typically costs 40-130 credits, most of it the model's tokens, against 1-4 for scrape_urls of that page. max_credits caps the whole run, 500 by default here; a run that reaches it stops with what it found, and continue_agent carries it on. Timing: it returns at once with a job, as an agent works for minutes. Call get_job(kind='agent', id=...) every 30 to 60 seconds; cancel_job stops it. Calling run_agent again with the same inputs in the same ten-minute window returns that run, not a new one. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: prompt (required), urls, schema, max_steps, +2 more. Returns: An agent run: its answer and the pages it rests on once finished, or a job whil…

scrape_urlsScrape pages by URLAInspect

Fetch pages whose URLs you already have and return their content. No project is created. Use crawl_site when the URLs must be found by following links, and map_site to list a site's URLs without fetching. list_pages with url reads a page a project already stored, for free. Inputs: urls come from the request or from map_site. formats adds bodies, e.g. 'markdown,text'. config overrides fetch settings, e.g. {"render_js": "always"}; get_project with no project_id lists the keys. full=true reads one URL in full and runs config.actions first, e.g. [{"type": "click", "selector": "#load-more", "repeat": "until_gone"}] or [{"type": "scroll", "repeat": 5}] (each scroll waits for the page to grow); a step's unknown key is refused. formats="markdown,screenshot" also takes a picture of the page; for one URL it is given as screenshotUrl. Cost: 1 credit for a plain fetch, 4 with a browser, +1 for a screenshot. A page the site refuses is reported as blocked and is free. A short page is rendered once to see what its scripts add (example.com adds five languages), and kept at 4 when they add text; config {"render_js": "never"} reads only what the server sent, at 1. Lists: a list runs as one batch. If it outlasts the connection's time limit, a job comes back for get_job, and sending the same list again within ten minutes returns that batch, marked reused with its ageSeconds; after that, or with force_refresh=true, the URLs are read again. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: urls (required), full, config, formats, +2 more. Returns: A scrape. A list: status, the pages with excerpts and an index of every url. On…

search_webSearch the webAInspect

Search the web for a query and return the ranked results, each with its title, url and snippet. The results are read from Google's results page; when Google refuses or reads short, from DuckDuckGo's and then Bing's, and the answer with most results about the query is given, topped up from the others. Use it to find pages whose URLs you do not know. It searches the web, unlike list_pages with q, which searches inside a project's stored run. For URLs you already have use scrape_urls; scrape_urls with full=true reads one result in full. Inputs: query as typed into a search engine, e.g. 'python http client'. scrape=true also fetches each result's page as markdown in the same call. include_domains=['python.org'] keeps the search to those sites; exclude_domains drops sites, and an exclude wins. Cost: at most 4 credits a search, whatever read it: Google's results page, and DuckDuckGo's or Bing's at 1 each when their results are used, within those 4. A results page an engine refused, or one about something else, is free. An equal search (same query, country, lang, freshness and domains) within an hour of a finished one comes from cache with no charge for the results page. Scraped pages are charged, cached or not. Timing: it waits for the results. A search aims to answer within about 35 seconds; a retry on the residential browser after Google's wall can take longer. If a search outlasts the connection's time limit, a job comes back for get_job; a scraping search whose pages are still landing returns its results with a job for the pages. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: query (required), lang, limit, scrape, +4 more. Returns: A web search: the ranked results, with an excerpt of each page when scraped, or…

start_runStart a project run nowAInspect

Crawl a project's site now with its saved settings, or re-read only the pages you list. The run is compared with the one before it. Use it after create_project or update_project, or whenever fresh results are wanted. For a site with no project use crawl_site. Inputs: project_id from list_projects. urls=['/pricing'] re-reads just those pages, resolved against the project's site, and compares them with the last full run; a URL on another site is refused before anything runs. wait=true returns the finished run instead of the queued one. Cost: 1 to 4 credits per page. A run that uses up the credit budget stops and keeps what it read. Refusals: 409 while another run is queued or running (stop it with cancel_job), and 402 with no credits left. Timing: with wait=true, a run that outlasts the connection's time limit comes back as a job for get_job. Read the results with list_pages and get_changes. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: project_id (required), urls, wait. Returns: A run of a project, or a job when a wait ran out first.

update_projectUpdate a project's settingsA
Destructive
Inspect

Change a project's name, schedule or settings, its webhook among them, and send the webhook a test. Call get_project first to see the current values. To crawl with the new settings now, follow with start_run. A project's site cannot change: to watch another site use create_project. Inputs: project_id from list_projects. Only what you pass changes, and in config only the keys given, so config={"max_pages": 200} leaves every other setting alone. schedule='manual' stops scheduled runs. Valid keys come from get_project with no project_id. A webhook is config={"webhook_url": "https://example.com/hook", "webhook_events": ["run.finished", "page.changed"]}; webhook_url="" turns it off. test_webhook=true then queues a test run.finished message, and get_project shows whether it was delivered. Effect: it answers with the updated project. Nothing is fetched and no credits are spent. A replaced value is gone, not versioned. Changing how markdown is produced (e.g. only_main_content, include_tags, exclude_tags) makes the next run a new baseline, recorded rather than compared. Needs write access; a read-only connection is refused with code 'read_only'.

Inputs: project_id (required), name, config, schedule, +1 more. Returns: A project, as get_project, create_project and update_project answer with it; ge…

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      Fetches webpages or crawls sites locally, strips noise, and converts content to clean Markdown while preserving links, enabling fast, token-efficient web scraping for AI agents and LLM pipelines.
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Fetches webpages and crawls sites locally, stripping noise and converting content into clean, link-preserving Markdown with a minimal token footprint. Supports configurable crawl depth, concurrency, robots.txt compliance, and caching for efficient AI agent and LLM pipelines.
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.