apinoa-mcp gives MCP clients programmatic access to apinoa's live product, social, search, AI-answer, and image-translation data.
Search the apinoa docs for available operations, parameters, costs, and returned fields (free).
Run TypeScript via execute to call the apinoa API for product data from Amazon, Walmart, Shopify, TikTok Shop, and AliExpress; social profiles/posts/comments from TikTok, YouTube, Instagram, Threads, X, Reddit, and LinkedIn; search results from Google, Bing, Naver, and other engines; and AI answers from ChatGPT, Gemini, Google AI Overviews/AI Mode, and Naver.
Fan out over many queries or accounts, follow paginated results, and filter/count/rank/average inside the sandbox.
Use concurrency, persistent local storage, usage/budget controls, and 10-minute answer caching.
Translate text in images into another language while preserving layout, fonts, and colors.
Use it from Claude Code, Codex, Cursor, Claude Desktop, other MCP clients, or as a library.
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 |
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.daum: search, suggestions
apinoa.duckduckgo: search, suggestions
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.
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, daum, duckduckgo, 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.
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 3 tools
The three tools occupy completely separate roles: search_docs is free documentation discovery, execute is the paid code runner for all API work, and translate_image is a single-purpose image transformation. The descriptions explicitly reinforce the boundary ('Free: it calls nothing', 'Use it before writing code'), so an agent cannot mistake one for another.
search_docs and translate_image use a consistent snake_case verb_noun pattern, while execute is a bare verb with no noun. That deviation is minor and idiomatic for a runner tool, so the set still reads predictably.
Three tools is thin in raw count, but the design deliberately collapses 35+ platforms and hundreds of operations behind a single typed executor plus a discovery tool, so each tool earns its place. The only slightly odd member is translate_image, which is a niche add-on unrelated to the discovery/execute core.
The discover-then-execute loop covers the full domain: search_docs lists every operation, parameter, cost and return field, and execute handles calls, pagination, fan-out, persistence and usage inspection. Minor gaps exist around pre-run budget/account checks and error diagnostics outside of code, but agents can work around these inside execute.
Real-time Amazon product, seller, and search data for AI agents across 21 marketplaces.
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.
Live public Instagram and TikTok data for AI assistants: profiles, posts, stories, followers.
