# KDP Niche Finder — Amazon Book Opportunity Scores (`datascoutlab/kdp-niche-analyzer`) Actor

Find low-competition Amazon KDP book niches. Enter keywords, get each scored 0–100 by competition (review counts), price and rating — with a clear opportunity/saturated verdict and the top books as evidence. No API key.

- **URL**: https://apify.com/datascoutlab/kdp-niche-analyzer.md
- **Developed by:** [Anton DataScout](https://apify.com/datascoutlab) (community)
- **Categories:** E-commerce, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## KDP Niche Finder — Amazon Book Opportunity Scores

Find **low-competition Amazon KDP book niches** before your competitors do. Enter keywords and get each one scored 0–100 by real competition, price and rating — with a clear opportunity/saturated verdict and the top books as evidence. **No API key, no login.**

This is a *decision*, not a data dump: instead of eyeballing Amazon search pages, you get a ranked verdict per niche — is `nurse planner` an open opportunity or is `gratitude journal` already saturated? The score is driven by the one number that actually matters for a self-publisher: **how many reviews the top books already have.**

| You give it | You get back |
| --- | --- |
| Niche keywords (`dog mom notebook`, `nurse planner`) | A 0–100 opportunity score + verdict per niche |
| An Amazon marketplace (US, UK, DE…) | Competition analyzed in that store, prices in its currency |
| — | Median review count, avg price, avg rating, and the top books as evidence |

### What does the KDP Niche Finder do?

For each keyword you give it, the Actor searches Amazon's book category, reads the top organic results (skipping sponsored listings), and scores the niche on the signals that decide whether a self-published book can rank:

- **Competition** — the review counts of the books already ranking. Few reviews = a niche newcomers can break into.
- **Price** — whether books in the niche sell in a healthy KDP range.
- **Rating** — how strong the incumbents are.

It returns one row per niche with an `opportunityScore` (0–100), a plain-English verdict (🟢 opportunity / 🟡 medium / 🔴 saturated), the median and average review counts, average price and rating, and the top-scored books as evidence. No Amazon account, no API key.

### Who is it for?

| Audience | What they pull |
| --- | --- |
| **KDP self-publishers** | Which low-content/book niches are still open to a newcomer |
| **Print-on-demand creators** | Trending notebook / planner / journal topics with room to rank |
| **Low-content book publishers** | A fast pass/fail on a list of niche ideas before designing anything |
| **Amazon sellers & researchers** | Competition and price benchmarks across a category |

### Why use this tool?

- **Scores what matters — real review counts.** Competition is measured from the incumbents' review counts, the single best proxy for how hard a niche is to enter.
- **Verdict, not a spreadsheet.** Each niche comes back as 🟢/🟡/🔴 with a 0–100 score — decide in seconds.
- **Reliable parsing.** Amazon serves inconsistent page variants; this Actor retries through rotating sessions until it gets a clean, parseable result — so scores aren't skewed by half-loaded pages.
- **Correct prices.** Marketplace-matched proxies return prices in the store's real currency, not whatever your location defaults to.
- **No API key, no login.** Works out of the box.

### What data do you get?

One row per niche:

```json
{
    "type": "niche",
    "keyword": "nurse planner",
    "marketplace": "us",
    "opportunityScore": 86,
    "competitionLevel": "low",
    "verdict": "🟢 OPPORTUNITY — low competition",
    "booksAnalyzed": 16,
    "medianReviewCount": 5,
    "avgReviewCount": 14,
    "lowCompetitionShare": 0.75,
    "avgPrice": 10.81,
    "avgRating": 4.4,
    "topBooks": [
        { "title": "2026 Monthly Planner for Nurses", "price": 10.99, "rating": 4.8, "reviewCount": 2, "nicheScore": 96, "url": "https://www.amazon.com/dp/…" }
    ]
}
````

| Field | Description |
| --- | --- |
| `opportunityScore` | 0–100 — higher = less competition, more room to rank |
| `competitionLevel` / `verdict` | `low`/`medium`/`high` + a plain-English 🟢/🟡/🔴 verdict |
| `medianReviewCount` / `avgReviewCount` | Review counts of ranking books — the core competition signal |
| `lowCompetitionShare` | Share of top books with ≤20 reviews |
| `avgPrice` / `avgRating` | Average book price and rating in the niche |
| `topBooks[]` | The top-scored books as evidence, each with its own `nicheScore` |

### How to find low-competition KDP niches

1. Add your niche ideas to **Keywords** — one per line (`nurse planner`, `dog mom notebook`, `teacher lesson planner 2026`).
2. Pick the **Amazon marketplace** (US, UK, DE…).
3. Run the Actor and read the `opportunityScore` and `verdict` for each — 🟢 niches are where a new book can still rank.

### How to research KDP low-content book ideas

Feed a long list of keyword variations in one run — cover a theme from every angle (`gratitude journal`, `gratitude journal for men`, `daily gratitude journal for kids`). The niches with high scores and low median review counts are the sub-angles the big sellers haven't saturated yet. Use the `topBooks` evidence to see exactly what's already ranking and where the gap is.

### How to check if a KDP niche is saturated

A niche is saturated when the top books already carry hundreds or thousands of reviews — a new book can't out-rank them on relevance alone. This Actor surfaces that instantly: a low `opportunityScore` with a high `medianReviewCount` (e.g. `gratitude journal` at 1,900+ median reviews) is a 🔴 saturated market to avoid. A high score with near-zero median reviews is an open lane.

### How much does it cost?

You pay per niche analyzed. Runs are cheap — a typical keyword list costs a few cents. The Actor runs on lightweight HTTP with rotating proxies; there's no browser to spin up.

### How to export KDP niche research to CSV or Google Sheets

After a run, open the **Dataset** tab and export as CSV, Excel or JSON, or connect the Apify **Google Sheets integration** to keep a living niche-research sheet that updates on every scheduled run.

### Input configuration

| Field | Type | Notes |
| --- | --- | --- |
| `keywords` | array | Niche keywords to score |
| `marketplace` | string | `us`, `uk`, `de`, `fr`, `es`, `it`, `ca`, `au`, `jp` |
| `maxBooksPerKeyword` | integer | Top results to score per niche (default 16) |
| `includeBooks` | boolean | Attach the top scored books as evidence |

### Integrations

- **Niches → Google Sheets** — keep a living niche-research sheet, updated on every scheduled run.
- **Niches → Slack / Discord** — get alerted when a monitored keyword opens up.
- **Niches → Make / Zapier** — trigger downstream research or design workflows.
- **Scheduled runs & webhooks** — re-score your niche shortlist weekly to catch newly-opening lanes.

### Use with AI agents via MCP

Callable from AI assistants via Apify's MCP server — ask "score these 10 KDP niche ideas and tell me which are open" and your assistant runs it and returns the verdicts.

### FAQ

**How is competition measured?** From the review counts of the books already ranking for the keyword — the most reliable public signal of how hard a niche is to enter.

**Why did a niche return no data?** Amazon occasionally serves a layout the parser can't read; the Actor retries, but a persistent miss is reported as a `no_data` status rather than a wrong score.

**Do I need an Amazon account or API key?** No. No login, no key.

### Disclaimer

This Actor is not affiliated with, endorsed by, or sponsored by Amazon. "Amazon" and "Kindle Direct Publishing" are trademarks of Amazon.com, Inc. It reads only publicly available search data. Comply with Amazon's Terms of Service and applicable laws.

### SEO Keywords

kdp niche research, amazon kdp niche finder, low content book niches, kdp keyword research, amazon book niche analyzer, self publishing niche research, print on demand niches, kdp low competition keywords, amazon book opportunity score, kdp niche scraper, book niche finder, kindle direct publishing research, amazon book market research, apify kdp actor

# Actor input Schema

## `keywords` (type: `array`):

Book niche ideas to score, e.g. `nurse planner`, `dog mom notebook`, `gratitude journal`. Each is analyzed separately.

## `marketplace` (type: `string`):

Which Amazon store to analyze.

## `maxBooksPerKeyword` (type: `integer`):

How many top search results to score per keyword (more = more stable score).

## `includeBooks` (type: `boolean`):

Attach the top scored books (title, price, rating, reviews) as evidence in each niche row.

## Actor input object example

```json
{
  "keywords": [
    "nurse planner",
    "gratitude journal"
  ],
  "marketplace": "us",
  "maxBooksPerKeyword": 16,
  "includeBooks": true
}
```

# Actor output Schema

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

Books and niche metrics for Kindle keyword and category research.

## `resultsCsv` (type: `string`):

The same rows as CSV — open in Excel or pull into Google Sheets with IMPORTDATA().

# 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 = {
    "keywords": [
        "nurse planner",
        "gratitude journal"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutlab/kdp-niche-analyzer").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 = { "keywords": [
        "nurse planner",
        "gratitude journal",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datascoutlab/kdp-niche-analyzer").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 '{
  "keywords": [
    "nurse planner",
    "gratitude journal"
  ]
}' |
apify call datascoutlab/kdp-niche-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datascoutlab/kdp-niche-analyzer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "KDP Niche Finder — Amazon Book Opportunity Scores",
        "description": "Find low-competition Amazon KDP book niches. Enter keywords, get each scored 0–100 by competition (review counts), price and rating — with a clear opportunity/saturated verdict and the top books as evidence. No API key.",
        "version": "0.1",
        "x-build-id": "O92O50NWN1a6jGqe8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutlab~kdp-niche-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutlab-kdp-niche-analyzer",
                "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/datascoutlab~kdp-niche-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-datascoutlab-kdp-niche-analyzer",
                "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/datascoutlab~kdp-niche-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutlab-kdp-niche-analyzer",
                "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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords / niches",
                        "type": "array",
                        "description": "Book niche ideas to score, e.g. `nurse planner`, `dog mom notebook`, `gratitude journal`. Each is analyzed separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketplace": {
                        "title": "Amazon marketplace",
                        "enum": [
                            "us",
                            "uk",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "ca",
                            "au",
                            "jp"
                        ],
                        "type": "string",
                        "description": "Which Amazon store to analyze.",
                        "default": "us"
                    },
                    "maxBooksPerKeyword": {
                        "title": "Books to analyze per niche",
                        "minimum": 4,
                        "maximum": 48,
                        "type": "integer",
                        "description": "How many top search results to score per keyword (more = more stable score).",
                        "default": 16
                    },
                    "includeBooks": {
                        "title": "Include evidence books",
                        "type": "boolean",
                        "description": "Attach the top scored books (title, price, rating, reviews) as evidence in each niche row.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
