Skip to main content
Glama
ashlrai
by ashlrai

webfetch

npm version CI License: MIT webfetch MCP server Discord GitHub stars

The license-first image layer for AI agents and humans.

One MCP server, one CLI, and one HTTP server that federate across 25 image providers, rank results license-first, and reject UNKNOWN results by default. Any agent that speaks MCP (Claude Code, Cursor, Cline, Continue, Roo Code, Codex) wires up from one config line. Landing page, pricing, and hosted usage live at getwebfetch.com.

Install

Surface

One-liner

npm

npm i -g getwebfetch

Homebrew

brew tap ashlrai/webfetch && brew install webfetch

Docker

docker run --rm ghcr.io/ashlrai/webfetch cli help

curl | bash

curl -fsSL https://raw.githubusercontent.com/ashlrai/webfetch/main/install/install.sh | bash

The curl | bash installer also wires webfetch into Claude Code's ~/.claude/settings.json idempotently. Re-run any time to update.

Related MCP server: mcp-openverse

Surfaces

Surface

Best for

Entry point

CLI

scripts, shell work, agent handoff

webfetch search ...

MCP server

Claude Code, Cursor, Cline, Continue, Roo Code, Codex

npx -y getwebfetch-mcp

HTTP server

local integrations and extensions

npx -y webfetch-server

Core library

TypeScript apps and custom tooling

npm i webfetch-core

Browser layer

fallback extraction and managed-browser flows

npm i webfetch-browser

Hosted cloud

pooled keys, usage tracking, team controls

app.getwebfetch.com

Package-level API notes live in packages/core/README.md, packages/browser/README.md, and the other package READMEs under packages/.

30-second usage

CLI:

webfetch search "drake portrait" --limit 5
webfetch artist "Taylor Swift" --kind portrait --min-width 1200
webfetch download <url> --out ./portrait.jpg
printf "drake portrait\nradiohead album\n" | webfetch batch --jsonl --continue-on-error

MCP (from inside any MCP-speaking agent):

search_images({ query: "drake portrait", limit: 5 })
search_artist_images({ artist: "Taylor Swift", kind: "portrait" })
download_image({ url: "..." })

TypeScript library:

import { searchArtistImages, pickBest, downloadImage } from "webfetch-core";

const { candidates } = await searchArtistImages("Drake", "portrait");
const best = pickBest(candidates, { minWidth: 1200 });
if (best) {
  const { cachedPath, sha256 } = await downloadImage(best.url);
  console.log(best.attributionLine, "->", cachedPath);
}

What problem this solves

Manually sourcing an image has four failure modes:

  1. You don't know the license, so you can't safely ship the result.

  2. You can't script it — every new site means another afternoon.

  3. Google's Image Search API is retired; scraping is brittle and ToS-grey.

  4. No shared cache — you re-download the same file dozens of times.

webfetch fixes all four by federating across direct-source APIs that have stable terms and structured license metadata, ranking candidates license-first, and exposing the result as a single MCP tool.

Providers

Provider

Covers

License default

Auth

Opt-in

wikimedia

portraits, events, logos, history

CC_BY_SA (metadata)

no

openverse

any CC-licensed content

CC_BY (metadata)

no

unsplash

high-quality photography

UNSPLASH_LICENSE

UNSPLASH_ACCESS_KEY

no

pexels

stock photography

PEXELS_LICENSE

PEXELS_API_KEY

no

pixabay

stock photos + illustrations

PIXABAY_LICENSE

PIXABAY_API_KEY

no

itunes

album covers, artist portraits

EDITORIAL_LICENSED

no

musicbrainz-caa

canonical album art

EDITORIAL_LICENSED

no

spotify

artist + album images

EDITORIAL_LICENSED

SPOTIFY_CLIENT_ID/SECRET

no

youtube-thumb

video thumbnails

EDITORIAL_LICENSED

yes

brave

general web image search

UNKNOWN (+heuristic)

BRAVE_API_KEY

no

bing

general web image search

UNKNOWN (+heuristic)

BING_API_KEY

yes

serpapi

Google Images + reverse lookup

UNKNOWN (+heuristic)

SERPAPI_KEY

yes

browser

headless fallback vs images.google.com

UNKNOWN

yes

managed-browser

Bright Data managed browser fallback

UNKNOWN

BRIGHTDATA_API_TOKEN

yes

flickr

CC / public-domain photography

CC_BY (metadata)

FLICKR_API_KEY

no

internet-archive

public-domain / CC archive media

PUBLIC_DOMAIN

no

smithsonian

Open Access museum media

CC0

SMITHSONIAN_API_KEY

no

nasa

NASA imagery

PUBLIC_DOMAIN

no

met-museum

The Met Open Access

CC0

no

europeana

European cultural heritage

CC_BY (metadata)

EUROPEANA_API_KEY

no

library-of-congress

US historical archive

PUBLIC_DOMAIN

no

wellcome-collection

medical/historical imagery

CC_BY (metadata)

no

rawpixel

CC0 stock slice

CC0

RAWPIXEL_API_KEY optional

no

burst

Shopify Burst stock photos

CC0

no

europeana-archival

Europeana text/manuscript records

CC_BY (metadata)

EUROPEANA_API_KEY

yes

See docs/PROVIDERS.md for gotchas, rate limits, and docs/PROVIDER_TUNING.md for per-use-case picks.

Local and cloud modes

The CLI is local-first: by default webfetch search, artist, album, download, probe, license, and batch call webfetch-core in-process and use provider API keys from your environment. Pass --cloud or set WEBFETCH_MODE=cloud to call https://api.getwebfetch.com/v1/* with WEBFETCH_API_KEY or webfetch config set apiKey wf_live_....

Use local mode when you want direct provider calls and a local cache. Use cloud mode when you want hosted auth, pooled provider keys, managed browser fallback, usage accounting, or team controls.

Why license-first

The only outcome we reject by default is an image we can't justify. A marginally-better photo under an unknown license is worthless to a pipeline that needs to ship without human review. Relevance ties are easy to break; provenance is not.

The ranker sorts by: license tag -> metadata confidence -> resolution -> provider priority. UNKNOWN is rejected by default (Berne Convention: most of the web is all-rights-reserved unless proven otherwise). See docs/LICENSE_POLICY.md.

Migration: CC0 stock providers

Older webfetch builds treated Unsplash, Pexels, and Pixabay as CC0. Current builds expose their platform terms explicitly:

Old tag

New tag

What to check

CC0 from Unsplash

UNSPLASH_LICENSE

Unsplash terms; not Creative Commons

CC0 from Pexels

PEXELS_LICENSE

Pexels terms; not Creative Commons

CC0 from Pixabay

PIXABAY_LICENSE

Pixabay terms; not Creative Commons

Most callers should keep licensePolicy: "safe-only" because it still allows open, platform, editorial, and press-kit categories while rejecting UNKNOWN. Pipelines that require only Creative Commons or public-domain assets should use licensePolicy: "open-only" and update type guards to handle the three platform tags separately.

webfetch vs alternatives

Capability

webfetch

Raw Google Images

Unsplash-only

Bing CSE

Scriptable via API

yes

no (retired)

yes

yes

License metadata per result

yes

no

yes (one lic)

partial

Covers editorial music art

yes

partial

no

partial

Covers CC / public-domain

yes

no

no

no

Safe-by-default (rejects UNKNOWN)

yes

n/a

n/a

no

Shared content-addressed cache

yes

no

no

no

Attribution line pre-built

yes

no

no

no

One MCP config line across all IDEs

yes

no

no

no

No per-query cost on defaults

yes

n/a

yes

no

Architecture

                             +------------------+
                             |  webfetch-core  |
                             |  (ranker, cache, |
                             |   license coerce)|
                             +---------+--------+
                                       |
          +----------------+-----------+-----------+----------------+
          |                |                       |                |
  +-------v------+  +------v-------+       +-------v------+  +------v-------+
  | webfetch     |  | webfetch-mcp |       | webfetch-    |  | browser      |
  | CLI          |  | (stdio)      |       | server (HTTP)|  | extensions   |
  +-------+------+  +------+-------+       +-------+------+  +------+-------+
          |                |                       |                |
          |                |                       |                |
          +----------------+-----------+-----------+----------------+
                                       |
                 +---------------------v---------------------+
                 |              provider adapters            |
                 |  wikimedia  openverse  unsplash  pexels    |
                 |  pixabay    itunes     mb-caa    spotify   |
                 |  youtube    brave      bing      serpapi   |
                 |  flickr     nasa       met       europeana |
                 |  loc        wellcome   rawpixel  burst     |
                 |  browser + managed-browser + archival opt-in|
                 +-------------------------------------------+

Every surface shares ~/.webfetch/cache/ keyed by SHA-256, so a download from the CLI is instantly available to the MCP server and vice versa.

Safety defaults

  • licensePolicy: "safe-only" — open, platform-license, and editorial/press categories are allowed; UNKNOWN is rejected.

  • safeSearch: "strict".

  • Opt-in providers (youtube-thumb, bing, serpapi, browser, managed-browser, europeana-archival) off by default.

  • 20 MB per-download cap, content-type guard, host blocklist.

  • robots.txt respected on generic page probes.

Roadmap

  • webfetch watch — daemon mode for repeated queries / incremental refresh.

  • Bring-your-own-provider plugin API.

  • Hosted tier at getwebfetch.com — pooled provider keys, managed browser fallback, team usage dashboard.

Contributing

Issues and PRs welcome. Run bun install && bun test to get started. See docs/ for per-area reference docs.

License

MIT.

Available Tools

7 tools
download_imageA

Download an image URL (typically from a prior search_images result) to the local disk cache. Streams with a 20MB hard cap, content-type guard, SHA-256 hash, and returns the cached file path. Host blocklist enforced.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYes
maxBytesNo
cacheDirNo

TDQS

A4.3/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description fully discloses key behaviors: streaming with a 20MB cap, content-type guard, SHA-256 hashing, and a host blocklist. Since no annotations are provided, this information is critical for safe and correct usage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences with no redundancy. The first sentence states the purpose, the second lists technical details, and the third adds a restriction. Information is front-loaded and every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the tool's purpose, key behaviors, and return value (cached file path). It is mostly complete for a download tool, but lacks details on optional parameters and how they affect behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description mentions a '20MB hard cap' which correlates to the maxBytes parameter but does not explain it or the cacheDir parameter. With 0% schema description coverage, the tool relies heavily on the description to clarify semantics, missing the opportunity to describe optional parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Download' and resource 'image URL', clearly stating the action and result (cached file path). It distinguishes itself from sibling tools like 'search_images' or 'fetch_with_license' by emphasizing local disk caching and typical usage from search results.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions 'typically from a prior search_images result', providing a clear context for when to use this tool. However, it does not explicitly state when not to use it or mention alternative tools for different scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fetch_with_licenseA

Given an arbitrary URL (image or webpage), determine its license via host heuristics + page metadata (, dc.rights, og tags). Set probe: true to also download the bytes. Use when an agent already has a URL and needs a go/no-go decision before shipping.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYes
probeNo

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Given no annotations, the description carries full burden; it discloses heuristics, page metadata scanning, and the probe parameter triggering download. Sufficiently transparent for a simple tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no unnecessary words. First sentence describes function, second provides usage guidance. Efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, but description implies return of license info. For a 2-param tool, it covers behavior and usage. Could mention return format or error handling.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% description coverage, but the description explains the url parameter as target and probe parameter as triggering download, adding value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'determine its license' and the resource 'URL', and distinguishes from siblings like download_image and search_images through its specific function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit usage context: 'Use when an agent already has a URL and needs a go/no-go decision before shipping.' Lacks explicit alternatives or when-not-to-use, but the context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_similarA

Reverse-image-search: given a public image URL, find visually similar images. Requires SERPAPI_KEY env var and providers: ['serpapi']. Returns candidates with heuristic licenses — treat results as leads, not shippable.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesPublic URL of the reference image
providersNo

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries the burden. It adds 'Returns candidates with heuristic licenses — treat results as leads, not shippable,' disclosing the heuristic nature and appropriate usage, which is valuable behavioral context beyond basic purpose.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences with no redundancies: purpose, prerequisite, output disclaimer. Each sentence serves a distinct, essential function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description covers purpose, a key prerequisite, and output quality. It does not address error cases or rate limits, but the tool is low-complexity with 2 params.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 50% (url has description, providers does not). Description adds 'Requires ... providers: ["serpapi"]', indicating the required provider and hinting at the role of the providers parameter. However, it does not explain individual enum options, which the schema already lists.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Reverse-image-search: given a public image URL, find visually similar images.' This is a specific verb+resource combo, and it distinguishes from sibling tools like download_image or search_images.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description mentions requirement 'Requires SERPAPI_KEY env var and providers: ["serpapi"]', giving clear context for when to use. It does not explicitly exclude alternatives, but the prerequisite is helpful.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

probe_pageA

Given a webpage URL, return every on the page with inferred dimensions and a heuristic license per image. Respects robots.txt by default. Use to triage a candidate source page before picking.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYes
respectRobotsNo

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses that the tool respects robots.txt and returns images with dimensions and license. This is transparent about its behavior, though it could mention error handling or performance.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise—two sentences that pack all necessary information. No redundant words. It front-loads the core action and then provides usage context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with no output schema and moderate complexity, the description covers what the tool returns (images with dimensions and license) and its default behavior (respects robots.txt). The context is sufficient for an agent to understand when to invoke it among siblings.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema has 2 params (url, respectRobots) with 0% description coverage. The description clarifies the purpose of the tool and implies usage of both params (url as input, respectRobots via default respect). It adds meaning beyond the raw schema, especially for the boolean parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (return every <img> on a webpage), the resource (given a URL), and the output (images with dimensions and license). It distinguishes itself from siblings like download_image or fetch_with_license by focusing on triaging a source page.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states 'Use to triage a candidate source page before picking', indicating the intended use case. It also mentions respecting robots.txt by default, providing a constraint. However, it does not explicitly state when not to use or mention alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_album_coverA

Find canonical album artwork. Uses MusicBrainz Cover Art Archive + iTunes + Spotify. Results are EDITORIAL_LICENSED — safe for album identification UI per platform ToS; always show attribution.

ParametersJSON Schema
NameRequiredDescriptionDefault
artistYes
albumYes
providersNo
safeSearchNo
licensePolicyNo
maxPerProviderNo
minWidthNo
minHeightNo
timeoutMsNo

TDQS

A3.9/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses that results are editorial-licensed and safe per ToS, which is key behavioral info. No annotations provided, so description covers safety. Could add more on failure modes or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, efficient and front-loaded. However, lacks structure or parameter hints. No wasted words, but could be slightly more informative.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 9 parameters and no output schema, description is incomplete. It doesn't explain return format or behavior for missing results. Adequate for a simple search but not comprehensive.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%; description does not mention any parameters despite there being 9, including required ones. Schema is detailed, but description fails to add meaning beyond it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses specific verb 'Find' and resource 'canonical album artwork', clearly distinguishing from sibling tools like search_images and search_artist_images. Mentions specific data sources (MusicBrainz, iTunes, Spotify) and licensing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

States use case 'album identification UI' and attribution requirement. Implicitly differentiates from siblings but lacks explicit when-to-use vs alternatives. Clear context provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_artist_imagesA

Specialized image search for a musical artist. kind selects provider set + query expansion: 'portrait' (Wikimedia + Unsplash + Spotify), 'album' (MusicBrainz CAA + iTunes + Spotify), 'logo' (Wikimedia), 'performing' (Wikimedia + Pexels). Prefer this over search_images when building artist/band content.

ParametersJSON Schema
NameRequiredDescriptionDefault
artistYes
kindNoportrait
providersNo
safeSearchNo
licensePolicyNo
maxPerProviderNo
minWidthNo
minHeightNo
timeoutMsNo

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It explains the behavioral differences based on the 'kind' parameter (provider sets and query expansion). However, it does not disclose any other behavioral traits such as read-only nature, pagination, or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with a few sentences, front-loaded with the purpose. It could be more structured, but it is not overly long and gets to the point.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of output schema and missing parameter descriptions, the description should be more comprehensive. It only covers the 'kind' parameter and one usage scenario, leaving many parameters and the return format unexplained.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It only explains the 'kind' parameter in detail; the other 8 parameters (like safeSearch, licensePolicy, maxPerProvider, etc.) are not described at all. This adds minimal value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it is a specialized image search for a musical artist, and explicitly distinguishes this tool from sibling search_images by saying 'Prefer this over search_images when building artist/band content.' It also explains the purpose of the 'kind' parameter with specific provider sets.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit guidance on when to use this tool over search_images for artist/band content. However, it does not mention when not to use it or provide alternatives for other contexts, and lacks details about other sibling tools like search_album_cover.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_imagesA

Federated image search across license-aware providers (Wikimedia Commons, Openverse, Unsplash, Pexels, Pixabay, iTunes, MusicBrainz CAA, Spotify, Brave). Returns concise ranked candidates with license + attribution. Does NOT auto-download — call download_image after. Default safe-only policy includes open, platform-license, editorial/press tags and rejects UNKNOWN. Use open-only for CC/public-domain only. For large batches, prefer CLI: webfetch batch --jsonl --continue-on-error.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesWhat to search for (e.g., 'Drake musician portrait')
providersNo
safeSearchNo
licensePolicyNo
maxPerProviderNo
minWidthNo
minHeightNo
timeoutMsNo

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses search behavior (federated, license-aware), return format (candidates with license+attribution), and safe policy details. No annotations provided, so description carries burden; could mention failure modes or limits, but overall good disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is fairly concise and front-loaded with key information (search purpose, no auto-download, policy). A few clauses (e.g., 'Default safe-only policy includes...') could be tightened, but overall efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 8 parameters, no output schema, and complex providers, description covers search scope, license awareness, policy, and pointer to download_image. Missing output format details but adequate for use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Description mentions query and providers implicitly but does not explain parameters beyond schema. Schema coverage is low (13%), yet description adds minimal parameter guidance (e.g., no details on timeoutMs, minWidth, etc.).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it performs 'Federated image search across license-aware providers' and returns 'concise ranked candidates with license + attribution.' It distinguishes from sibling tools like download_image which handles downloading.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when not to use ('Does NOT auto-download — call download_image after'), describes default policy and when to use open-only, and suggests using CLI for large batches.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 7 tool updates
    • First observeddownload_image
    • First observedfetch_with_license
    • First observedfind_similar
    • First observedprobe_page
    • First observedsearch_album_cover
    • First observedsearch_artist_images
    • First observedsearch_images

TDQS

A4.2/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose: downloading, license checking, reverse image search, page probing, and three specialized search tools (general, album art, artist). No ambiguity between them.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern with underscores (e.g., download_image, search_images). No mixing of conventions.

Tool Count5/5

Seven tools cover the domain of image fetching and license checking without being excessive. Each tool earns its place, and the count is appropriate for the server's purpose.

Completeness4/5

The set covers core workflows (search, download, license check, find similar, probe page). Minor gaps exist like a generic URL fetcher for non-image content, but the server's focus on images makes this acceptable.

Maintenance

ActivityStale
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • A
    license
    A
    quality
    D
    maintenance
    An MCP server for searching and retrieving photos from Unsplash with proper attribution, designed for LLMs building content pages.
    3
    24
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    MCP server for searching and retrieving Creative-Commons-licensed images and audio from Openverse. Enables AI agents to query open media content.
    5
    MIT
  • A
    license
    B
    quality
    C
    maintenance
    MCP server for searching and attributing images from Openverse and Wikimedia Commons, enabling insertion via insertUrl and attribution formatting.
    2
    9
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ashlrai/webfetch'

If you have feedback or need assistance with the MCP directory API, please join our Discord server