# Kanto Labs (mcpb · kanto-labs-mcp.mcpb)

Web data, SEO, domain, company, trends, OCR, document and image tools for AI assistants via Apify.

- Trust score: 45/100 (low)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-28

## Components

- mcpb · `kanto-labs-mcp.mcpb`: 45/100 (this document), [markdown](https://verifymcp.io/servers/akhiyugo-kanto-labs-mcp/https-github-com-kanto-labs-kanto-labs-mcp-releases-download-v1-2-0-kanto-labs-m.md), [page](https://verifymcp.io/servers/akhiyugo-kanto-labs-mcp/https-github-com-kanto-labs-kanto-labs-mcp-releases-download-v1-2-0-kanto-labs-m)

## Channel facts

- Registry: `mcpb`
- Package: `https://github.com/kanto-labs/kanto-labs-mcp/releases/download/v1.2.0/kanto-labs-mcp.mcpb`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-28.

- **Supply Chain Security**: 23/100
  - No malware scan is available for this kind of package: the supply-chain vendors we use do not cover it. This is a permanent gap in our coverage, not a finding about the package.
  - Known CVEs were checked across the 92 of 92 dependencies we could resolve, so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - 31 of 92 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 5 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 62/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 7226 tokens (~516/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 14 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 14 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Kanto Labs MCP server?

Kanto Labs ships as an MCPB bundle, a single file you download and open in an MCP host that supports MCPB bundles, such as Claude Desktop. The host reads the launch command from the bundle's own manifest, so there is no command to copy. The MCP registry declares no SHA-256 for this bundle, so there is no published digest to check the download against.

- Download bundle: `https://github.com/kanto-labs/kanto-labs-mcp/releases/download/v1.2.0/kanto-labs-mcp.mcpb`

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-28 (score 45, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-27 (score 45, 0)

- [functional regression] Security disclosure: fail → unverified

### 2026-09-25 (score 45, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-23 (score 45)

First indexed and scored.

## MCP tools (14)

### `detect_website_tech_stack` (~318 tokens)

Detect website tech stack

Detect the technologies a website runs on: CMS, ecommerce platform, JavaScript frameworks, analytics and ad tags, CDN, hosting, payment and marketing tools (7,600+ fingerprints, with versions and confidence). Use it for lead qualification, competitor research, sales prospecting or 'what is this site built with?' questions. Reads only the public page, one request per site. Cost: $0.003 per website analyzed, billed to your Apify account; failed or unreachable sites are free. Runs the Apify actor kantolabs/website-tech-stack-detector with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `includeDescriptions` (boolean): Add a one-paragraph description of each technology (larger output). Default false.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `minConfidence` (integer): Only report technologies detected with at least this confidence (%). Default 50; 0 returns every weak guess.
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.
- `urls` (array, required): Domains or full URLs to analyze, e.g. ["shopify.com", "https://example.com/pricing"]. Duplicates are removed.

### `convert_document_to_markdown` (~387 tokens)

Convert document to Markdown

Download documents from public URLs and convert them to clean Markdown: PDF, DOCX, PPTX, XLSX/XLS, CSV, EPUB, HTML, IPYNB, MSG, TXT, JSON, XML, RSS and ZIP archives of these. Returns the Markdown plus title, page and word counts, and optional heading-aware chunks for RAG / vector databases. Use it when you need to read, summarize, quote or index a document that is only reachable by link. Cost: $0.004 per document converted, billed to your Apify account; unsupported or failed files are free. Runs the Apify actor kantolabs/document-to-markdown with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `chunkOverlap` (integer): Characters repeated between consecutive chunks. Default 150.
- `chunkSize` (integer): Split each document into heading-aware chunks of about this many characters for embeddings. Default 0 (no chunking).
- `documentUrls` (array, required): Direct links to documents, e.g. ["https://arxiv.org/pdf/1706.03762"]. Links without a file extension work; the type is detected from the file itself.
- `includeMarkdown` (boolean): Return the full Markdown text. Default true; set false when only chunks are needed.
- `maxFileSizeMb` (integer): Skip (and do not charge) files larger than this. Default 50.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `audit_website_seo` (~378 tokens)

Audit website SEO

Run an on-page SEO audit: 0-100 score and a prioritized list of issues (title, meta description, headings, canonical, indexability, structured data, Open Graph, images without alt, speed, robots.txt, sitemap, llms.txt and AI-crawler blocking), with optional broken-link checking and an internal crawl. Use it when asked to audit, review or improve a site's SEO, or to compare pages. Cost: $0.004 per page audited, billed to your Apify account; unreachable pages are free. Crawling multiplies cost: pages = urls x maxPagesPerSite at most. Runs the Apify actor kantolabs/website-seo-audit with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `checkBrokenLinks` (boolean): Request every link on each audited page and report 4xx/5xx/unreachable ones. Slower. Default false.
- `maxLinksToCheckPerPage` (integer): Upper bound on link checks per page when checkBrokenLinks is on. Default 100.
- `maxPagesPerSite` (integer): 1 (default) audits only the listed URLs. Higher values crawl internal links up to this many pages per start URL; each page is charged.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.
- `urls` (array, required): Pages or domains to audit, e.g. ["https://www.python.org"].

### `extract_text_from_image` (~579 tokens)

Extract text from images (OCR)

OCR: extract the text from images, screenshots, photos and scanned PDFs reachable by URL (PNG, JPG, WEBP, TIFF, BMP, GIF, HEIC, PDF). Returns reading-order text per image or PDF page with an average confidence, and optionally every line with its pixel bounding box. Reads English and other Latin-script languages, Chinese and Japanese; PDFs that already contain a text layer are read exactly without OCR. Use it for receipts, invoices, forms, scanned documents, screenshots and product photos when you need the words in the image, not a description of it. For digital (non-scanned) PDFs and Office files prefer convert_document_to_markdown. Cost: $0.003 per image or PDF page read ($0.008 with quality "accurate"), billed to your Apify account; failed downloads and pages with no text are free. Runs the Apify actor kantolabs/image-to-text-ocr with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `includeLines` (boolean): Also return every text line with its confidence and pixel box [x0, y0, x1, y1] (much larger output; useful for tables or finding a value next to a label). Default false.
- `maxPdfPages` (integer): Read only the first N pages of each PDF (each page is charged). Default 50.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `minConfidence` (string): Drop text lines recognized below this confidence. Default "0.5"; use "0.3" for very poor scans.
- `pdfDpi` (integer): Render resolution for scanned PDF pages. Default 200; use 300 for small print.
- `pdfMode` (string): "auto" (default) uses a PDF page's own text layer when present and OCRs only scanned pages; "ocr" always runs OCR.
- `quality` (string): "fast" (default, $0.003/page) is right for screenshots, documents and Latin-script text. "accurate" ($0.008/page, about 4x slower) is better for Japanese, dense Chinese, stylized fonts and poor photo…
- `sources` (array, required): Direct links to images or PDF files, e.g. ["https://example.com/receipt.jpg", "https://example.com/scan.pdf"]. Each image and each PDF page is one charged result.
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `lookup_domain` (~460 tokens)

Look up domain WHOIS, DNS, SSL and email security

One report per domain: registration data via RDAP/WHOIS (registered or available, registrar, creation and expiry dates, domain age, status, nameservers, DNSSEC), all DNS records (A, AAAA, MX, NS, TXT, CAA, SOA, www), the SSL certificate (valid, issuer, expiry, days left, SANs, TLS version) and email security (SPF, DKIM, DMARC, MTA-STS, detected email provider, 0-100 score and A-F grade), plus a plain-English list of issues. Accepts domains, URLs or email addresses. Use it for 'who is the registrar / when does it expire / is this domain available / is the certificate valid / who hosts their email / is DMARC set up' questions, lead enrichment and domain or certificate monitoring. No registrant personal data is returned. Cost: $0.003 per domain analyzed, billed to your Apify account; invalid domains and failed lookups are free. Runs the Apify actor kantolabs/domain-whois-dns-ssl-lookup with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `domains` (array, required): Domains, URLs or email addresses, e.g. ["stripe.com", "https://www.shopify.com/pricing", "ceo@example.org"]. Each is reduced to its registrable domain; duplicates are removed.
- `includeDns` (boolean): DNS records. Default true.
- `includeEmailSecurity` (boolean): SPF/DKIM/DMARC report with score and grade. Default true.
- `includeSsl` (boolean): SSL certificate check on port 443. Default true.
- `includeWhois` (boolean): Registration data (RDAP/WHOIS). Default true.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `extract_video_frames` (~603 tokens)

Extract frames from videos (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. Extract still frames from video files reachable by direct URL (MP4, MOV, WEBM, MKV, AVI, M4V, MPEG-TS; not YouTube or TikTok pages): an automatic storyboard of scene changes, scene cuts only, N evenly spaced frames, or one frame every N seconds. Returns public image URLs with timestamps for every frame, a free contact-sheet grid image, and the video's duration, resolution, fps and codecs. Use it to let a vision model 'watch' a video, to make thumbnails or storyboards, or to find scene changes. A call must finish within 300 seconds, so send one or a few short videos per call. Cost: $0.002 per frame extracted (default 12 frames per video = $0.024), billed to your Apify account; videos that fail to download or decode are free. Runs the Apify actor kantolabs/video-frame-extractor with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `contactSheet` (boolean): Also build one grid image of all frames with timecodes (free). Default true.
- `frameCount` (integer): Frames per video in auto and count modes. Default 12. Each frame is charged.
- `imageFormat` (string): Frame image format. Default jpg.
- `intervalSeconds` (integer): Seconds between frames in interval mode. Default 10.
- `maxFramesPerVideo` (integer): Upper limit per video in scenes and interval modes. Default 50.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `maxWidth` (integer): Scale frames down to this width in px (0 = original). Default 1280, plenty for vision models.
- `mode` (string): "auto" (default): first frame + strongest scene changes, topped up with evenly spaced frames to frameCount. "scenes": only real cuts (up to maxFramesPerVideo). "count": exactly frameCount evenly spac…
- `sceneThreshold` (string): Scene-change sensitivity (lower finds subtler changes). Default "0.3".
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.
- `videoUrls` (array, required): Direct links to video files, e.g. ["https://media.w3.org/2010/05/sintel/trailer.mp4"].

### `download_images` (~623 tokens)

Bulk download images (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. Download every image from web pages (img tags, srcset, lazy-load attributes, CSS backgrounds, optionally favicons and SVGs) and/or from direct image links, with size and format filters, de-duplication and optional conversion or resizing. Each saved image gets a public download URL plus its dimensions, format, alt text and SHA-256. Use it to collect product photos, gallery or article images, or to re-host and convert a list of image links. Only for images you have the right to use; social networks and stock-photo sites are refused. Cost: $0.002 per image saved, billed to your Apify account; duplicates, filtered-out and failed images are free. A page can hold hundreds of images, so set maxImagesPerPage and minWidth to control cost. Runs the Apify actor kantolabs/bulk-image-downloader with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `allowedFormats` (array): Keep only these formats. Omit to keep all raster formats.
- `convertTo` (string): Keep original files (default) or convert every image to one format.
- `dedupe` (boolean): Save (and charge) the same picture found at several URLs only once. Default true.
- `includeCssBackgrounds` (boolean): Also collect CSS background images (hero banners, sliders). Default true.
- `includeIcons` (boolean): Also collect favicons and touch icons. Default false.
- `includeSvg` (boolean): Also save SVG files (logos, icons). Default false.
- `maxDimension` (integer): Downscale images whose longest side exceeds this in px. 0 (default) keeps the original size.
- `maxImagesPerPage` (integer): Stop after this many images from one page. Default 200.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `minFileSizeKb` (integer): Skip (free) files smaller than this. Default 2, which removes tracking pixels.
- `minHeight` (integer): Skip (free) images shorter than this in px. Default 0.
- `minWidth` (integer): Skip (free) images narrower than this in px. 200+ drops icons, avatars and thumbnails. Default 0.
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.
- `urls` (array, required): Web page URLs (all images on the page) and/or direct image links, mixed freely, e.g. ["https://books.toscrape.com/"].

### `check_domain_authority` (~423 tokens)

Check domain authority (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. Score how authoritative (well linked) domains are: a 0-100 authority score computed from the open Common Crawl domain web graph of about 133 million domains, with the harmonic-centrality rank, PageRank rank, top-% percentile, number of subdomains seen, and the rank change and trend (up/down/stable/new) against the previous monthly graph. Accepts domains, URLs or email addresses; each is reduced to its registrable domain. Use it for link-building and outreach prospect lists, guest-post or PR vetting, expired-domain research, lead scoring and competitor tracking. It is its own open metric, NOT Moz Domain Authority or Ahrefs Domain Rating: compare domains against each other. It does not return backlinks and visits no website. Domains outside the top 12 million come back with ranked=false (score below 20) and are free. Thousands of domains finish in seconds. Cost: $0.001 per domain scored, billed to your Apify account; unranked and invalid domains are free. Runs the Apify actor kantolabs/domain-authority-checker with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `domains` (array, required): Domains, URLs or email addresses, e.g. ["stripe.com", "https://www.nytimes.com/section/world", "ceo@shopify.com"]. Reduced to the registrable domain; duplicates are removed.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `enrich_company` (~495 tokens)

Enrich company profiles (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. Turn domains, website URLs, email addresses or company names into company profiles. From one normal visit to the company's homepage: name, description, logo and favicon URLs, brand colour, language, the company's own social profile links (LinkedIn, X, Facebook, Instagram, YouTube, GitHub...), App Store / Google Play links and key pages (about, pricing, careers, contact, blog, docs). From Wikidata (open data): industries, country, headquarters, founding date, employee count and revenue (with the year of each figure), stock tickers, parent organization, legal form and LEI. Use it for CRM or lead-list enrichment, account research before a sales call, logo walls, market maps, or 'tell me about this company' questions. Names are matched on Wikidata (well-known organizations only); pass a domain for an exact match. Small businesses usually get the website fields only. Returns no personal data (no people, emails or phone numbers). Cost: $0.003 per company enriched, billed to your Apify account; unreachable domains, unknown names and invalid inputs are free. Runs the Apify actor kantolabs/company-enrichment with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `companies` (array, required): One company per item: a domain ("stripe.com"), a website URL, an email address or a company name ("Siemens"). Duplicates are removed.
- `includeWebsite` (boolean): Read the company's homepage (logo, socials, apps, key pages). Default true.
- `includeWikidata` (boolean): Firmographics from Wikidata (industry, HQ, founded, employees, revenue, ticker). Default true.
- `maxConcurrency` (integer): Companies processed in parallel. Default 10.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `upscale_image` (~670 tokens)

Upscale images with AI (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. Enlarge images 2x or 4x with Real-ESRGAN, the open-source AI super-resolution model, run inside the actor (no third-party AI API): sharper edges and textures, less blur and JPEG noise than a normal resize. Two models: "general" for photos, product shots, screenshots and scans; "anime" for anime, cartoons, illustrations, logos and line art. Transparency is kept. Returns a public download URL for each upscaled file with input and output dimensions. Use it to make small product photos, thumbnails or artwork print- or store-ready, or to enlarge small text before OCR. Inputs up to about 0.3 megapixels (640x480) are standard price (output up to 2560x1920 at 4x); bigger inputs are reduced to that size unless allowLargeImages is true, which upscales inputs up to about 2.1 MP (1920x1080) at full size at the large price. Upscaling takes about 12 s per standard image and about 80 s per large one, and a call must finish within 300 s, so send at most about 15 standard or 3 large images per call. Only images you have the right to process; social-network and stock-photo links are refused. Cost: $0.01 per image upscaled, $0.06 per large image, billed to your Apify account; failed or refused images are free. Runs the Apify actor kantolabs/ai-image-upscaler with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `allowLargeImages` (boolean): Upscale inputs up to ~2.1 MP at full size and charge the large price ($0.06). Default false: bigger inputs are first reduced to ~0.3 MP and charged $0.01.
- `imageUrls` (array, required): Direct links to images (JPEG, PNG, WEBP, GIF first frame, BMP, TIFF; up to 40 MB), e.g. ["https://example.com/product-small.jpg"].
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `model` (string): "general" (default) for photos and real-world images; "anime" for anime, cartoons, illustrations and line art.
- `outputFormat` (string): "jpeg" (default, smallest for photos), "png" (lossless, keeps transparency) or "webp" (small, keeps transparency).
- `quality` (integer): JPEG / WEBP quality. Default 95.
- `scale` (string): Upscale factor, "4" (default) or "2". Same price.
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `get_topic_trends` (~700 tokens)

Get topic interest over time (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. Measure and compare interest in topics over time, like Google Trends, from official Wikipedia pageview data (human traffic, 2015-07-01 to yesterday, CC0). Each keyword is matched to one Wikipedia article (exact title first, else the top non-disambiguation search hit; the matched article is returned so you can check it; write "Apple Inc." for the company, "apple" gives the fruit). Per topic: a daily, weekly or monthly timeline with absolute views and a 0-100 value normalised across all keywords of the call, total and average views, peak date, latest value, change percent and trend (rising/stable/falling), spike days, and interest by language edition. Use it for 'is interest in X growing?', comparing brands, products, people or technologies, seasonality, or finding the day a story broke. It counts people reading about a topic, not Google searches, and has no per-city data. About 5-10 s for 3 keywords and about a minute for 10 keywords over 12 months, so send up to about 30 keywords per call. Cost: $0.003 per topic analyzed, billed to your Apify account; keywords with no matching article are free. Runs the Apify actor kantolabs/wikipedia-trends with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `endDate` (string): Custom end date, YYYY-MM-DD. Default yesterday (UTC).
- `granularity` (string): Timeline resolution. "auto" (default) = daily up to 3 months, weekly up to about 2 years, monthly beyond.
- `includeLanguages` (boolean): Add interest by language edition. Default true; false is faster.
- `includeRedirects` (boolean): Add views of titles that redirect to the article (old names, spellings) so a renamed topic does not start from zero. Default true.
- `keywords` (array, required): Topics to compare on one scale: keywords ("bitcoin"), exact article titles ("Apple Inc.") or Wikipedia URLs.
- `language` (string): Wikipedia language edition used to match keywords: en (default), de, fr, es, ja, pt, it, ru, zh, pl, nl, ko...
- `maxLanguages` (integer): How many of the largest language editions to include. Default 10.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `platform` (string): Devices counted. Default all-access.
- `startDate` (string): Custom start date, YYYY-MM-DD (earliest 2015-07-01).
- `timeRange` (string): Period to analyse. Default past90Days. "all" = 2015-07-01 to yesterday. Ignored when startDate or endDate is set.
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `get_trending_topics` (~443 tokens)

Get trending topics (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. List what people are reading about on a given day: the most-read Wikipedia articles per country (US, GB, IN, DE, JP... readers in that country; views rounded up to the nearest 100 by Wikimedia) and/or per language edition (exact views), with rank, views and a one-line description. Main pages, search and special pages are removed. Data comes from the official Wikimedia Pageviews API (CC0) and is published about one day later, so the default day is the latest published one (usually yesterday). Use it for news and social monitoring, content ideas, or 'what is trending in Japan today?'. If neither trendingCountries nor trendingProjects is given, the English edition is listed. Cost: $0.0005 per trending article returned, billed to your Apify account; lists that fail or have no data yet are free. Runs the Apify actor kantolabs/wikipedia-trends with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `maxTrending` (integer): Articles per list. Default 25. Each is charged.
- `platform` (string): Devices counted. Default all-access.
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.
- `trendingCountries` (array): Two-letter country codes, e.g. ["US", "GB", "IN"].
- `trendingDate` (string): Day to list, YYYY-MM-DD. Default: the latest published day.
- `trendingProjects` (array): Wikipedia language editions, e.g. ["en", "de", "ja"].

### `check_website_traffic_rank` (~467 tokens)

Check website traffic rank (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. How popular is a website, worldwide and by country? From published open data (Chrome UX Report popularity ranks, CC BY 4.0, and the Majestic Million, CC BY 3.0): the global Chrome popularity tier (top 1K, 5K, 10K, 50K, 100K, 500K or 1M websites), month-over-month trend, the countries where the site ranks best and its tier in each of 40 countries, plus Majestic rank, referring subnets and IPs (a backlink-strength signal) and an overall popularityTier. Use it for lead scoring, competitor and market research, vetting publishers, affiliates or link-building targets, and market sizing by country. It gives tiers, not exact positions or monthly visit counts, and does not visit the websites. Sites below the top 1M everywhere and not in the Majestic Million come back ranked=false and are free. Cost: $0.002 per domain ranked, billed to your Apify account; unranked and invalid domains are free. Runs the Apify actor kantolabs/website-traffic-rank with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `domains` (array, required): Domains, URLs or subdomains, e.g. ["canva.com", "https://www.zalando.de/", "shop.lego.com"]. A subdomain is judged on its own, then falls back to the main site.
- `includeCountries` (boolean): Add the full per-country tier list (countryRanks). topCountries is always included. Default true.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

### `search_free_images` (~680 tokens)

Search free-to-use images (coming soon)

COMING SOON: this Kanto Labs actor is not public on the Apify Store yet. Until it is, calls return an 'actor not yet public' error and nothing is charged. Find pictures you may legally reuse: searches the 100M+ freely licensed files on Wikimedia Commons through the official MediaWiki API and returns only images under free licenses that allow commercial use (public domain, CC0, CC BY, CC BY-SA...). Each image comes with the full-size original URL, a thumbnail URL, the file page, width, height, orientation, license, license family, whether attribution or share-alike is required, the author, a ready-to-paste attribution line (text and HTML), community quality marks and any extra restrictions (trademarks, personality rights). Filter by license ("noAttribution" = public domain/CC0 only, "commercialNoShareAlike" = PD/CC0/CC BY), minimum size, orientation and file type. Use it for article featured images, product or slide visuals, maps, flags, diagrams, historical photos and licensed image datasets. Works best for concrete subjects (animals, food, places, objects, events); abstract stock concepts return fewer matches, so search for the concrete scene. Not legal advice: follow each image's license. Cost: $0.001 per image returned, billed to your Apify account; filters apply before charging and a search with no match is free. Runs the Apify actor kantolabs/free-image-search with your APIFY_TOKEN; maxTotalChargeUsd caps the spend per call.

Input parameters:

- `excludeRestricted` (boolean): Skip files with trademark, personality-rights or insignia restrictions (recommended for ads). Default false.
- `fileTypes` (array): Formats to include. Default ["jpg", "png", "webp"]; use ["svg"] for maps, flags, icons and diagrams.
- `language` (string): Preferred language for titles and descriptions, e.g. en (default), de, fr, ja.
- `license` (string): "any" (default): every free license. "commercialNoShareAlike": public domain, CC0 and CC BY only. "noAttribution": public domain and CC0 only (no credit needed).
- `maxResultsPerQuery` (integer): Images per search after filters. Default 20. Each is charged.
- `maxTotalChargeUsd` (number): Hard spending cap for this call in USD, enforced by Apify: the run stops once it has charged this much. Default 1 (server setting KANTO_MAX_CHARGE_USD).
- `minHeight` (integer): Minimum height in px. Default 0 (any).
- `minWidth` (integer): Minimum width in px. Default 0 (any).
- `orientation` (string): Default any.
- `queries` (array, required): Search terms, one per item, e.g. ["golden retriever puppy", "tokyo skyline night"]. English works best.
- `thumbnailWidth` (integer): Width of thumbnailUrl in px. Default 800. imageUrl is always the full original.
- `timeoutSecs` (integer): Give up after this many seconds (max 300, Apify's limit for synchronous runs). Default 280. For big batches, split the input into several calls.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/akhiyugo-kanto-labs-mcp/https-github-com-kanto-labs-kanto-labs-mcp-releases-download-v1-2-0-kanto-labs-m#diagnostics

## Score history

- 2026-09-28: 45
- 2026-09-27: 45
- 2026-09-26: 45
- 2026-09-25: 45
- 2026-09-24: 45
- 2026-09-23: 45

## Common questions

### What is the Kanto Labs MCP server?

Kanto Labs is an MCP server listed in the public MCP registry as io.github.Akhiyugo/kanto-labs-mcp. Web data, SEO, domain, company, trends, OCR, document and image tools for AI assistants via Apify. This page covers its MCPB bundle (https://github.com/kanto-labs/kanto-labs-mcp/releases/download/v1.2.0/kanto-labs-mcp.mcpb).

### Is the Kanto Labs MCP server safe to use?

Kanto Labs scores 45 out of 100 on VerifyMCP. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Kanto Labs MCP server expose?

Kanto Labs exposes 14 tools: detect_website_tech_stack, convert_document_to_markdown, audit_website_seo, extract_text_from_image, lookup_domain, and 9 more. Their descriptions and schemas cost roughly 7,226 tokens of context every time the server is loaded.

### What licence is the Kanto Labs MCP server under?

Kanto Labs declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- Repository: https://github.com/kanto-labs/kanto-labs-mcp
- Website: https://apify.com/kantolabs
- Changelog RSS feed: https://verifymcp.io/servers/akhiyugo-kanto-labs-mcp/https-github-com-kanto-labs-kanto-labs-mcp-releases-download-v1-2-0-kanto-labs-m.xml
- Changelog JSON feed: https://verifymcp.io/servers/akhiyugo-kanto-labs-mcp/https-github-com-kanto-labs-kanto-labs-mcp-releases-download-v1-2-0-kanto-labs-m.json
- HTML version of this page: https://verifymcp.io/servers/akhiyugo-kanto-labs-mcp/https-github-com-kanto-labs-kanto-labs-mcp-releases-download-v1-2-0-kanto-labs-m