# Etsy Digital Product Research & Niche Finder (`herazur/etsy-product-research-niche-finder`) Actor

Find profitable digital product niches using live Etsy market data and Pinterest trend signals. Compare demand, competition, pricing, freshness, and trend momentum to identify promising product opportunities.

- **URL**: https://apify.com/herazur/etsy-product-research-niche-finder.md
- **Developed by:** [Furkan Toluç](https://apify.com/herazur) (community)
- **Categories:** E-commerce, For creators, Marketing
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 etsy keyword analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Digital Product Research & Niche Finder

Find evidence-backed digital product opportunities using live Etsy market signals and Pinterest trend validation.

This Apify Actor is a focused product opportunity finder for creators deciding which digital-product niche to test next. It is not a generic scraper or an AI idea generator. It turns normalized marketplace evidence into transparent rankings, confidence scores, and `TEST` / `WATCH` / `SKIP` decisions.

### 1. What this Actor does

Give the Actor up to five seed niches, such as `ADHD planner`. It discovers related Etsy keyword opportunities, shortlists candidates using Etsy commercial evidence, validates those candidates against Pinterest trends, and returns one Dataset row per ranked opportunity.

Example result:

```text
ADHD Morning Routine Cards

Opportunity: 82/100
Confidence: 89/100
Decision: TEST

Why:
- strong Etsy demand
- manageable entry headroom
- positive Pinterest validation
```

Numbers above are illustrative. Production scores are calculated only from normalized upstream evidence; missing values remain `null`.

Use it for Etsy product research, Etsy keyword research, printable product research, Etsy niche research, market validation, and prioritizing digital downloads. It can surface stronger and weaker candidates related to a seed; it does not promise “low competition Etsy niches” or guaranteed sales.

### 2. Who it is for

- Etsy digital-product and printable sellers
- Designers researching editable templates, planners, worksheets, trackers, and bundles
- Product researchers comparing digital product ideas with current evidence
- Agencies or automation builders that need structured niche-research output through the Apify API

### 3. How it works

```text
Seed niche
  → Etsy keyword discovery
  → Etsy adapter and normalization
  → evidence-based candidate shortlist
  → Pinterest trend validation
  → Pinterest adapter and normalization
  → transparent opportunity + confidence scoring
  → ranked Dataset rows and full reports
```

Etsy is the primary commercial evidence source. Pinterest trends are secondary validation and cannot overpower Etsy in the score.

The default upstream Actors are configurable without changing business logic:

- Etsy: `yumitori/etsy-keyword-tool`
- Pinterest: `yumitori/pinterest-trends-scraper` in keyword-research mode

### 4. Input

```json
{
  "seeds": [
    "ADHD planner",
    "kids screen free activities"
  ],
  "country": "US",
  "maxOpportunities": 10,
  "candidateLimitPerSeed": 20,
  "etsyExpansionDepth": 1,
  "debug": false
}
```

| Field | Required | Default | Limits |
|---|---:|---:|---|
| `seeds` | Yes | — | 1–5 strings, each 2–80 characters |
| `country` | No | `US` | `US`, `GB`, `CA`, `DE`, `FR`, `IT`, `ES`, `BR`, `MX`, `AR`, `IN` |
| `maxOpportunities` | No | `10` | 1–20 |
| `candidateLimitPerSeed` | No | `20` | 1–40 |
| `etsyExpansionDepth` | No | `1` | 1 or 2 |
| `debug` | No | `false` | Includes safe normalization/scoring metadata; never secrets |

### 5. Output

The default Dataset receives one item per opportunity. Each record contains:

- the original seed, final rank, normalized keyword, suggested product, and conservative product format
- Opportunity Score, Confidence Score, and decision
- all normalized score components
- Etsy sample size, listings, average price, carts, recent-sales/listing shares, discount density, and digital-product share
- qualified Pinterest term, match quality, search volumes, multi-week momentum windows, trend evidence, and `FULL` / `PARTIAL` / `NONE` evidence quality
- available Etsy and Pinterest evidence; missing or low-quality evidence is `null`
- deterministic reasons and signal-supported risks
- real source URLs when upstream data supplies them

The default Key-Value Store also contains:

- `OUTPUT.json`: the full machine-readable report
- `REPORT.md`: a concise human-readable report

### 6. Opportunity Score

The 0–100 Opportunity Score uses these components:

| Component | Weight |
|---|---:|
| Etsy demand | 30% |
| Entry headroom (`100 - competition`) | 25% |
| Digital fit (`digital_pct`) | 15% |
| Pinterest validation | 15% |
| Margin potential | 10% |
| Freshness (`recent_listings_pct`) | 5% |

Missing components are ignored and available weights are re-normalized. Missing Pinterest data is not converted to zero. A normal score requires Etsy demand plus additional Etsy evidence; otherwise the result is `INSUFFICIENT_EVIDENCE`.

### 7. Confidence Score

Confidence is separate from opportunity quality. A promising niche can have a high Opportunity Score and low Confidence Score when evidence coverage is thin.

| Confidence component | Weight |
|---|---:|
| Etsy core-evidence completeness | 60% |
| Etsy sample credibility | 25% |
| Qualified cross-market confirmation | 15% |

Rich Etsy evidence can establish meaningful baseline confidence on its own. A qualified Pinterest match increases confidence; Pinterest remains optional and does not automatically lower the Etsy-based Opportunity Score when unavailable.

Pinterest evidence is `FULL` when a qualified match includes enough weekly history for stable multi-week comparison, `PARTIAL` when a qualified match has current-interest/trend evidence but no usable history, and `NONE` when no sufficiently related validation is available. Partial validation is deliberately discounted. Separately, `matchType` reports semantic specificity as `EXACT`, `CLOSE`, `BROAD`, or `NONE`; broad matches retain their raw trend evidence but receive a capped validation contribution because an important niche token was dropped.

### 8. TEST / WATCH / SKIP

- `TEST`: Opportunity ≥ 75 and Confidence ≥ 60
- `WATCH`: Opportunity ≥ 60 but the `TEST` rule is not met
- `SKIP`: Opportunity < 60
- `INSUFFICIENT_EVIDENCE`: minimum Etsy evidence is unavailable

These decisions prioritize small, inexpensive product tests. They are not predictions or guarantees.

### 9. Example output

```json
{
  "recordType": "opportunity",
  "seed": "ADHD planner",
  "rank": 1,
  "keyword": "adhd morning routine cards",
  "suggestedProduct": "ADHD Morning Routine Cards",
  "suggestedFormat": "Printable cards",
  "opportunityScore": 82,
  "confidenceScore": 87,
  "decision": "TEST",
  "scores": {
    "etsyDemand": 88,
    "entryHeadroom": 72,
    "digitalFit": 100,
    "pinterestValidation": 81,
    "marginPotential": 70,
    "freshness": 78
  }
}
```

This example is illustrative, not hardcoded production data.

### 10. Data sources

The Actor orchestrates existing Apify Store Actors rather than maintaining its own Etsy or Pinterest crawlers. Adapters isolate upstream schemas from the scoring engine. Override providers with `ETSY_ACTOR_ID` and `PINTEREST_ACTOR_ID` when a compatible adapter mapping is available.

Cost protection defaults to `$1.00` total across Etsy seed calls and `$0.25` for the Pinterest call. Configure:

```text
ETSY_MAX_TOTAL_CHARGE_USD=1.00
PINTEREST_MAX_TOTAL_CHARGE_USD=0.25
ETSY_TIMEOUT_SECONDS=300
PINTEREST_TIMEOUT_SECONDS=300
```

The SDK passes these limits to child Actor runs. Etsy's configured budget is divided across the 1–5 seed calls so the run-level cap remains conservative.

### 11. Limitations

- Scores are research signals, not revenue guarantees.
- Etsy is the primary commercial evidence source.
- Pinterest is used as secondary trend validation.
- Pinterest attention does not necessarily equal purchasing demand.
- Missing Pinterest data is not treated as zero demand.
- Marketplace conditions change over time.
- Upstream Actor schemas and field coverage can change; unknown fields are not guessed.
- Results should prioritize small product tests, not justify large upfront investment.
- Upstream Actors can have their own pricing, availability, geographic coverage, and usage limits.

### 12. API / automation usage

Run locally after providing Apify credentials:

```bash
npm install
npm run build
apify run
```

Deploy from this directory:

```bash
npm install -g apify-cli
apify login
apify validate-schema
apify push
```

Use the Apify API after deployment:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/herazur~etsy-product-research-niche-finder/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"seeds":["meal planner"],"country":"US","maxOpportunities":3,"candidateLimitPerSeed":5,"etsyExpansionDepth":1}'
```

#### Development and verification

Tests use sanitized fixtures and never call paid Actors:

```bash
npm run typecheck
npm test
npm run build
```

The SDK checks the effective pricing model at runtime. Local and non-Pay-Per-Event runs are
not charged. Use `ACTOR_TEST_PAY_PER_EVENT=true` only when testing the charging flow locally;
local test events use Apify's simulated event price rather than the Store price.

### 13. Pricing

The Store Actor uses Pay-Per-Event pricing, so you pay only for the Etsy listings that are actually analyzed:

- Etsy listing analyzed (`listing-analyzed`): **$0.002** per unique Etsy listing on the Apify Free plan ($2 per 1,000), with lower prices on paid Apify plans
- Actor Start: $0.00005
- Platform usage: included

An analyzed listing is one unique Etsy keyword market (its search listings, sampled for demand, competition, price, and freshness) that is scored in the run. Each unique keyword is charged once per run, even when several seeds surface it. Nothing is charged when a run fails before results are produced.

The Dataset returns the top `maxOpportunities` ranked results, so a run usually analyzes more listings than it returns. Lower `candidateLimitPerSeed` to analyze fewer listings. With the two prefilled seeds and the default limits, a run analyzes at most 40 listings (at most $0.08 on the Free plan).

Upstream Etsy and Pinterest data costs are billed separately by the source Actors. The Actor respects your maximum cost per run: it analyzes only as many listings as the limit allows and stops when the limit is reached.

# Actor input Schema

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

Enter 1–5 product niches to investigate.

## `country` (type: `string`):

Market used for Pinterest trend validation.

## `maxOpportunities` (type: `integer`):

Maximum ranked opportunities returned across all seeds.

## `candidateLimitPerSeed` (type: `integer`):

Maximum Etsy candidates shortlisted per seed before Pinterest validation.

## `etsyExpansionDepth` (type: `integer`):

Keyword expansion depth. Depth 2 costs more and can take longer.

## `debug` (type: `boolean`):

Include safe adapter and scoring diagnostics. Secrets are never included.

## Actor input object example

```json
{
  "seeds": [
    "ADHD planner",
    "kids screen free activities"
  ],
  "country": "US",
  "maxOpportunities": 10,
  "candidateLimitPerSeed": 20,
  "etsyExpansionDepth": 1,
  "debug": false
}
```

# Actor output Schema

## `opportunities` (type: `string`):

Ranked digital product opportunities with scores, evidence, risks, and TEST / WATCH / SKIP decisions.

## `jsonReport` (type: `string`):

Complete structured opportunity report.

## `markdownReport` (type: `string`):

Human-readable opportunity report.

# 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 = {
    "seeds": [
        "ADHD planner",
        "kids screen free activities"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("herazur/etsy-product-research-niche-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 = { "seeds": [
        "ADHD planner",
        "kids screen free activities",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("herazur/etsy-product-research-niche-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 '{
  "seeds": [
    "ADHD planner",
    "kids screen free activities"
  ]
}' |
apify call herazur/etsy-product-research-niche-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,herazur/etsy-product-research-niche-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/CSqmDlFQZim7ejJ5Q/builds/9b9ggfhvEkQcIacpn/openapi.json