Etsy Listing Optimizer MCP
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., "@Etsy Listing Optimizer MCPWrite an Etsy listing for my wedding budget planner PDF, keywords: wedding planner printable"
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.
Etsy Listing Optimizer MCP
Write and audit Etsy listings that follow the rules and rank. Give your agent the product facts and target keywords. It returns titles that always fit Etsy's 140-character limit, 13 tags that always fit 20 characters, a structured description, and a 0–100 listing score with specific fixes. Built for digital-product and handmade sellers.
Deterministic and rule-based. Same input, same output. No LLM inside, no randomness.
No Etsy account, no API key, no network. Works only on the data you provide.
Accurate by design. It never invents descriptors like "handmade" or "gold". It uses only what you confirm, and asks about the rest.
Tools
Tool | What it does |
| 3–4 variants ( |
| Up to 13 unique tags ≤20 chars, multi-word phrases first, plural/word-order duplicates removed, characters sanitised. Returns |
| Keyword-led opening (first 160 chars), sections (why you'll love it / what's included / how it works / size / delivery), digital-download disclosure |
| Score 0–100 + grade A–F over 16 checks in title, tags, description and media, plus |
| Group a raw keyword list into themes, pick a primary per theme, flag tag-ready phrases |
| Expand a seed into long-tail variants with proven digital/physical modifiers and your attributes |
All tools are readOnlyHint: true, openWorldHint: false.
Related MCP server: FichePro MCP Server
Install
Remote (Streamable HTTP, recommended once hosted)
This server is stateless with no user data, so it is ideal to host. Deploy with one of:
Vercel:
vercel deploy(usesvercel.json+api/mcp.js; endpointhttps://<project>.vercel.app/mcp)Docker / Fly / Render / Cloud Run:
docker build -t etsy-listing-optimizer-mcp . && docker run -p 3000:3000 etsy-listing-optimizer-mcp
Then add to your client:
{ "mcpServers": { "etsy-listing-optimizer": { "url": "https://<your-host>/mcp" } } }Optional: set MCP_AUTH_TOKEN on the server and send Authorization: Bearer <token>.
Local (stdio)
Requires Node.js 20+.
{ "mcpServers": { "etsy-listing-optimizer": { "command": "npx", "args": ["-y", "https://github.com/ppiotis/etsy-listing-optimizer-mcp/archive/refs/tags/v1.0.0.tar.gz"] } } }From source: git clone https://github.com/ppiotis/etsy-listing-optimizer-mcp && cd etsy-listing-optimizer-mcp && npm ci && npm run build && node dist/stdio.js (HTTP: npm run start:http, then http://127.0.0.1:3000/mcp).
Skills included
etsy-seo-fundamentals: Etsy's hard limits and ranking best practices.etsy-listing-workflow: facts → keywords → title/tags/description → verify.etsy-listing-audit: score an existing listing and show before → after.
Security & privacy
No network calls, no telemetry, no credentials. It never touches Etsy. Runtime deps: the MCP SDK and
zod.Stateless. Nothing is stored. Each HTTP request gets a fresh server instance.
Validated input. zod schemas with length and count caps on every field; 1 MB HTTP body cap.
Hosted hardening. Optional bearer token (constant-time compare); binds to
127.0.0.1unlessHOSTis set;/healthendpoint.
Reviewer test plan
New digital listing. Add the plugin and ask: "Create an Etsy listing for my minimalist wedding budget planner PDF. Keywords: wedding budget planner, wedding planner printable, budget spreadsheet, wedding checklist. It's editable and printable." → Expect three titles, all ≤140 characters and starting "Wedding Budget Planner"; 13 tags each ≤20 characters (e.g.
budget planner,gift for bride,digital download); and a description that says no physical item ships.Hard limits. Ask: "Give me tags for a 'personalized extraordinarily beautiful watercolor nursery wall art print'" → Expect every tag ≤20 characters. Over-long phrases are shortened to their head noun or listed under
skipped, never cut mid-word.Accuracy guard. Ask: "Tags for my gold name necklace, keywords: personalized name necklace, gold name necklace, mothers day gift." → Expect fewer than 13 tags with no "handmade"/"boho", and the bot asking which of handmade / custom / minimalist… are true. Answer "handmade and dainty" →
handmade necklace,dainty necklaceappear.Audit. Paste: title "BEST PLANNER EVER planner planner planner", tags "planner, planners", description "Nice planner." and ask "score this for 'wedding budget planner'" → Expect grade F with fixes for ALL CAPS, keyword stuffing, too few tags, a duplicate plural tag, a short description and a missing keyword. Ask it to rewrite → the new version scores A/B.
Keyword research. Paste 15–20 raw keywords and ask "cluster these and pick my primary" → Expect themed clusters, a
suggested_primaryper theme, and tag-ready flags.
Development
npm ci
npm test # build + unit/property tests + e2e over stdio and Streamable HTTP
npm audit --omit=devDisclaimer
Not affiliated with or endorsed by Etsy, Inc. "Etsy" is a trademark of Etsy, Inc.
License
MIT © Paris Piotis
Available Tools
6 toolsanalyze_listingScore an Etsy listingARead-onlyIdempotent
Score a listing 0–100 (grade A–F) against Etsy best practices: title length and keyword placement, caps and stuffing, 13 tags ≤20 chars and multi-word, description length/opening/structure/disclosure, photos and video. Returns blockers and the top 5 fixes.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | Yes | ||
| price | No | ||
| title | Yes | ||
| digital | No | ||
| keywords | No | Target keywords, primary first (improves accuracy) | |
| has_video | No | ||
| description | Yes | ||
| photo_count | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavior beyond that: it discloses the return shape ('blockers and the top 5 fixes') and the grading scale/grade mapping, which matters because there is no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence that front-loads the score/grade outcome and then lists criteria, followed by a short sentence on returns. It is long but every clause adds a distinct criterion, so little is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description does the work of explaining the return ('blockers and the top 5 fixes') and the scale, and it enumerates the scoring dimensions. It is nearly complete for an 8-parameter read-only tool, with only the price/digital/keywords inputs left unexplained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 13% across 8 parameters, so the description has to carry meaning. It maps evaluation criteria to several params (title, 13 tags ≤20 chars multi-word, description structure/disclosure, photos and video), but price, digital and keywords are never explained in the description, leaving real gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb and resource ('Score a listing 0–100 (grade A–F) against Etsy best practices') and enumerates the exact dimensions being graded, which makes it unmistakably distinct from the generate_*/suggest_* siblings that produce content rather than audit it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the verb 'score' versus the sibling generators, so an agent can infer this is the audit path. However, there is no explicit when-to-use statement, no mention of when a listing should be scored versus regenerated, and no reference to any sibling by name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
cluster_keywordsCluster keywordsARead-onlyIdempotent
Group a raw keyword list (e.g. from Etsy search autocomplete, eRank or your Etsy Stats export) into themes by shared terms, pick a primary phrase per theme and flag tag-ready (≤20 char) phrases.
| Name | Required | Description | Default |
|---|---|---|---|
| keywords | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds genuine behavioral context by disclosing the processing outcome: themes are formed by shared terms, one primary phrase is selected per theme, and phrases are flagged tag-ready at the ≤20-character threshold.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence, front-loaded with the core action and followed by outputs and input examples. No filler, and the ≤20 char rule is stated inline where it is needed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so the description must convey return shape; it does so at a high level (themes, primary phrase, tag-ready flags). Limits on input size and the exact structure of each theme are not described, which leaves a small gap for a tool with a single structured parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With one parameter and 0% schema description coverage, the description carries the semantic burden and does so reasonably: it specifies that the input should be a raw keyword list and names typical sources. It does not restate the 500-item / 80-character constraints, but it adds meaning beyond the array-of-strings schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (group/cluster) and resource (raw keyword list) plus the concrete outputs: themes by shared terms, a primary phrase per theme, and tag-ready flags. The framing as an operation over a user-supplied list clearly separates it from the generate_* siblings, which create content from scratch.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Input provenance examples (Etsy autocomplete, eRank, Etsy Stats export) imply the situation in which to use it, but there is no explicit when-to-use vs alternatives guidance and no mention of when to prefer suggest_long_tail or generate_tags instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_descriptionGenerate listing descriptionBRead-onlyIdempotent
Write a structured, scannable Etsy description: keyword-rich opening (first 160 chars), highlights, what's included, how it works, size/format, delivery, and a digital-download disclosure when digital.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Product name as you'd say it to a buyer | |
| digital | No | true for digital downloads | |
| keywords | Yes | Target search phrases, most important first | |
| modifiers | No | Descriptors the seller confirms are true (e.g. handmade, editable, canva). Only these are added beyond keywords/attributes. | |
| attributes | No | ||
| dimensions | No | ||
| highlights | No | ||
| how_to_use | No | ||
| product_type | Yes | What the item is, e.g. 'wedding budget planner' | |
| call_to_action | No | ||
| whats_included | No | ||
| care_or_requirements | No | ||
| shipping_or_delivery | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description goes beyond that by disclosing output structure, a hard 160-character constraint on the opening, and a conditional rule (digital-download disclosure only 'when digital') — genuine behavioral content not in the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence ending in a colon-list; dense but every clause names a real output section, and the 'when digital' qualifier is placed at the point of relevance. No filler or restatement of the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 13 parameters, low schema coverage, no output schema, and nested objects, the description is only partially complete: it sketches the returned artifact's sections but not its length limits (e.g. Etsy's 1400-char body cap), and it leaves the more than half of undocumented inputs unexplained. Adequate to call the tool, insufficient to call it well.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 38% across 13 parameters, including a nested attributes object, so the description must compensate — and it does so only partially. It implicitly maps to keywords, highlights, whats_included, how_to_use, shipping_or_delivery, and digital, but says nothing about modifiers, attributes, dimensions, care_or_requirements, call_to_action, name, or product_type.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource ('Write a structured, scannable Etsy description') and enumerates the exact sections produced, so the agent knows precisely what artifact comes out. It does not, however, explicitly distinguish itself from siblings like generate_titles or generate_tags, relying on the reader to infer the division of labor.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use, when-not-to-use, or alternative-tool guidance at all. An agent selecting among generate_titles, generate_tags, generate_description, and suggest_long_tail gets no routing signal from this text beyond the word 'description'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_tagsGenerate 13 Etsy tagsARead-onlyIdempotent
Build up to 13 unique tags (each ≤20 characters, multi-word buyer phrases, no plural duplicates) from keywords, attributes and proven modifiers. Reports skipped phrases.
| Name | Required | Description | Default |
|---|---|---|---|
| digital | No | true for digital downloads | |
| keywords | Yes | Target search phrases, most important first | |
| modifiers | No | Descriptors the seller confirms are true (e.g. handmade, editable, canva). Only these are added beyond keywords/attributes. | |
| attributes | No | ||
| product_type | Yes | What the item is, e.g. 'wedding budget planner' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as a read-only, idempotent, non-destructive, closed-world operation, so the safety profile is covered. The description adds genuinely new behavioral context: output is capped at 13 tags, each constrained to ≤20 characters, plural duplicates are suppressed, and skipped phrases are reported back to the caller — the last of which is important because it tells the agent that partial results are possible.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the action and output constraint, then the input sources and the skipped-phrase reporting. Every clause carries information — there is no filler or restatement of the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a five-parameter generator with a nested attributes object and no output schema, the description covers what is produced (13 tags, character limit, dedup rules) and flags the skipped-phrase report, which is the closest thing to return-value disclosure. It stops short of describing tag ordering or how attributes versus keywords are prioritized when conflicts arise.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 80%, so the schema already documents keywords ('most important first'), modifiers, product_type, and most attribute fields. The description reinforces which input groups feed the tag set but adds no format, ordering, or interaction detail beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb (Build) plus the exact resource and dose (up to 13 unique tags) along with hard constraints (≤20 characters, multi-word buyer phrases, no plural duplicates) and the input sources (keywords, attributes, modifiers). That makes the tag-generation role unmistakable, though it never explicitly distinguishes itself from keyword-oriented siblings like cluster_keywords or suggest_long_tail.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the stated inputs ('from keywords, attributes and proven modifiers') and by the 'proven modifiers' qualifier that tells the caller to pass only seller-confirmed descriptors. There is no explicit when-to-use, when-not-to-use, or named alternative among the six siblings, so the agent must infer routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_titlesGenerate Etsy titlesARead-onlyIdempotent
Build 3–4 Etsy title variants (SEO keyword-first, concise ≤70, benefit-led, optional branded), each guaranteed ≤140 characters with %, :, & and + used at most once.
| Name | Required | Description | Default |
|---|---|---|---|
| brand | No | ||
| digital | No | true for digital downloads | |
| keywords | Yes | Target search phrases, most important first | |
| modifiers | No | Descriptors the seller confirms are true (e.g. handmade, editable, canva). Only these are added beyond keywords/attributes. | |
| attributes | No | ||
| product_type | Yes | What the item is, e.g. 'wedding budget planner' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, non-destructive, idempotent behavior, so the safety profile is covered. The description adds valuable output constraints (length caps, special-character limits) that go beyond the annotations, but says nothing about determinism or failure modes. Solid but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One tight sentence that front-loads the output shape, then lists variant types and formatting constraints. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Describes the output shape and formatting rules, which is the most important context for a generation tool. No output schema exists, so the description must explain return values, and it does so only partially (variant types and character rules, but not ordering or which variant is recommended). Missing sibling routing guidance for a crowded tool family.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 67%, with keywords, modifiers, digital, and several attributes already documented in the schema. The description adds the branding/brand-variant rationale and implies how modifiers are gated, but does not explain the interplay of attributes versus keywords, which is central to output quality. Baseline 3 for a schema that carries most of the load.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (build) and resource (Etsy title variants) with the exact output shape (3-4 variants). Names four distinct title strategies, which distinguishes it from siblings like generate_tags and generate_description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the Etsy-listing context and the output format, but the description never states when to call this versus generate_tags, generate_description, or suggest_long_tail. No explicit alternatives or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
suggest_long_tailSuggest long-tail keywordsBRead-onlyIdempotent
Expand a seed phrase into long-tail variants using proven Etsy modifiers (digital or physical) and your attributes, flagging which fit as tags.
| Name | Required | Description | Default |
|---|---|---|---|
| max | No | ||
| seed | Yes | ||
| digital | No | ||
| attributes | No | ||
| extra_modifiers | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds real context — variant generation via proven Etsy modifiers, a digital/physical branch, and flagging of tag-suitable results — but says nothing about ordering, volume, or output shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single well-formed sentence that front-loads the core action ('Expand a seed phrase') and packs in modifiers, attributes, and the tag-flagging outcome without padding. Efficient and free of waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only suggestion tool with no output schema, the description should hint at what comes back; 'flagging which fit as tags' gives a partial clue but does not describe the result shape or how many variants are produced. Adequate but leaves meaningful gaps for a 5-param tool with a nested object.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Top-level schema description coverage is 0%, with only a few nested attribute fields carrying inline examples. The description compensates partially by signaling the digital/physical choice and the 'attributes' input, but leaves max and extra_modifiers entirely unaddressed, so the gap is only half filled.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('expand a seed phrase into long-tail variants') and names the domain (Etsy modifiers) plus the tagging angle. It's clear what it does, though it doesn't explicitly contrast itself with generate_tags or cluster_keywords, so it falls short of full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use or when-not-to-use guidance, and no mention of the sibling alternatives (generate_tags, cluster_keywords) it overlaps with. Usage must be inferred entirely from the purpose sentence.
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.
6 tool updates
v1.0.0- First observed
analyze_listing - First observed
cluster_keywords - First observed
generate_description - First observed
generate_tags - First observed
generate_titles - First observed
suggest_long_tail
TDQS
Scored across 6 tools
Each tool targets a distinct artifact or operation: three generators produce titles, tags, and descriptions respectively, while cluster_keywords groups an existing list, suggest_long_tail expands a seed, and analyze_listing scores. Although cluster_keywords and suggest_long_tail both touch keyword expansion and tag-fit, their inputs and outputs are clearly differentiated.
All six names follow a consistent verb_noun snake_case pattern (generate_titles, generate_tags, generate_description, analyze_listing, cluster_keywords, suggest_long_tail). No mixed conventions or ambiguous verbs appear.
Six tools is well-scoped for a listing optimizer, each covering a distinct step of the listing workflow. No redundant or filler tools are present.
The surface covers the core listing lifecycle: title, tag, and description generation plus keyword clustering, long-tail expansion, and scoring. Minor gaps exist around applying fixes to an existing listing or handling non-text assets like image alt text, but analyze_listing partially covers photo/video scoring.
Maintenance
Related MCP Connectors
Programmatic SEO as callable tools: research, generate, audit and publish landing pages.
JSON/YAML, regex, diff, JWT, SQL dialects — the keyless millisecond ops an agent needs mid-task.
Agent-readiness scanner (0-5 score), robots.txt + llms.txt generators, managed agent enablement.
Generate SEO-optimized Etsy listings — title, description, and 13 tags — from your AI assistant.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to search, compare, buy, and sell products across multiple e-commerce platforms through 13 marketplace tools.1MIT
- FlicenseNot gradedqualityDmaintenanceEnables dropshippers and e-commerce operators to generate SEO-optimized product listings, score SEO, audit catalogs, discover niches and suppliers, and surface Autopilot optimizations directly from Claude.-
- AlicenseBqualityCmaintenanceProvides technical SEO tools for AI agents, including structured data generation, meta tag creation, robots.txt validation, and SERP previews, all offline with no API key or account.1818 PyPIMIT
- FlicenseBqualityCmaintenanceEnables Etsy sellers to manage their shops via natural language, including listing CRUD, bulk price and quantity updates by SKU, whole-shop A-F grade audits, photo uploads, shipping profiles, conversations, receipts, fulfillment tracking, and profit calculation.19-