# Etsy Winner Product Finder (`yoarksify/etsy-winner-product-finder`) Actor

Etsy market research API for finding products, keyword demand, bestseller signals, shop sales, and market opportunities using Etsy data. Supports fast search plus deeper product and shop analysis.

- **URL**: https://apify.com/yoarksify/etsy-winner-product-finder.md
- **Developed by:** [Yoarks Kaka](https://apify.com/yoarksify) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Etsy Winner Product Finder

**Etsy market research, product research, keyword research, shop analysis, and product discovery API for Etsy sellers, digital product creators, ecommerce researchers, agencies, and developers.**

Find Etsy products, search demand signals, discover related keywords, inspect seller and shop signals, analyze sold-listing activity, and research multiple niches through a single Apify Actor API.

### Why use Etsy Winner Product Finder?

Etsy research often requires more than simply collecting listing titles and prices. Product discovery can involve checking search volume proxies, comparing listings, looking at favorites and views, inspecting seller performance, expanding keywords, and researching shop sales activity.

Etsy Winner Product Finder packages those research workflows into an API that can be called directly from Apify. It supports both a **fast Etsy search lane** and **deeper research operations** for users who need additional product and shop signals.

The Actor runs in **Apify Standby mode**, so you can call its HTTP endpoints directly from applications, automations, backend systems, integrations, scripts, or the Apify interface.

### Main features

#### 🔎 Etsy keyword search

Search Etsy by keyword and retrieve a market snapshot including:

- Total matching listing count
- Listing IDs
- Listing titles
- Prices
- Views
- Favorites
- Listing URLs
- Shop names
- Shop sales signals
- Shop age
- Shop reviews
- Shop ratings

The `/search` endpoint uses the official Etsy v3 search lane in the underlying service and is designed for quick demand checks.

#### 🔑 Etsy keyword research

Expand a niche using Etsy autocomplete and related-search terms.

This is useful for discovering:

- Long-tail Etsy keywords
- Buyer-language variations
- Related niche terms
- Search phrase ideas
- Product naming ideas
- Additional research seeds

The `/keywords` endpoint returns `autocomplete` and `related` terms from the underlying Etsy research service.

#### 📦 Etsy product research

Research products for a specific niche and retrieve a structured product grid.

Depending on the request, product data can include:

- Product/listing ID
- Product title
- Price
- Product URL
- Shop information
- Bestseller signal
- Star Seller signal
- Advertising signal
- Seller score
- Reviews and rating when deep enrichment is available

The `/products` endpoint supports `limit`, `deep`, and `deep_n` controls. Deep enrichment can attach additional reviews, sales, purchased-in-24-hours, and bestseller information.

#### 🏆 Multi-niche winner research

The `/winners` endpoint is designed for comparing multiple research seeds in one request.

Provide several Etsy niches or product ideas and the service can:

1. Search the supplied seeds.
2. Build a shortlist.
3. Run deeper enrichment on selected products.
4. Return a combined winners dataset.

The underlying documented scoring model is based on reviews and favorites when those fields are available. The current service documentation also notes that the deep pass may not capture favorites consistently, so the effective ranking can fall back toward reviews-weighted results.

#### 🏪 Etsy shop sales research

The `/shop-sales` endpoint is designed for shop-level research.

It crawls a shop's sold-listing pages and tallies listing occurrences, while also returning the shop's total-sales figure when available through the underlying research process.

This can be useful for:

- Competitor research
- Shop discovery
- Product opportunity research
- Identifying products that appear repeatedly in sold listings
- Comparing activity across Etsy shops

The underlying API documentation describes this sold-page occurrence tally as the service's distinctive shop-sales capability.

#### ❤️ Favorites, views, reviews, ratings and seller signals

Depending on the endpoint and enrichment mode, the Actor can expose signals such as:

- Favorites
- Views
- Reviews
- Star ratings
- Bestseller status
- Star Seller status
- Seller score
- Shop sales
- Shop review count
- Shop age

These signals are intended for research and comparison workflows rather than guaranteeing future product performance.

#### ⚡ Fast search and deeper research in one Actor

The Actor combines a fast search workflow with heavier research workflows.

Use `/search` when you need a quick market check. Use `/keywords`, `/products`, `/winners`, and `/shop-sales` when your workflow needs more detailed Etsy research. The underlying service documents the scrape-lane operations as slower and serialized, with heavy requests potentially requiring long client timeouts.

***

## What can you use it for?

### 🛍️ Etsy product research

Search a niche and inspect products, shops, prices, demand proxies, and seller signals before deciding what to investigate further.

Example niches:

- Crochet patterns
- Digital planners
- Printable wall art
- Wedding templates
- SVG bundles
- Sewing patterns
- Jewelry designs
- Craft templates
- Party invitations
- Digital downloads

### 📈 Etsy niche research

Use search totals, listing data, keyword suggestions, and product signals to explore a market before creating a new product.

A simple workflow can be:

**Niche idea → keyword expansion → Etsy search → product research → shop analysis → deeper research**

### 🔍 Etsy SEO keyword research

Use Etsy autocomplete and related search terms to discover how shoppers phrase searches.

You can use the resulting keywords for:

- Etsy listing titles
- Tags
- Product naming
- Niche expansion
- Content ideas
- Research databases
- Product ideation

### 🧠 Product opportunity discovery

Research several product niches in one workflow and return a consolidated dataset for further analysis.

For example:

```text
crochet bag pattern
crochet sweater pattern
granny square pattern
amigurumi pattern
```

The `/winners` endpoint is built specifically for this multi-seed research workflow.

### 🏪 Etsy competitor research

Research a shop's products and sales-related signals to better understand its catalog and visible market activity.

The shop-sales endpoint is especially useful when you want to investigate how frequently specific listings appear on sold pages.

### 🤖 Automation and AI workflows

Because the Actor exposes HTTP endpoints in Apify Standby mode, it can be used as a component inside larger workflows.

Examples include:

- AI product research agents
- Ecommerce dashboards
- Automated niche research
- Internal research tools
- Scheduled market monitoring
- Product databases
- Lead and competitor research systems
- Custom SaaS applications
- Python scripts
- JavaScript/Node.js applications
- No-code and low-code workflows

***

## Available API endpoints

The Actor exposes six endpoints through its Apify Standby API.

| Endpoint | Method | Purpose |
|---|---|---|
| `/search` | GET | Fast Etsy keyword search and market snapshot |
| `/keywords` | POST | Etsy autocomplete and related keyword research |
| `/products` | POST | Product research with optional deep enrichment |
| `/winners` | POST | Multi-niche research and combined winners board |
| `/shop-sales` | POST | Shop sold-listing and sales research |
| `/health` | GET | Service health check |

***

## 1. Etsy Search API

### `GET /search`

Search Etsy by keyword.

#### Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `q` | string | Yes | Etsy search keyword |
| `limit` | integer | No | Number of listings to return |

#### Example

```http
GET /search?q=crochet%20pattern&limit=25
```

#### Example use case

Search for a niche such as:

```text
crochet pattern
```

and use the returned total listing count and listing-level signals as a market research snapshot.

The underlying service documents `data.total` as the number of live listings matching the search and returns fields such as title, listing ID, URL, price, favorites, views, and shop.

#### Example response

```json
{
  "ok": true,
  "mode": "search",
  "data": {
    "total": 955433,
    "results": [
      {
        "listing_id": 4303683762,
        "title": "Example Etsy Listing",
        "views": 9108,
        "favorites": 613,
        "price": 10,
        "url": "https://www.etsy.com/listing/4303683762/example",
        "shop_name": "ExampleShop",
        "shop_sales": 113482,
        "shop_age_years": 3.9,
        "shop_reviews": 10180,
        "shop_rating": 4.85
      }
    ]
  },
  "elapsed_s": 6.3
}
```

***

## 2. Etsy Keyword Research API

### `POST /keywords`

Find keyword variations using Etsy autocomplete and related search terms.

#### Request

```json
{
  "niche": "crochet pattern"
}
```

#### Response structure

The service returns keyword collections under fields such as:

```json
{
  "ok": true,
  "mode": "keywords",
  "data": {
    "autocomplete": [],
    "related": []
  }
}
```

The exact result set depends on the niche and the Etsy research pass at request time.

#### Use keyword research to discover

- Long-tail keywords
- Related product ideas
- New niche seeds
- Buyer terminology
- Listing title variations
- Search expansion opportunities

***

## 3. Etsy Product Research API

### `POST /products`

Retrieve a product grid for a niche with optional deep research.

#### Request

```json
{
  "niche": "crochet bag pattern",
  "limit": 40,
  "deep": false,
  "deep_n": 8
}
```

#### Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `niche` | string | Yes | Research niche or product keyword |
| `limit` | integer | No | Product grid size |
| `deep` | boolean | No | Enable deeper product enrichment |
| `deep_n` | integer | No | Number of products to deeply enrich |

#### Basic mode

Use:

```json
{
  "niche": "crochet bag pattern",
  "limit": 20,
  "deep": false
}
```

This is useful for fast product discovery and initial research.

#### Deep mode

Use:

```json
{
  "niche": "crochet bag pattern",
  "limit": 40,
  "deep": true,
  "deep_n": 10
}
```

Deep mode is intended for cases where you need more detailed product-level enrichment. It is slower than basic product research.

#### Example response

```json
{
  "ok": true,
  "mode": "products",
  "data": {
    "products": [
      {
        "id": "1833521002",
        "title": "Example crochet bag pattern",
        "price": "$13.10",
        "reviews": null,
        "rating": null,
        "shop": "ExampleShop",
        "bestseller": true,
        "star_seller": false,
        "ad": false,
        "url": "https://www.etsy.com/listing/1833521002/example",
        "seller_score": 2
      }
    ],
    "grid": [],
    "deep": []
  }
}
```

Some fields may be `null` in non-deep mode because deeper enrichment has not been requested or captured.

***

## 4. Etsy Winner Research API

### `POST /winners`

Research multiple Etsy niches in one request and return a combined winners board.

#### Request

```json
{
  "seeds": [
    "granny square crochet pattern",
    "crochet bag pattern",
    "amigurumi pattern"
  ],
  "deep_n": 8
}
```

#### Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `seeds` | array of strings | Yes | Etsy niches or search seeds |
| `deep_n` | integer | No | Number of products to deeply enrich for each research seed |

#### How it works

The documented workflow is:

**multiple seeds → demand shortlist → deep enrichment → combined winners board**.

#### Important ranking note

The underlying service documentation describes a ranking approach using reviews and favorites. It also notes that the current deep pass may not capture favorites consistently, so the output can degrade toward reviews-weighted ranking until favorites are available in the deep data.

Treat the returned ranking as a **research signal**, not a guarantee of future sales or profitability.

#### Performance

This is one of the heavier operations. The underlying API documentation estimates approximately 90 seconds per seed before additional deep-enrichment time, so large multi-seed requests should use a long client timeout.

***

## 5. Etsy Shop Sales API

### `POST /shop-sales`

Research visible sold-listing activity for a specific Etsy shop.

#### Request

```json
{
  "shop": "SomeCrochetShop",
  "limit": 200
}
```

#### Parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `shop` | string | Yes | Etsy shop name |
| `limit` | integer | No | Maximum number of sold items to crawl |

#### What it returns

The underlying service can return:

- Shop total sales
- Per-listing sale counts based on sold-page occurrences
- Product/listing identifiers
- Additional shop-level research information when available

The documentation describes Etsy lifetime per-product sales as hidden on normal listing pages and identifies `/shop-sales` as the service's sold-page occurrence-tally workflow.

#### Example

```json
{
  "ok": true,
  "mode": "shop-sales",
  "data": {
    "shop": "SomeCrochetShop",
    "total_sales": 12345,
    "products": []
  }
}
```

The exact response fields depend on the available sold-page research data at request time.

***

## 6. Health Check

### `GET /health`

Use this endpoint to verify that the underlying Etsy research service is reachable and authenticated.

#### Example

```http
GET /health
```

#### Example response

```json
{
  "ok": true,
  "service": "swissbox-etsy",
  "auth": true
}
```

***

## Recommended workflows

### Workflow 1: Find a niche to research

Start with `/search`.

```text
Search keyword
↓
Review total results
↓
Inspect listing signals
↓
Select promising niches
```

### Workflow 2: Expand Etsy keywords

Start with `/keywords`.

```text
Seed niche
↓
Autocomplete terms
↓
Related terms
↓
Create a larger keyword list
↓
Search each keyword
```

### Workflow 3: Research products

Use `/products`.

```text
Niche
↓
Product grid
↓
Seller/shop signals
↓
Optional deep enrichment
```

### Workflow 4: Compare multiple niches

Use `/winners`.

```text
Niche A
Niche B
Niche C
Niche D
↓
Combined research
↓
Enrichment
↓
Winners dataset
```

### Workflow 5: Research a competitor shop

Use `/shop-sales` together with `/products` or `/search`.

```text
Shop name
↓
Sold-page research
↓
Per-product occurrence counts
↓
Compare with visible listing signals
```

***

## API usage from your applications

Because the Actor runs in Apify Standby mode, you can call its endpoint directly over HTTP.

The Apify-generated Standby URL is shown in the Actor's **Endpoints** tab. Apify's Standby interface can render the attached OpenAPI specification and provides interactive requests directly from the browser.

#### Example cURL

```bash
curl -X GET \
  'https://YOUR-ACTOR.apify.actor/search?q=crochet%20pattern&limit=10' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN'
```

#### Example JavaScript

```javascript
const response = await fetch(
  'https://YOUR-ACTOR.apify.actor/search?q=crochet%20pattern&limit=10',
  {
    headers: {
      Authorization: `Bearer ${process.env.APIFY_API_TOKEN}`,
    },
  }
);

const data = await response.json();
console.log(data);
```

#### Example Python

```python
import requests

url = "https://YOUR-ACTOR.apify.actor/search"
headers = {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
}
params = {
    "q": "crochet pattern",
    "limit": 10
}

response = requests.get(url, headers=headers, params=params, timeout=60)
response.raise_for_status()

print(response.json())
```

***

## Apify integration

This Actor is designed to fit naturally into the Apify ecosystem.

You can use it from:

- Apify Console
- Apify Actor API
- Apify Standby endpoints
- JavaScript/Node.js applications
- Python applications
- Backend services
- Automation workflows
- Custom integrations
- AI agents that can call HTTP tools

The Actor's OpenAPI schema is attached to the Standby service so the Apify interface can show the available routes and request fields.

***

## Input examples

### Simple Etsy search

```json
{
  "q": "digital planner",
  "limit": 25
}
```

### Keyword expansion

```json
{
  "niche": "digital planner"
}
```

### Product research

```json
{
  "niche": "wedding invitation template",
  "limit": 40,
  "deep": false,
  "deep_n": 8
}
```

### Deep product research

```json
{
  "niche": "printable wall art",
  "limit": 40,
  "deep": true,
  "deep_n": 10
}
```

### Multi-niche research

```json
{
  "seeds": [
    "digital planner",
    "wedding template",
    "budget spreadsheet",
    "printable wall art"
  ],
  "deep_n": 8
}
```

### Shop research

```json
{
  "shop": "ExampleShop",
  "limit": 200
}
```

***

## Data fields and research signals

The available data varies by endpoint and research mode.

Common fields can include:

| Field | Meaning |
|---|---|
| `listing_id` / `id` | Etsy listing identifier |
| `title` | Listing title |
| `url` | Etsy listing URL |
| `price` | Visible listing price |
| `views` | Visible view signal when available |
| `favorites` | Visible favorite signal when available |
| `reviews` | Product review count when available |
| `rating` | Product rating when available |
| `shop_name` / `shop` | Seller/shop name |
| `shop_sales` | Shop sales signal when available |
| `shop_age_years` | Approximate shop age when available |
| `shop_reviews` | Shop review count when available |
| `shop_rating` | Shop rating when available |
| `bestseller` | Bestseller signal |
| `star_seller` | Star Seller signal |
| `ad` | Advertising signal |
| `seller_score` | Seller signal generated by the research service |

Not every field is returned by every endpoint, and some fields can be `null` or unavailable depending on the research lane and current Etsy page data.

***

## Performance and timeouts

The Actor supports both fast and heavy research requests, so execution time varies considerably by endpoint.

#### Fast lane

`/search` is the fast official Etsy v3 search lane and is intended for quick market checks.

#### Scrape lane

`/keywords`, `/products`, `/winners`, and `/shop-sales` use the underlying signed-in research browser and are much heavier than `/search`.

The service documentation notes that scrape-lane requests are serialized and can take roughly 90 seconds per seed, with `/winners` scaling with the number of seeds and deep enrichment.

#### Practical guidance

For long-running requests:

- Use a generous client timeout.
- Avoid sending many heavy requests simultaneously.
- Start with a small `limit` or `deep_n` when exploring a new niche.
- Use `/search` before launching deeper research.
- Batch only as much work as your workflow can reasonably handle.

The underlying service specifically warns that parallel scrape-lane calls queue behind the serialized research lane.

***

## Data quality and limitations

Etsy market data changes continuously. Search positions, listing counts, views, favorites, reviews, seller signals, and shop activity can change between requests.

Important limitations documented by the underlying service include:

- The official Etsy search lane is quota-bound and can return HTTP `429` on quota exhaustion.
- The scrape-lane operations rely on a persistent signed-in browser profile.
- The underlying research browser needs its server-side display environment available.
- Scrape-lane requests are serialized.
- Deep enrichment is slower than basic product research.
- Favorites may not always be captured during the current deep product pass.
- Per-product lifetime sales are not directly exposed on ordinary Etsy listing pages; the shop-sales workflow relies on sold-page occurrence tallying.

These limitations are part of the underlying research service and are important when interpreting results.

***

## Important: research signals are not guarantees

This Actor is a **research and data analysis tool**.

Metrics such as:

- views
- favorites
- reviews
- ratings
- bestseller badges
- shop sales
- seller signals
- search result counts

can help you investigate an Etsy market, but they do not guarantee future demand, revenue, ranking position, profitability, or sales performance.

Use multiple signals together and verify important decisions with your own research.

***

## Frequently asked questions

### Is this an Etsy scraper?

It is an Etsy market research Actor that combines fast Etsy search with deeper research workflows for products, keywords, shops, and multi-niche analysis.

### Can I search Etsy by keyword?

Yes. Use `GET /search` with a `q` parameter.

### Can I find Etsy keywords?

Yes. Use `POST /keywords` to retrieve autocomplete and related search terms.

### Can I research Etsy products?

Yes. Use `POST /products` and enable deep enrichment when you need additional product signals.

### Can I research multiple niches at once?

Yes. Use `POST /winners` with an array of `seeds`.

### Can I research Etsy shop sales?

Yes. Use `POST /shop-sales` with the shop name.

### Does the Actor return reviews and ratings?

They can be returned when available through the relevant product research/enrichment path. Basic product mode may leave them unavailable or `null` until deep research is performed.

### Is the API fast?

`/search` is designed as the fast research route. Deep research routes are significantly slower and should be called with appropriate timeouts.

### Can I use this from Python or JavaScript?

Yes. The Actor is exposed over HTTP through Apify Standby mode, so any HTTP-capable application can call it.

### Can an AI agent use this Actor?

Yes. The HTTP endpoints and OpenAPI description make the Actor suitable for AI systems and tool-calling workflows that can make authenticated HTTP requests.

### Does it use an Etsy API?

The underlying service combines the official Etsy v3 API for its fast search lane with a separate signed-in browser research lane for deeper operations.

### Can I run large research jobs?

Yes, but heavy endpoints should be used carefully because the underlying scrape lane is serialized and can take significant time. Start small, verify the output, and scale your research workflow deliberately.

***

## Best practices

#### Start with `/search`

Use the fast route to validate a niche before spending time on heavier research.

#### Expand with `/keywords`

Build a broader keyword set before deciding which niches deserve deeper investigation.

#### Keep deep research targeted

Use `deep_n` for a focused subset rather than deeply enriching every listing.

#### Use multiple signals

Don't rely on a single metric. Look at the available combination of search totals, views, favorites, reviews, ratings, bestseller signals, shop activity, and other returned fields.

#### Respect execution time

Heavy requests can take substantially longer than simple searches.

***

## Example research workflow

A practical automated research pipeline can look like this:

```text
1. Start with a niche idea
        ↓
2. /keywords
        ↓
3. Expand into Etsy search terms
        ↓
4. /search for each keyword
        ↓
5. Select interesting niches
        ↓
6. /products for product-level research
        ↓
7. Enable deep enrichment for shortlisted products
        ↓
8. /shop-sales for competitor shops
        ↓
9. /winners for multi-niche comparison
        ↓
10. Store the results in your own database/dashboard
```

This workflow helps separate **fast discovery** from **expensive deep research** and matches the different capabilities exposed by the underlying API.

***

## Example output envelope

Successful responses from the underlying API use an envelope similar to:

```json
{
  "ok": true,
  "mode": "search",
  "data": {},
  "elapsed_s": 1.2
}
```

Errors can return:

```json
{
  "ok": false,
  "error": "..."
}
```

Authentication failures return an unauthorized response.

***

## Who is this Actor for?

Etsy Winner Product Finder is useful for:

- Etsy sellers
- Etsy shop owners
- Digital product sellers
- Printables sellers
- Handmade product businesses
- Etsy SEO researchers
- Ecommerce agencies
- Product researchers
- Market researchers
- Competitive intelligence workflows
- Ecommerce developers
- SaaS builders
- Automation builders
- AI agent developers

***

## SEO and product research use cases

Search terms and research topics this Actor is designed to support include:

**Etsy keyword research, Etsy product research, Etsy market research, Etsy competitor research, Etsy niche research, Etsy SEO research, Etsy product finder, Etsy winner finder, Etsy bestseller research, Etsy shop research, Etsy shop sales research, Etsy listing research, Etsy search API, Etsy data API, Etsy research API, Etsy keyword API, Etsy product API, Etsy seller research, Etsy ecommerce research, Etsy digital product research, Etsy printable research, Etsy craft research, Etsy marketplace analysis, Etsy trend research, Etsy product discovery, Etsy listing data, Etsy shop analysis, Etsy sales research, ecommerce product research, niche product research, market opportunity research, Etsy API for developers, Etsy automation, Etsy data extraction, Etsy research automation.**

***

## Privacy and credential handling

The underlying Etsy credentials are kept server-side and are not intended to be exposed to Actor users.

When using this Actor through Apify, users authenticate to the Actor using the Apify-generated endpoint and their Apify credentials. The backend Etsy credential remains separate from the user request.

***

## Support and feedback

For issues with the Actor, include:

- Endpoint used
- Input parameters
- Approximate time of the request
- Returned HTTP status
- Error message, if any

Do not include private credentials or API tokens in support requests.

***

## Summary

**Etsy Winner Product Finder** gives developers and Etsy researchers a unified API for:

✅ Etsy keyword search\
✅ Etsy keyword expansion\
✅ Etsy product discovery\
✅ Product signal research\
✅ Multi-niche winner research\
✅ Etsy shop sales research\
✅ Seller and shop signals\
✅ Fast search plus deep research workflows\
✅ Apify Standby HTTP API access\
✅ Automation and AI-agent integration

Start with **`/search`** for fast market discovery, use **`/keywords`** to expand your research, move to **`/products`** for product analysis, use **`/shop-sales`** for shop research, and use **`/winners`** when you need a combined multi-niche research workflow.

***

### Apify

This Actor runs in **Apify Standby mode** and exposes its HTTP endpoints through the Apify platform. The Actor includes an OpenAPI specification so the available routes can be explored and called directly from the Apify interface.

### Underlying service

The underlying Etsy research service provides a secured HTTP API with a server-side credential, a fast official Etsy v3 search lane, and deeper signed-in browser research operations.

# Actor input Schema

## `operation` (type: `string`):

Choose the type of Etsy research.

## `query` (type: `string`):

Keyword to search on Etsy.

## `niche` (type: `string`):

Etsy niche or product keyword to research.

## `seeds` (type: `array`):

Multiple niche keywords for winner research.

## `shop` (type: `string`):

Etsy shop name to analyze.

## `limit` (type: `integer`):

Maximum number of results to retrieve.

## `deep` (type: `boolean`):

Enable deeper product enrichment. This is slower.

## `deep_n` (type: `integer`):

Number of products to enrich when deep analysis is enabled.

## Actor input object example

```json
{
  "operation": "search",
  "query": "crochet pattern",
  "niche": "crochet bag pattern",
  "seeds": [
    "granny square crochet pattern",
    "crochet bag pattern",
    "amigurumi pattern"
  ],
  "shop": "",
  "limit": 25,
  "deep": false,
  "deep_n": 8
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("yoarksify/etsy-winner-product-finder").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("yoarksify/etsy-winner-product-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 yoarksify/etsy-winner-product-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yoarksify/etsy-winner-product-finder"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DpeMoDR8Jr40zfKSF/builds/amF1SVXrMdIJ6FTS6/openapi.json