# Teachers Pay Teachers Store & Product Scraper (`crawlerbros/teachers-pay-teachers-scraper`) Actor

Scrape Teachers Pay Teachers (TpT) with search educational resources by keyword, grade, subject, or format. Get product details with price, rating, seller info, and more. Also scrape entire teacher stores.

- **URL**: https://apify.com/crawlerbros/teachers-pay-teachers-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

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

## Teachers Pay Teachers Store & Product Scraper

Scrape educational resources from **Teachers Pay Teachers** (TPT) — the world's largest marketplace for teacher-created educational materials. Extract product details including price, rating, seller information, grade levels, and more — no account required.

### What This Actor Does

- **Search resources** by keyword with optional grade, subject, and format filters
- **Browse by grade** — Pre-K through 12th grade, Higher Education, Homeschool
- **Browse by subject** — Math, ELA, Science, Social Studies, Arts, and more
- **Fetch specific product details** from TpT product URLs
- **Scrape entire teacher stores** — get all products from any teacher's store page

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | Select | `search`, `byGrade`, `bySubject`, `getProduct`, `getStore` |
| `searchQuery` | Text | Keyword search (mode=search) |
| `startUrls` | List | TpT product or store URLs (getProduct/getStore) |
| `grade` | Select | Grade level filter (also required for byGrade mode) |
| `subject` | Select | Subject area filter (required for bySubject mode) |
| `format` | Select | Resource format (PDF, Google Apps, PowerPoint, etc.) |
| `isFree` | Boolean | Only return free resources |
| `minRating` | Number | Minimum average rating (1–5 star scale) |
| `minReviews` | Integer | Minimum number of ratings/reviews |
| `maxItems` | Integer | Maximum records to return (default: 24) |

#### Grade Options
Pre-K, Kindergarten, 1st–12th Grade, Higher Education, Adult Education, Homeschool, Not Grade Specific

#### Subject Options
Arts & Music, English Language Arts, Foreign Language, Math, Science, Social Studies - History, Special Education, Holidays/Seasonal

#### Format Options
PDF, Google Apps, PowerPoint, Word Document, Excel Spreadsheets, Easel Activity, Interactive Notebooks, Lesson Plans, Task Cards, Tests, Worksheets, Workbooks

### Output

| Field | Type | Description |
|-------|------|-------------|
| `productId` | String | TpT numeric product ID |
| `title` | String | Resource title |
| `description` | String | Product description |
| `price` | Number | Price in USD (0.0 = free) |
| `isFree` | Boolean | Whether the resource is free |
| `rating` | Number | Average rating (1–5 scale) |
| `ratingCount` | Integer | Number of ratings |
| `seller` | String | Teacher/seller display name |
| `sellerUrl` | String | Seller's TpT store URL |
| `thumbnailUrl` | String | Product preview image URL |
| `url` | String | Product page URL |
| `releaseDate` | String | Date product was listed |
| `currency` | String | Currency code (USD) |
| `grades` | Array | Grade levels (when available) |
| `subjects` | Array | Subject areas (when available) |
| `formats` | Array | Resource formats (when available) |
| `recordType` | String | Always "product" |
| `scrapedAt` | String | ISO timestamp |

### Example Output

```json
{
  "productId": "4061393",
  "title": "Multiplication Color By Number Worksheets - Fact Fluency",
  "price": 3.50,
  "isFree": false,
  "rating": 4.8,
  "ratingCount": 1250,
  "seller": "Games 4 Learning",
  "sellerUrl": "https://www.teacherspayteachers.com/Store/Games-4-Learning",
  "thumbnailUrl": "https://ecdn.teacherspayteachers.com/thumbitem/...",
  "url": "https://www.teacherspayteachers.com/Product/Multiplication-Color-By-Number-Worksheets-Fact-Fluency-4061393",
  "currency": "USD",
  "recordType": "product",
  "scrapedAt": "2026-05-17T07:00:00+00:00"
}
````

### Modes

#### `search` — Search by keyword

Searches TpT's browse page with optional filters.

```json
{"mode": "search", "searchQuery": "multiplication worksheets", "grade": "3rd", "maxItems": 24}
```

#### `byGrade` — Browse by grade level

Returns resources for a specific grade.

```json
{"mode": "byGrade", "grade": "Kindergarten", "maxItems": 50}
```

#### `bySubject` — Browse by subject

Returns resources for a specific subject area.

```json
{"mode": "bySubject", "subject": "Math", "grade": "5th", "maxItems": 50}
```

#### `getProduct` — Fetch specific product(s)

Returns full details for specific product URLs.

```json
{
  "mode": "getProduct",
  "startUrls": [
    "https://www.teacherspayteachers.com/Product/Multiplication-Color-By-Number-Worksheets-4061393"
  ]
}
```

#### `getStore` — Scrape a teacher's store

Returns all products from a teacher's store.

```json
{
  "mode": "getStore",
  "startUrls": ["https://www.teacherspayteachers.com/Store/Games-4-Learning"],
  "maxItems": 100
}
```

### FAQ

**Does this require a TpT account?**
No. All product listings and details scraped are publicly accessible without login.

**Does TpT use Algolia for search?**
TpT uses Algolia internally for its search infrastructure, but the search results are delivered as server-rendered HTML. This actor scrapes the HTML results pages and individual product pages to extract structured data (including JSON-LD) without needing Algolia credentials.

**How do I get grades, subjects, and formats for a product?**
These fields are best populated by fetching product detail pages (all modes except search/byGrade/bySubject). Use `mode=getProduct` or `mode=getStore` for richest data.

**What is the rating scale?**
TpT uses a standard 1–5 star rating scale. The JSON-LD on product pages includes `ratingValue` on this scale.

**How many products can I scrape?**
Set `maxItems` up to 5000. TpT has millions of resources.

**Why might some product records have fewer fields?**
Listing pages provide only the product URL and title. Full details (price, rating, seller, thumbnail) require fetching individual product pages, which is done automatically by the actor.

**Can I scrape an entire teacher's store?**
Yes — use `mode=getStore` with the store URL. The actor paginates through all store pages automatically.

### Limitations

- TpT's browse page may require a brief delay between requests to avoid rate limiting
- Some product fields (grades, subjects, formats) may not always be available on listing pages and require fetching the product detail page
- Product pages blocked by TpT's anti-bot systems will be skipped with a warning; try reducing request frequency if many pages fail
- Preview/download files are not accessible without a TpT account

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

## `searchQuery` (type: `string`):

Keyword(s) to search for resources (mode=search).

## `startUrls` (type: `array`):

TpT product or store URLs (modes: getProduct, getStore). Example: https://www.teacherspayteachers.com/Product/Multiplication-Worksheets-4061393

## `grade` (type: `string`):

Filter by grade level. Required for mode=byGrade.

## `subject` (type: `string`):

Filter by subject area. Required for mode=bySubject.

## `format` (type: `string`):

Filter by resource format/file type.

## `isFree` (type: `boolean`):

When enabled, only return free resources.

## `minRating` (type: `number`):

Minimum average rating (TpT uses 1–5 star scale).

## `minReviews` (type: `integer`):

Minimum number of reviews/ratings.

## `maxItems` (type: `integer`):

Maximum number of product records to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "multiplication worksheets",
  "startUrls": [],
  "grade": "",
  "subject": "",
  "format": "",
  "isFree": false,
  "maxItems": 24
}
```

# Actor output Schema

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

Dataset containing all scraped TpT product records.

# 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 = {
    "mode": "search",
    "searchQuery": "multiplication worksheets",
    "startUrls": [],
    "grade": "",
    "subject": "",
    "format": "",
    "isFree": false,
    "maxItems": 24
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/teachers-pay-teachers-scraper").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 = {
    "mode": "search",
    "searchQuery": "multiplication worksheets",
    "startUrls": [],
    "grade": "",
    "subject": "",
    "format": "",
    "isFree": False,
    "maxItems": 24,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/teachers-pay-teachers-scraper").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 '{
  "mode": "search",
  "searchQuery": "multiplication worksheets",
  "startUrls": [],
  "grade": "",
  "subject": "",
  "format": "",
  "isFree": false,
  "maxItems": 24
}' |
apify call crawlerbros/teachers-pay-teachers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/teachers-pay-teachers-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Teachers Pay Teachers Store & Product Scraper",
        "description": "Scrape Teachers Pay Teachers (TpT) with search educational resources by keyword, grade, subject, or format. Get product details with price, rating, seller info, and more. Also scrape entire teacher stores.",
        "version": "1.0",
        "x-build-id": "IcmpWThq4rwh9yHXD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~teachers-pay-teachers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-teachers-pay-teachers-scraper",
                "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/crawlerbros~teachers-pay-teachers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-teachers-pay-teachers-scraper",
                "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/crawlerbros~teachers-pay-teachers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-teachers-pay-teachers-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byGrade",
                            "bySubject",
                            "getProduct",
                            "getStore"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword(s) to search for resources (mode=search).",
                        "default": "multiplication worksheets"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "TpT product or store URLs (modes: getProduct, getStore). Example: https://www.teacherspayteachers.com/Product/Multiplication-Worksheets-4061393",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "grade": {
                        "title": "Grade level",
                        "enum": [
                            "",
                            "PreK",
                            "Kindergarten",
                            "1st",
                            "2nd",
                            "3rd",
                            "4th",
                            "5th",
                            "6th",
                            "7th",
                            "8th",
                            "9th",
                            "10th",
                            "11th",
                            "12th",
                            "Higher Education",
                            "Adult Education",
                            "Homeschool",
                            "Not Grade Specific"
                        ],
                        "type": "string",
                        "description": "Filter by grade level. Required for mode=byGrade.",
                        "default": ""
                    },
                    "subject": {
                        "title": "Subject area",
                        "enum": [
                            "",
                            "Arts & Music",
                            "English Language Arts",
                            "Foreign Language",
                            "Math",
                            "Science",
                            "Social Studies - History",
                            "Special Education",
                            "Holidays/Seasonal"
                        ],
                        "type": "string",
                        "description": "Filter by subject area. Required for mode=bySubject.",
                        "default": ""
                    },
                    "format": {
                        "title": "Resource format",
                        "enum": [
                            "",
                            "PDF",
                            "Google Apps",
                            "PowerPoint",
                            "Word Document",
                            "Excel Spreadsheets",
                            "Easel Activity",
                            "Interactive Notebooks",
                            "Lesson Plans",
                            "Task Cards",
                            "Tests",
                            "Worksheets",
                            "Workbooks"
                        ],
                        "type": "string",
                        "description": "Filter by resource format/file type.",
                        "default": ""
                    },
                    "isFree": {
                        "title": "Free resources only",
                        "type": "boolean",
                        "description": "When enabled, only return free resources.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Min rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Minimum average rating (TpT uses 1–5 star scale)."
                    },
                    "minReviews": {
                        "title": "Min reviews",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Minimum number of reviews/ratings."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of product records to return.",
                        "default": 24
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
