This MCP server gives MCP clients live access to apinoa's product, social, search, AI-answer and image-text APIs, plus a TypeScript execution sandbox and feedback tools.
Search apinoa docs for operations, parameters, costs and return fields.
Run TypeScript in execute to call apinoa APIs, paginate, fan out, filter/aggregate, and return small results.
Retrieve product data from Amazon, Walmart, Shopify, TikTok Shop, AliExpress, Google Shopping, etc.
Retrieve social posts/profiles/comments from TikTok, YouTube, Instagram, Threads, X, Reddit, LinkedIn, etc.
Retrieve search results from Google, Bing, Naver and other search engines.
Retrieve AI answers from ChatGPT, Gemini, Google AI Overviews, Google AI Mode, Naver, etc.
Translate text embedded in images while preserving layout.
OCR images to extract text regions with confidence and bounding boxes.
Persist data between runs using the sandbox store.
Send and read feedback reports about errors, missing data or feature requests.
Use either a code-execution toolset or a fallback per-operation tool mode.
Provides access to AliExpress product data, including keyword and image-based product search, full product details, reviews, and category browsing.
Provides access to Amazon product data, including keyword and image-based product search, full product details, reviews, and category browsing.
Provides access to Instagram social data, including profiles, posts, post details, and comments.
Provides access to Reddit social data, including profiles, posts, searches, community feeds, trending content, and comments.
Provides access to Shopify product data, including product search, product details, reviews, and category browsing.
Provides access to Threads social data, including profiles, posts, post details, and comments.
Provides access to TikTok Shop product data and TikTok social data, including product search and details, reviews, categories, profiles, posts, and comments.
Provides access to Walmart product data, including keyword and image-based product search, full product details, reviews, and category browsing.
Provides access to YouTube social data, including profiles, posts, post details, searches, trending content, and comments.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@apinoa-mcp compare the top wool socks on Amazon and Walmart under $20"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server for apinoa. It gives Claude Code, Codex, Cursor and any other MCP client live product data from Amazon, Walmart, Shopify, TikTok Shop and AliExpress; posts, profiles and comments from TikTok, YouTube, Instagram, Threads, X, Reddit and LinkedIn; search results from Google, Bing, Naver and 13 more search engines; AI answers from ChatGPT, Gemini, Google AI Overviews, Google AI Mode and Naver; and image translation. Use it instead of writing a scraper.
Ask things like "which of @duolingo's last 30 TikToks got 3x its usual views", "compare the cheapest Stanley 40 oz on Amazon and Walmart", "where does example.com rank on Google for 'trail running shoes'", "does ChatGPT mention our brand when asked for the best running shoes" or "translate the text on this product photo into Korean".
Create a key under Dashboard > API keys at apinoa.com. Calls are billed to it at the API's normal rates; a call that fails is not billed.
Get a key from the terminal
npx apinoa-mcp loginIt prints a code and opens an apinoa page in your browser, where you sign in and enter the code. The new key is
saved to .env in the current folder as APINOA_API_KEY (--out <path> writes it to another file,
--no-browser only prints the address). It expires after 90 days and is listed under Dashboard > API keys,
where you can revoke it. Give it to your client as below.
Claude Code
claude mcp add apinoa -e APINOA_API_KEY=your_key -- npx -y apinoa-mcpCodex
codex mcp add apinoa --env APINOA_API_KEY=your_key -- npx -y apinoa-mcpor in ~/.codex/config.toml:
[mcp_servers.apinoa]
command = "npx"
args = ["-y", "apinoa-mcp"]
env = { APINOA_API_KEY = "your_key" }Claude Desktop, Cursor, Windsurf and others — add to the client's MCP configuration
(claude_desktop_config.json, .cursor/mcp.json, …):
{
"mcpServers": {
"apinoa": {
"command": "npx",
"args": ["-y", "apinoa-mcp"],
"env": { "APINOA_API_KEY": "your_key" }
}
}
}Requires Node.js 20 or later. The package installs Deno, which runs the model's code.
Related MCP server: Sprinklr MCP Server
Tool | What it does |
| Finds the operations for a task: how to call each, every parameter, the cost, and the fields it returns. Free |
| Runs TypeScript the model writes against the API, and returns only what the code returns or prints |
| Replaces the text in an image with a translation; returns the image |
| Reads the text in an image (OCR): every region with its text, confidence and position |
| Reports a failed call, wrong or missing data, or an API you need. Free, and works without a key |
| Reads a report's status and our reply by its id |
Instead of one tool call per API call, the model writes a short program. Fanning out over 50 accounts, following pages, filtering and averaging happen in the code, and only the answer comes back into the conversation:
const page = await apinoa.tiktok.posts({ username: "duolingo", limit: 30 });
const views = page.items.map((p) => p.metrics?.views ?? 0).sort((a, b) => a - b);
const median = views[Math.floor(views.length / 2)];
return page.items.filter((p) => (p.metrics?.views ?? 0) >= 3 * median).map((p) => p.url);Inside execute:
apinoa.<platform>.<operation>(params): one API call; returns the answer's data, throws ApinoaError
(code, status) on a refusal.
pages(op, params, { maxPages }): every item of a paged operation, following cursors.
many(items, fn, { concurrency }): fn over every item, 8 at a time; an item that fails comes back
undefined and is counted.
store.save / load / list / saveFile: data kept on your machine between runs (videos from
apinoa.tiktok.media, for example).
usage: this run's calls and units.
The code is type-checked against the API's types before it runs, so an operation, parameter or field that
does not exist fails there, before anything is billed. Each run has a budget (500 units by default, set per
run with budget_units) and stops once it is spent. Answers are cached for 10 minutes, so running fixed
code again costs nothing for the calls already made.
The code runs in a Deno subprocess that can reach only the apinoa API and read and write only its data folder: no other hosts, no other files, no environment variables, no programs. The API key never enters the code; the sandbox adds it to each request.
The platforms, operations and parameters are read from the live API catalog when the server starts, so a platform added to apinoa appears without updating this package.
APINOA_MCP_MODE=tools serves the 0.1 tools instead: one tool per kind of read (search_products,
get_product, list_social_posts, get_social_comments, call_apinoa, list_platforms, …), one API call
per tool call. The server falls back to it by itself where Deno cannot run. An answer over 100,000
characters keeps as many whole items as fit, with a note saying how many were left out.
Variable | Default | |
| — | Required for every data call. |
|
| |
|
| Where |
|
|
|
|
| Where the cache, |
|
| The most units one run may be given. |
|
| API calls in flight at once within a run. |
|
| How long an answer is reused; |
|
| The most characters of output one run hands back to the model. |
| the bundled one | Path to another |
import { createApinoaServer } from "apinoa-mcp";
const server = await createApinoaServer({ apiKey: process.env.APINOA_API_KEY });
// connect it to any MCP transport, e.g. Streamable HTTP@apinoa/sdk: the TypeScript SDK
apinoa on PyPI: the Python SDK
Official MCP Registry: listed as io.github.apinoahq/apinoa-mcp
MIT
Run TypeScript that calls the apinoa API, and get back only what it prints or returns. Use it for every data task, from one call to thousands: fan out over accounts or posts, follow pages, then filter, count, rank and average in the code, so raw API answers never fill the conversation.
The code is the body of an async function: use await, and return a small result (aggregate, slice, pick the fields you need). In scope:
apinoa..(params): one API call, returns the answer's data; throws ApinoaError (code, status) on a refusal. search_docs lists the parameters and the fields returned.
pages(op, params, { maxPages }): every item of a paged operation, following cursors (default 5 pages).
many(items, fn, { concurrency }): fn over every item, 8 at a time by default; a failed item comes back undefined.
store.save(name, value) / store.load(name) / store.list() / store.saveFile(name, base64): data kept on this machine between runs.
usage: { calls, units, budget } of this run. The code is type-checked before it runs: an operation, parameter or field that does not exist fails there, before anything is billed. Each call costs units (1 unit = $0.001, per search_docs); the run stops once budget_units are spent. Answers are cached for 10 minutes, so re-running after a fix costs nothing for calls already made. Only the API is reachable from the code.
Example: const page = await apinoa.tiktok.posts({ hashtag: "glassskin", limit: 50 }); const authors = [...new Set(page.items.map((p) => p.author.handle))].slice(0, 10); const recent = await many(authors, (u) => apinoa.tiktok.posts({ username: u, limit: 30 })); return authors.map((u, i) => { const views = (recent[i]?.items ?? []).map((p) => p.metrics?.views ?? 0).sort((a, b) => a - b); return { author: u, median: views[Math.floor(views.length / 2)] ?? null }; });
Operations (call search_docs with words or a platform for parameters, costs and the fields returned):
apinoa.aliexpress: search, browse, categories, imageSearch, product, shipping
apinoa.amazon: search, imageSearch, browse, categories, product
apinoa.app-store: search, app, reviews
apinoa.baidu: search, suggestions
apinoa.bing: search, suggestions
apinoa.chatgpt: answer
apinoa.company: technologies
apinoa.copilot: answer
apinoa.daum: search, suggestions
apinoa.dola: answer
apinoa.duckduckgo: search, suggestions
apinoa.facebook: profile, ads
apinoa.gemini: answer
apinoa.google: search, suggestions, places, place
apinoa.google-ai-mode: answer
apinoa.google-aio: answer
apinoa.google-play: search, app, reviews
apinoa.google-shopping: search, product, reviews
apinoa.google-trends: explore, trending
apinoa.instagram: profile, post, posts, comments, group, groups
apinoa.linkedin: profile, post, posts, comments, group, job, jobs
apinoa.naver: search, suggestions, places, place, reviews
apinoa.naver-ai-brief: answer
apinoa.naver-ai-tab: answer
apinoa.reddit: profile, profiles, post, posts, comments, group, groups
apinoa.seznam: search, suggestions
apinoa.shopify: search, imageSearch, catalog, product, reviews
apinoa.sogou: search, suggestions
apinoa.threads: profile, post, posts, comments
apinoa.tiktok: profile, profiles, post, posts, comments, group, groups, media
apinoa.tiktokshop: search, browse, categories, catalog, product, reviews
apinoa.tripadvisor: places, place, reviews
apinoa.walmart: search, browse, categories, product, reviews
apinoa.x: profile, post, posts, group
apinoa.yahoo: search, suggestions
apinoa.yahoo-japan: search, suggestions
apinoa.yandex: search, suggestions, places, place, reviews
apinoa.youtube: profile, profiles, post, posts, comments, groups
Inputs: code (required), budget_units, timeout_seconds.
The status of a report sent with send_feedback (received, in_progress, resolved or declined) and our reply, by its id. Free.
Inputs: id (required).
OCR: read the text in an image. Give the image as a URL. Returns every text region with its text, confidence, bounding box and polygon. Reads Chinese (Simplified and Traditional), Japanese, English and other Latin-script text. One credit per image; an image whose long side is 2.5 times its short side or more is read in sections, one credit each.
Inputs: image_url (required), language.
Find how to do a task with apinoa: the matching operations as you call them in execute (e.g. apinoa.tiktok.posts({ hashtag })), every parameter, the cost per call, and the fields of what they return. Free: it calls nothing. Use it before writing code. Pass words ('tiktok hashtag videos', 'instagram reels of an account', 'amazon product reviews'), a platform, or a type name ('Post'); with neither you get the list of every operation.
Platforms: aliexpress, amazon, app-store, baidu, bing, chatgpt, company, copilot, daum, dola, duckduckgo, facebook, gemini, google, google-ai-mode, google-aio, google-play, google-shopping, google-trends, instagram, linkedin, naver, naver-ai-brief, naver-ai-tab, reddit, seznam, shopify, sogou, threads, tiktok, tiktokshop, tripadvisor, walmart, x, yahoo, yahoo-japan, yandex, youtube.
Inputs: query, platform.
Tell apinoa when a call failed, returned wrong or missing data, or when a platform, operation or option you need does not exist. Include what you called (platform, operation, params), the request_id of the response, what came back (received) and what you expected; for a request, describe what you need in message. Free, and works without an API key. Returns an id: read the status and our reply later with get_feedback. Give contact to also get the reply by email.
Inputs: type (required), message (required), url, params, +6 more.
Replace the text inside a product image with a translation, keeping fonts, colours and layout. Give the image as a URL. Returns the translated image.
Inputs: image_url (required), source_language (required), target_language (required), font.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 6 tools
Each tool has a clearly distinct role: send_feedback/get_feedback form a lifecycle pair, search_docs is read-only discovery, execute runs code, and read_image_text/translate_image are separate image operations. There is no realistic risk of selecting the wrong tool, since execute is the sole data-access path and search_docs is explicitly documentation-only.
All names use snake_case with verb-led phrasing (send_feedback, get_feedback, search_docs, read_image_text, translate_image), which is predictable. The only minor deviation is the bare verb 'execute', though it remains clear and unambiguous.
Six tools is well-scoped for an API gateway that exposes dozens of platforms through a single programmatic execute tool. Each tool earns its place: docs discovery, execution, feedback submission/status, and two image utilities.
The surface covers the core loop: discover operations via search_docs, run them via execute, and report/resolve issues via the feedback pair, plus image OCR and translation. Minor gaps exist around account/billing status and direct operation listing without code, but these are largely workable through execute and search_docs.
Real-time Amazon product, seller, and search data for AI agents across 22 marketplaces.
Social data for AI agents: TikTok, RedNote, Douyin, WeChat, X, YouTube and more. Pay per call.
Connect e-commerce and marketing data to AI assistants via MCP.
Market data for AI agents: Douyin, Xiaohongshu, TikTok, WeChat, X and 15 more. Pay per call.
