# Dropshipping Mcp Dsers (`lofder/dropshipping-mcp-dsers`) Actor
Open-source MCP server that automates DSers dropshipping workflows with AI. Import products from AliExpress, Alibaba & Accio to Shopify and Wix stores — search suppliers, apply pricing rules, batch import, and push to multiple stores through natural language.
- **URL**: https://apify.com/lofder/dropshipping-mcp-dsers.md
- **Developed by:** [issac](https://apify.com/lofder) (community)
- **Categories:** E-commerce, MCP servers, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
Pay per usage
This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.
Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage
## What's an Apify Actor?
Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
## DSers MCP Product — Dropshipping Automation: AliExpress to Shopify & Wix with AI
[](https://safeskill.dev/scan/@lofder/dsers-mcp-product)
[](https://smithery.ai/server/@dsersx/product-mcp)
[](https://www.npmjs.com/package/@lofder/dsers-mcp-product)
[](https://registry.modelcontextprotocol.io/servers/io.github.lofder/dsers-mcp-product)
[](https://glama.ai/mcp/servers/lofder/dsers-mcp-product)
> An open-source MCP server to automate DSers product sourcing, import, bulk edit, and push to Shopify or Wix using AI.
> [English](#english) | [中文](#中文)
---
### English
**DSers MCP Product** is an open-source [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server that lets AI Agents automate the entire DSers import workflow — from product sourcing to Shopify or Wix store listing. Search the DSers product pool, import from AliExpress / Alibaba / [Accio.com](https://www.accio.com/), bulk edit variants, apply pricing rules, and push to multiple stores — all with a single sentence to your AI agent.
##### What can it do?
- **Product sourcing** — search the DSers product pool by keyword or image, find products to sell
- **One-click import** — paste a product link, your AI agent imports it into DSers automatically
- **Browse your catalog** — view your import staging list and products already pushed to stores
- **Clean up titles** — strips the messy keyword-stuffed AliExpress titles into something readable
- **Pricing rules** — markup multiplier (e.g. 2.5x), fixed markup (e.g. +$5), compare-at / sale prices
- **Batch import** — import multiple products at once with a list of URLs
- **Multi-store push** — push one product to all your connected Shopify & Wix stores in one go
- **Safety checks** — automatically blocks pushes that would result in below-cost pricing, zero price, or zero stock
- **SEO optimization** — let AI rewrite the title and description for better search rankings before pushing
The server is hosted on [Vercel](https://ai.silentrillmcp.com/dropshipping/mcp) and published across multiple platforms:
#### Available On
| Platform | Link |
|----------|------|
| npm | [npmjs.com/package/@lofder/dsers-mcp-product](https://www.npmjs.com/package/@lofder/dsers-mcp-product) |
| MCP Registry (Official) | [registry.modelcontextprotocol.io](https://registry.modelcontextprotocol.io/servers/io.github.lofder/dsers-mcp-product) |
| Smithery | [smithery.ai/server/@dsersx/product-mcp](https://smithery.ai/server/@dsersx/product-mcp) |
| Glama.ai | [glama.ai/mcp/servers/lofder/dsers-mcp-product](https://glama.ai/mcp/servers/lofder/dsers-mcp-product) |
| mcp.so | [mcp.so/server/dsers-mcp-product](https://mcp.so/server/dsers-mcp-product) |
| mcpservers.org | [mcpservers.org](https://mcpservers.org) |
| MCP Marketplace | [mcp-marketplace.io](https://mcp-marketplace.io/server/io-github-lofder-dsers-mcp-product) |
| awesome-mcp-servers | [punkpeye/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers) |
| Dev.to | [Article: I Built an MCP Server to Automate Dropshipping](https://dev.to/_95a3e57463e6442feacd0/i-built-an-mcp-server-to-automate-dropshipping-product-imports-3m5b) |
| Dev.to | [Tutorial: How to Automate AliExpress to Shopify with AI](https://dev.to/_95a3e57463e6442feacd0/how-to-automate-aliexpress-to-shopify-product-import-with-ai-step-by-step-guide-3f5a) |
#### Supported product sources
Works with product links from **AliExpress**, **Alibaba.com**, and **[Accio.com](https://www.accio.com/)**. Just give your AI agent a product link from any of these platforms, and it will import the product into DSers and push it to your store. (1688.com links are also recognized but require your DSers account to have 1688 source authorization enabled.)
#### Accio.com — AI-powered product sourcing
[Accio.com](https://www.accio.com/) is Alibaba's AI sourcing assistant. You describe what you're looking for (e.g. "wireless earbuds under $5"), and it searches AliExpress & Alibaba for you.
**How to use it with DSers MCP:**
1. Go to [accio.com](https://www.accio.com/) and search for products in natural language.
2. Browse the results. When you find a product you like, **click on it** to open the product detail panel.
3. **Copy the URL** from your browser address bar — it will look something like:
`https://www.accio.com/c/xxx?productId=1005009871053792&ds=aliexpress.com`
4. Give that link to your AI agent, e.g.: *"Import this product and push to my store: [paste URL]"*
5. The agent handles the rest — no extra setup needed.
This works for both AliExpress and Alibaba products found on Accio.
#### Documentation
| Document | Description |
|----------|-------------|
| [ARCHITECTURE.md](ARCHITECTURE.md) | Three-layer architecture, directory structure, data flow |
| [USAGE.md](USAGE.md) | Installation, client config (Cursor, Claude Desktop), scenario examples |
| [SKILL.md](SKILL.md) | AI agent instruction file — workflow, rules, push options, error handling |
#### What You Need
- A [DSers](https://www.dsers.com/) account (free plan works)
- A Shopify or Wix store already connected in DSers
- An MCP-compatible AI client — [Cursor](https://cursor.sh/), [Claude Desktop](https://claude.ai/desktop), [Windsurf](https://codeium.com/windsurf), or any client that supports MCP
#### Quick Start
**Step 1: Log in (one time — opens your browser)**
```bash
npx @lofder/dsers-mcp-product login
````
A browser window opens to the official DSers login page. You log in on DSers's own website — your password **never** passes through this tool. After login, the session is encrypted and saved locally.
**Step 2: Add to your MCP client (no credentials needed)**
```json
{
"mcpServers": {
"dsers-mcp-product": {
"command": "npx",
"args": ["-y", "@lofder/dsers-mcp-product"]
}
}
}
```
That's it. No passwords in config files.
**Remote server (no install needed):**
If you don't want to install anything locally, you can connect directly to the hosted MCP server at `https://ai.silentrillmcp.com/dropshipping/mcp`. This works with any MCP client that supports Streamable HTTP transport. You'll be prompted to authorize with your DSers account on first connect.
```json
{
"mcpServers": {
"dropshipping": {
"url": "https://ai.silentrillmcp.com/dropshipping/mcp"
}
}
}
```
Also listed on the official [MCP Registry](https://registry.modelcontextprotocol.io/servers/io.github.lofder/dsers-mcp-product).
#### Authentication — OAuth 2.1
Your DSers password **never touches this tool**. Here's how login works:
1. You run `npx @lofder/dsers-mcp-product login`
2. Your browser opens the DSers OAuth authorization page
3. You authorize access on DSers's own website
4. The tool receives an OAuth token and encrypts it locally
5. Done — the MCP server uses the token automatically. No passwords in config files.
**Tokens refresh automatically** — a long-lived refresh token keeps your session active without manual re-login. You should rarely need to run `login` again.
**Switching accounts?**
```bash
npx @lofder/dsers-mcp-product logout
npx @lofder/dsers-mcp-product login
```
> **For developers:** The server also accepts `DSERS_ACCESS_TOKEN` and `DSERS_REFRESH_TOKEN` env vars for headless/CI environments.
#### Usage Examples
Once set up, just talk to your AI agent in plain language:
> "Import this product and push to my Shopify store as a draft: https://www.aliexpress.com/item/1005006372921430.html"
> "Import this product, mark up the price by 2.5x, and push it: https://www.aliexpress.com/item/1005006372921430.html"
> "Batch import these 3 products and push them all to my store: \[URL1] \[URL2] \[URL3]"
> "Search for phone cases under $5 on the DSers product pool"
> "Show me what's in my import list"
> "What products have I pushed to my store?"
> "Push this product to all my connected stores"
> "Rewrite the title and description for SEO, then push to my store"
The agent figures out the right tools to call. You don't need to know tool names or parameters.
#### Install via Smithery
```bash
npx @smithery/cli mcp add @dsersx/product-mcp --client cursor
```
Or browse at [smithery.ai/server/@dsersx/product-mcp](https://smithery.ai/server/@dsersx/product-mcp).
#### Install from Source
```bash
git clone https://github.com/lofder/dsers-mcp-product.git
cd dsers-mcp-product
npm install
npm run build
npm test
```
#### Project Structure
```
dsers-mcp-product/
├── src/
│ ├── cli.ts ## npx entry — stdio transport, login/logout
│ ├── index.ts ## MCP server init, tool registration
│ ├── instructions.ts ## Server-level prompts (agent instructions)
│ ├── tools.ts ## 12 MCP tools — schema + handler
│ ├── rules.ts ## Rule validation & application engine
│ ├── push-guard.ts ## Pre-push safety checks
│ ├── push-options.ts ## Push option normalization
│ ├── resolver.ts ## URL normalization (AliExpress/Alibaba/Accio)
│ ├── provider/ ## DSers API adapter (split by concern)
│ │ ├── index.ts ## Provider class + interface
│ │ ├── store.ts ## Store discovery, platform detection
│ │ ├── import-ops.ts ## Import, save draft, delete
│ │ ├── push.ts ## Push execution, shipping logistics
│ │ ├── normalize.ts ## Data normalization
│ │ └── helpers.ts ## Shared utilities
│ ├── service/ ## Business logic orchestration
│ │ ├── index.ts ## ImportFlowService class
│ │ ├── import-flow.ts ## Import workflows
│ │ ├── push-flow.ts ## Push workflows
│ │ ├── preview.ts ## Preview & visibility
│ │ ├── status.ts ## Job status & deletion
│ │ ├── import-list.ts ## Import list browsing (with enrich)
│ │ ├── my-products.ts ## Pushed products browsing
│ │ └── find-product.ts ## Product pool search
│ ├── dsers/ ## Low-level DSers API wrappers
│ │ ├── config.ts ## Configuration
│ │ ├── auth.ts ## Session management
│ │ ├── client.ts ## Authenticated HTTP client
│ │ ├── account.ts ## Store & user APIs
│ │ ├── product.ts ## Product & import APIs
│ │ └── settings.ts ## Shipping, pricing, billing APIs
│ └── auth/ ## Browser login (CDP)
├── test/ ## Vitest unit tests (298 tests)
├── package.json
└── tsconfig.json
```
#### Twelve Tools
| ## | Tool | What it does |
|---|------|-------------|
| 1 | `dsers_store_discover` | See your connected stores, shipping methods, pricing rules, and capabilities |
| 2 | `dsers_rules_validate` | Test your pricing or title rules before applying — catches mistakes early |
| 3 | `dsers_product_import` | Paste a product URL, optionally apply pricing/title rules, and get a preview before pushing |
| 4 | `dsers_product_preview` | Review a product you already imported — title, price, variants, stock at a glance |
| 5 | `dsers_product_update_rules` | Edit pricing, content, images, or variant rules on an already-imported product (incremental merge — no re-import needed) |
| 6 | `dsers_product_visibility` | Set whether the product shows up in your store or stays as a hidden draft |
| 7 | `dsers_store_push` | Send products to your Shopify or Wix store — one at a time, in bulk, or to all stores at once |
| 8 | `dsers_job_status` | Check if a push finished and whether it succeeded |
| 9 | `dsers_product_delete` | Delete a product from the DSers import list (irreversible, requires confirmation) |
| 10 | `dsers_import_list` | Browse your import staging list with cost & sell price, stock, markup status |
| 11 | `dsers_my_products` | See products already pushed to a store, with supplier links for re-import |
| 12 | `dsers_find_product` | Search the DSers product pool by keyword or image — results link directly to import |
All tools return clear error messages so your AI agent knows what went wrong and what to do next.
#### Pre-Push Safety Checks
Before pushing a product to your store, the tool automatically checks for common mistakes:
- **Hard blocks** (push won't go through): selling below supplier cost, zero sell price, all variants out of stock
- **Warnings** (push goes through, but you'll see a heads-up): profit margin below 10%, stock under 5 units, sell price under $1
If something looks wrong, your AI agent will tell you exactly which variant has the problem and why. If you're sure it's fine, you can override with `force_push`.
#### Pricing Rule Conflict Detection
If your DSers store has its own **Pricing Rule** enabled (basic/standard/advanced), and you also set pricing rules through MCP, the push will be **blocked** — not just warned. The agent will show two fix options:
1. Set `pricing_rule_behavior='apply_store_pricing_rule'` in push options to accept the store's pricing rule
2. Disable the Pricing Rule in your DSers store settings to use MCP pricing instead
#### Four Prompts
Ready-made workflows your AI client can use directly:
| Prompt | Description |
|--------|-------------|
| `dsers_workflow_quick-import` | Import a single product and push to store as draft |
| `dsers_workflow_bulk-import` | Batch import with pricing multiplier |
| `dsers_workflow_multi-push` | Push one product to all connected stores |
| `dsers_workflow_seo-optimize` | Import, AI-rewrite title & description for SEO, then push |
#### Environment Variables
| Variable | Required | Description |
|----------|----------|-------------|
| `DSERS_ENV` | No | `production` (default) or `test` |
| `DSERS_BASE_URL` | No | Override API base URL |
| `IMPORT_MCP_STATE_DIR` | No | Job state directory (default: `.state`) |
#### What's Next
- Product pool search enhancements (category filters, URL-based search, product detail view)
- Support more store platforms that DSers already connects to (eBay, Wish, etc.)
- Smarter pricing rule templates
- More granular inventory sync options
Got an idea or feature request? [Open an issue](https://github.com/lofder/dsers-mcp-product/issues) — contributions are very welcome.
#### FAQ
**What is DSers MCP Product?**
DSers MCP Product is a free, open-source MCP server that automates dropshipping product imports from AliExpress, Alibaba, and 1688 to Shopify and Wix stores using AI agents like Claude and Cursor. Instead of manually copying product data, you tell your AI agent what to do in plain English.
**How does it work?**
You type a command like "Import this product, mark up 2.5x, push to my store" in Cursor or Claude Desktop. The MCP server handles the entire workflow: fetching product data, applying pricing rules, editing variants, and pushing to your connected stores.
**Is it free?**
Yes. The tool is open-source (MIT license) and completely free to use. You only need a free DSers account and a Shopify or Wix store connected in DSers.
**Is it safe? Do I need to share my password?**
No passwords are stored or transmitted. Authentication uses a zero-password browser login — you log in on DSers's own website, and the tool picks up the session token. Your credentials never touch the MCP server. The project scored 92/100 on [SafeSkill](https://safeskill.dev/scan/@lofder/dsers-mcp-product) security scanning.
**What AI clients does it support?**
Cursor, Claude Desktop, Claude Code, Windsurf, and any MCP-compatible client that supports stdio transport.
**How is this different from AliDropify, AutoDS, or other dropshipping tools?**
Most dropshipping tools have their own UI and require you to click through web interfaces. DSers MCP Product takes a fundamentally different approach — it connects directly to your AI agent, so you automate workflows through conversation instead of clicking buttons. It's also open-source and free, with no subscription tiers.
**What product sources does it support?**
AliExpress, Alibaba.com, Accio.com (Alibaba's AI sourcing tool), and 1688 (requires DSers authorization).
**Can I push to multiple stores at once?**
Yes. The `dsers_store_push` tool supports pushing a single product to all your connected Shopify and Wix stores in one command, with per-store pricing and visibility options.
#### Also Available
A [Python version](https://github.com/lofder/dsers-mcp-product-py) is available for local stdio deployments.
#### License
MIT
***
### 中文
**DSers MCP Product** 是一个开源的 [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) 服务器，让 AI Agent 自动完成 DSers 的整个商品流程 —— 从选品搜索到 Shopify 或 Wix 店铺上架。搜索 DSers 商品池、从速卖通 / Alibaba / [Accio.com](https://www.accio.com/) 导入商品、批量编辑变体、应用定价规则、推送到多个店铺 —— 只需一句话给你的 AI agent。
##### 能做什么？
- **选品搜索** — 在 DSers 商品池里按关键词或图片搜索，找到值得卖的商品
- **一句话导入** — 贴个商品链接，AI 助手自动导入到 DSers
- **浏览商品库** — 查看导入待推送列表和已上架商品，包含成本价、售价、加价状态
- **标题清理** — 把速卖通那些关键词堆砌的乱标题整理成人话
- **定价规则** — 加价倍率（比如 2.5 倍）、固定加价（比如 +5 美金）、划线价
- **批量导入** — 一次丢一堆链接，全部导入
- **多店铺推送** — 一个商品一次推到你所有的 Shopify 和 Wix 店铺
- **安全校验** — 推送前自动拦截低于成本价、零售价为零、库存为零的商品
- **SEO 优化** — 让 AI 重写标题和描述，提高搜索排名后再推送
服务已托管在 [Vercel](https://ai.silentrillmcp.com/dropshipping/mcp)，并发布到多个平台：
#### 发布平台
| 平台 | 链接 |
|------|------|
| npm | [npmjs.com/package/@lofder/dsers-mcp-product](https://www.npmjs.com/package/@lofder/dsers-mcp-product) |
| MCP Registry（官方） | [registry.modelcontextprotocol.io](https://registry.modelcontextprotocol.io/servers/io.github.lofder/dsers-mcp-product) |
| Smithery | [smithery.ai/server/@dsersx/product-mcp](https://smithery.ai/server/@dsersx/product-mcp) |
| Glama.ai | [glama.ai/mcp/servers/lofder/dsers-mcp-product](https://glama.ai/mcp/servers/lofder/dsers-mcp-product) |
| mcp.so | [mcp.so/server/dsers-mcp-product](https://mcp.so/server/dsers-mcp-product) |
| mcpservers.org | [mcpservers.org](https://mcpservers.org) |
| MCP Marketplace | [mcp-marketplace.io](https://mcp-marketplace.io/server/io-github-lofder-dsers-mcp-product) |
| awesome-mcp-servers | [punkpeye/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers) |
| Dev.to | [技术文章：I Built an MCP Server to Automate Dropshipping](https://dev.to/_95a3e57463e6442feacd0/i-built-an-mcp-server-to-automate-dropshipping-product-imports-3m5b) |
| Dev.to | [教程：How to Automate AliExpress to Shopify with AI](https://dev.to/_95a3e57463e6442feacd0/how-to-automate-aliexpress-to-shopify-product-import-with-ai-step-by-step-guide-3f5a) |
#### 支持的商品来源
支持 **速卖通（AliExpress）**、**Alibaba.com** 和 **[Accio.com](https://www.accio.com/)** 的商品链接。把任意平台的商品链接丢给你的 AI 助手，它就能自动导入 DSers 并上架到你的店铺。（1688 链接也能识别，但需要你的 DSers 账号开通了 1688 来源权限。）
#### Accio.com — AI 智能找商
[Accio.com](https://www.accio.com/) 是阿里巴巴的 AI 选品助手。你用自然语言描述想找的商品（比如"5 美金以下的蓝牙耳机"），它会帮你在速卖通和阿里巴巴上搜索。
**怎么配合 DSers MCP 用：**
1. 打开 [accio.com](https://www.accio.com/)，用自然语言搜索你想要的商品。
2. 在搜索结果里浏览，看到感兴趣的商品**点击进去**看详情。
3. **复制浏览器地址栏的链接**，大概长这样：
`https://www.accio.com/c/xxx?productId=1005009871053792&ds=aliexpress.com`
4. 把链接丢给你的 AI 助手，比如说：*"帮我导入这个商品并上架：\[粘贴链接]"*
5. 剩下的 AI 助手会自动搞定，不需要任何额外设置。
Accio 上搜出来的速卖通和阿里巴巴商品都能用。
#### 文档
| 文档 | 说明 |
|------|------|
| [ARCHITECTURE.md](ARCHITECTURE.md) | 三层架构、目录结构、数据流 |
| [USAGE.md](USAGE.md) | 安装、客户端配置（Cursor、Claude Desktop）、使用场景 |
| [SKILL.md](SKILL.md) | AI agent 指令文件 — 工作流、规则、推送选项、错误处理 |
#### 使用前提
- 一个 [DSers](https://www.dsers.com/) 账号（免费版就行）
- Shopify 或 Wix 店铺已经在 DSers 里绑定好了
- 一个支持 MCP 的 AI 客户端 — [Cursor](https://cursor.sh/)、[Claude Desktop](https://claude.ai/desktop)、[Windsurf](https://codeium.com/windsurf) 或其他支持 MCP 的工具
#### 快速开始
**第 1 步：登录（一次性操作，会打开浏览器）**
```bash
npx @lofder/dsers-mcp-product login
```
浏览器会自动打开 DSers 官方登录页。你在 DSers 自己的网站上登录 —— 密码**完全不经过**本工具。登录后 session 加密保存到本地。
**第 2 步：添加到你的 MCP 客户端（不需要密码）**
```json
{
"mcpServers": {
"dsers-mcp-product": {
"command": "npx",
"args": ["-y", "@lofder/dsers-mcp-product"]
}
}
}
```
搞定。配置文件里不需要任何密码。
**在线版（免安装）：**
如果不想在本地安装，可以直接连接托管的 MCP 服务端 `https://ai.silentrillmcp.com/dropshipping/mcp`。支持 Streamable HTTP transport 的 MCP 客户端都能用，首次连接会引导你授权 DSers 账号。
```json
{
"mcpServers": {
"dropshipping": {
"url": "https://ai.silentrillmcp.com/dropshipping/mcp"
}
}
}
```
同时已收录到官方 [MCP Registry](https://registry.modelcontextprotocol.io/servers/io.github.lofder/dsers-mcp-product)。
#### 授权认证 — OAuth 2.1
你的 DSers 密码**完全不经过本工具**。登录过程是这样的：
1. 运行 `npx @lofder/dsers-mcp-product login`
2. 浏览器自动打开 DSers OAuth 授权页
3. 你在 DSers 网站上授权
4. 工具拿到 OAuth token，加密存到本地
5. 搞定 — 之后 MCP 直接能用，配置文件里不需要写任何密码
**Token 自动续期** — refresh token 会自动保持登录状态，你基本不需要重新登录。
**换账号？**
```bash
npx @lofder/dsers-mcp-product logout
npx @lofder/dsers-mcp-product login
```
> **开发者注：** headless / CI 环境支持通过 `DSERS_ACCESS_TOKEN` 和 `DSERS_REFRESH_TOKEN` 环境变量传入凭据。
#### 使用示例
装好之后，直接用自然语言跟 AI 助手说就行：
> "帮我导入这个商品，推到我的 Shopify 店铺草稿：https://www.aliexpress.com/item/1005006372921430.html"
> "导入这个商品，加价 2.5 倍，然后推送：https://www.aliexpress.com/item/1005006372921430.html"
> "批量导入这 3 个商品，全部推到店铺：\[链接1] \[链接2] \[链接3]"
> "帮我搜一下 5 美金以下的手机壳"
> "看下我的导入列表里有什么"
> "我已经推送了哪些商品到店铺？"
> "把这个商品推到我所有店铺"
> "帮我把标题和描述重写一下做 SEO 优化，然后推送"
AI 助手会自己判断调用哪个工具，你不需要知道工具名称或参数。
#### 通过 Smithery 安装
```bash
npx @smithery/cli mcp add @dsersx/product-mcp --client cursor
```
或在 [smithery.ai/server/@dsersx/product-mcp](https://smithery.ai/server/@dsersx/product-mcp) 浏览和安装。
#### 从源码安装
```bash
git clone https://github.com/lofder/dsers-mcp-product.git
cd dsers-mcp-product
npm install
npm run build
npm test
```
#### 十二个工具
| ## | 工具 | 干什么的 |
|---|------|---------|
| 1 | `dsers_store_discover` | 查看你绑定了哪些店铺、有哪些配送方式、定价规则、能用什么规则 |
| 2 | `dsers_rules_validate` | 先试试定价或标题规则对不对，不会真改东西 |
| 3 | `dsers_product_import` | 贴个商品链接，可以顺便加定价/标题规则，推送前先给你看预览 |
| 4 | `dsers_product_preview` | 看一下已经导入的商品 — 标题、价格、变体、库存一目了然 |
| 5 | `dsers_product_update_rules` | 对已导入的商品修改定价、标题、图片或变体规则（增量合并，不需要重新导入） |
| 6 | `dsers_product_visibility` | 设置商品在店铺里是上架展示还是隐藏草稿 |
| 7 | `dsers_store_push` | 把商品推到你的 Shopify 或 Wix 店铺 — 单个推、批量推、或一次推到所有店铺 |
| 8 | `dsers_job_status` | 看看推送完了没、成功了没 |
| 9 | `dsers_product_delete` | 从 DSers 导入列表中删除商品（不可恢复，需确认） |
| 10 | `dsers_import_list` | 浏览导入待推送列表，含成本价、售价、库存、加价状态 |
| 11 | `dsers_my_products` | 查看已推到店铺的商品，带供应商链接方便重新导入 |
| 12 | `dsers_find_product` | 在 DSers 商品池搜索，支持关键词和以图搜图，结果可直接导入 |
报错时会返回清晰的消息，AI 助手能看懂出了什么问题、该怎么办。
#### 推送前安全校验
推送到店铺之前，工具会自动帮你检查常见问题：
- **直接拦截**（不让推）：售价低于进货成本、零售价为 0、所有变体都没库存
- **警告提醒**（能推，但会提示你）：利润率低于 10%、库存少于 5 件、售价低于 1 美金
有问题的话，AI 助手会告诉你具体是哪个变体出了什么问题。确定没问题的话可以用 `force_push` 强制推送。
#### 定价规则冲突检测
如果你的 DSers 店铺自己启用了**定价规则**（基础/标准/高级），同时你又通过 MCP 设置了定价规则，推送会被**直接拦截**而不是仅警告。AI 助手会给出两个解决方案：
1. 在推送选项中设置 `pricing_rule_behavior='apply_store_pricing_rule'` 接受店铺端的定价规则
2. 在 DSers 店铺设置中关闭定价规则，使用 MCP 的定价
#### 四个预设提示
MCP 客户端可直接展示给用户的工作流模板：
| 提示 | 说明 |
|------|------|
| `dsers_workflow_quick-import` | 一键导入单个商品并推送为草稿 |
| `dsers_workflow_bulk-import` | 批量导入 + 统一定价倍率 |
| `dsers_workflow_multi-push` | 一个商品推送到所有店铺 |
| `dsers_workflow_seo-optimize` | 导入后 AI 重写标题和描述做 SEO 优化，再推送 |
#### 后续计划
- 商品池搜索增强（分类过滤、URL 搜索、商品详情查看）
- 支持更多 DSers 已接入的店铺平台（eBay、Wish 等）
- 更智能的定价规则模板
- 更精细的库存同步选项
有想法或需求？欢迎 [提 issue](https://github.com/lofder/dsers-mcp-product/issues) —— 非常欢迎其他开发者的建议和贡献。
#### 常见问题
**DSers MCP Product 是什么？**
一个免费开源的 MCP 服务器，让 AI Agent（如 Claude、Cursor）自动完成从速卖通/Alibaba/1688 到 Shopify/Wix 店铺的商品导入全流程。不用手动复制商品数据，用自然语言对话就能操作。
**怎么用？**
在 Cursor 或 Claude Desktop 里输入"导入这个商品，加价 2.5 倍，推送到我的店铺"，MCP 服务器自动完成抓取商品数据、应用定价规则、编辑变体、推送到店铺的全部流程。
**收费吗？**
完全免费。项目开源（MIT 协议），你只需要一个免费的 DSers 账号和已连接的 Shopify 或 Wix 店铺。
**安全吗？需要提供密码吗？**
不需要。登录采用零密码浏览器认证——你在 DSers 官网登录，工具只接收会话令牌，密码永远不会经过 MCP 服务器。项目在 [SafeSkill](https://safeskill.dev/scan/@lofder/dsers-mcp-product) 安全扫描中获得 92/100 分。
**支持哪些 AI 客户端？**
Cursor、Claude Desktop、Claude Code、Windsurf，以及任何支持 stdio 传输的 MCP 兼容客户端。
**和 AliDropify、AutoDS 等 Dropshipping 工具有什么区别？**
大多数 Dropshipping 工具有自己的界面，需要点来点去。DSers MCP Product 完全不同——它直接连接你的 AI Agent，用对话代替点击来自动化工作流。而且完全开源免费，没有订阅分级。
**能同时推送到多个店铺吗？**
可以。`dsers_store_push` 支持一条命令将商品推送到所有已连接的 Shopify 和 Wix 店铺，支持按店铺设置不同的定价和可见性。
#### 其他版本
也提供 [Python 版本](https://github.com/lofder/dsers-mcp-product-py)，适用于本地 stdio 部署。
#### 许可证
MIT
## Actor input object example
```json
{}
```
# API
You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.
## JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
// Initialize the ApifyClient with your Apify API token
// Replace the '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {};
// Run the Actor and wait for it to finish
const run = await client.actor("lofder/dropshipping-mcp-dsers").call(input);
// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.dir(item);
});
// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs
```
## Python example
```python
from apify_client import ApifyClient
# Initialize the ApifyClient with your Apify API token
# Replace '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {}
# Run the Actor and wait for it to finish
run = client.actor("lofder/dropshipping-mcp-dsers").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{}' |
apify call lofder/dropshipping-mcp-dsers --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=lofder/dropshipping-mcp-dsers",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Dropshipping Mcp Dsers",
"description": "Open-source MCP server that automates DSers dropshipping workflows with AI. Import products from AliExpress, Alibaba & Accio to Shopify and Wix stores — search suppliers, apply pricing rules, batch import, and push to multiple stores through natural language.",
"version": "0.0",
"x-build-id": "pPrwQXSvdbrUiVQIT"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/lofder~dropshipping-mcp-dsers/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-lofder-dropshipping-mcp-dsers",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/lofder~dropshipping-mcp-dsers/runs": {
"post": {
"operationId": "runs-sync-lofder-dropshipping-mcp-dsers",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/lofder~dropshipping-mcp-dsers/run-sync": {
"post": {
"operationId": "run-sync-lofder-dropshipping-mcp-dsers",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"properties": {}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```