# Teachers Pay Teachers Scraper (`solidcode/teacherspayteachers-scraper`) Actor

\[💰 $7.5 / 1K] Extract Teachers Pay Teachers resources by search term, product URL, or store — titles, prices, sale prices, quality scores, ratings, grade levels, subjects, formats, standards, author info, thumbnails, and optional individual reviews.

- **URL**: https://apify.com/solidcode/teacherspayteachers-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 resources

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/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 Scraper

Pull educational resources from Teachers Pay Teachers (TpT) at scale — prices, sale prices, quality scores, ratings, grade levels, subjects, formats, standards alignment, teacher-author store details, and optional individual buyer reviews. Search by keyword, paste a single resource link, or point it at a whole store to pull that seller's entire catalogue. Built for curriculum companies, edtech market-research teams, and TpT sellers who need structured competitive data across thousands of resources without copying it off one product page at a time.

### Why This Scraper?

- **Three ways in — keyword, resource URL, or whole-store URL** — search a term like `"fractions"`, paste a `/Product/...` link for one resource, or paste a `/store/...` link to pull a competitor's full catalogue. Mix all three freely in a single run.
- **19 grade-level filters** — PreK through Grade 12 plus Homeschool, Adult Education, Higher Education, Staff, and Not Grade Specific — so you only collect resources for the audience you sell to.
- **20+ subject and resource-type filters** — Math, English Language Arts, Science, Social Studies, World Languages, Arts, Music, Special Education, and ESL/EFL/ELL subjects, plus format filters for worksheets, task cards, Google Apps, PDF, PowerPoint, Easel activities, and more.
- **Free-only and price-range targeting** — set a minimum and maximum USD price, or set the maximum to `0` to return only free resources — the fastest way to map a market's freebies.
- **Quality-score threshold (0–5 scale)** — TpT gives each resource an aggregate quality score out of 5; filter to 3.0+, 3.5+, 4.0+, 4.5+, or 5.0 (top rated) to surface only proven best-sellers.
- **Individual buyer reviews on demand** — flip one switch to collect each resource's reviews as separate rows: reviewer, numeric rating (0–4), the qualitative satisfaction label, comment text, grades taught, and buyer location — the raw material for sentiment analysis.
- **Every resource carries standards alignment** — Common Core and other academic standards notation (e.g. `3.NF.A.1`) attached to each resource, so you can map a catalogue to a curriculum framework.
- **Two clean record types, parent-to-child linked** — `product` rows and `review` rows, each review joined to its resource by product id and URL, delivered in separate Resources and Reviews tabs.
- **On-sale detection and four sort orders** — filter to currently discounted resources and order results by relevance, rating, price (low or high), or newest.

### Use Cases

**Market Research**
- Map an entire subject-and-grade niche to size the opportunity before building a resource
- Track how many resources exist for a trending topic and how they are priced
- Compare free versus paid resource density across grade bands
- Benchmark quality scores and rating counts across a category

**Competitive Pricing**
- Pull a competitor's full store catalogue from a single `/store/...` link
- Compare list price versus sale price to reverse-engineer discount strategies
- Find the price band where top-rated resources cluster in your subject
- Monitor which competitor resources are currently on sale

**Lead Generation**
- Build lists of high-performing teacher-authors by store name and store URL
- Identify prolific sellers in a subject to target for partnerships or acquisition
- Surface authors whose resources consistently score 4.0 to recruit as contributors

**Curriculum & Content Research**
- Filter resources by Common Core and other standards to fill curriculum gaps
- Discover the most popular formats (task cards, Google Apps, Easel) for a grade level
- Assemble a shortlist of top-rated worksheets and lessons for a unit

**Academic Research**
- Study pricing, ratings, and review sentiment across the educational-resource marketplace
- Analyze which grade levels and subjects attract the most reviews
- Measure the relationship between quality score, price, and review volume

### Getting Started

#### Simple Keyword Search

The simplest run — one search term, 100 resources:

```json
{
    "searchQueries": ["fractions"],
    "maxResults": 100
}
````

#### Filtered Search

Fourth-grade math worksheets rated 4.0 and up, under $5, newest first:

```json
{
    "searchQueries": ["multiplication"],
    "gradeLevels": ["4th-grade"],
    "subjects": ["math"],
    "resourceTypes": ["worksheets"],
    "minRating": "4",
    "priceMax": 5,
    "sort": "newest",
    "maxResults": 200
}
```

#### Store Catalogue with Reviews

Pull a seller's full catalogue and collect up to 50 reviews per resource for sentiment analysis:

```json
{
    "searchQueries": ["https://www.teacherspayteachers.com/store/example-teacher-store"],
    "includeReviews": true,
    "maxReviewsPerProduct": 50,
    "maxResults": 0
}
```

#### Free Resources Only

Map every free resource for a topic — set the maximum price to zero:

```json
{
    "searchQueries": ["sight words"],
    "priceMax": 0,
    "sort": "rating",
    "maxResults": 100
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["fractions"]` | Search terms (e.g. "fractions", "sight words") and/or TpT links. A resource page (`/Product/...`) returns that resource; a store page (`/store/...`) returns that seller's resources. Each entry is processed on its own. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `gradeLevels` | string\[] | `[]` | Only include resources for these grade levels. 19 options from PreK / Preschool through 12th grade, plus Higher education, Adult education, Homeschool, Staff, and Not grade specific. Empty means all grades. |
| `subjects` | string\[] | `[]` | Only include resources in these subject areas: Math, English Language Arts, Science, Social Studies / History, Specialty, Arts, Music, World Languages, Holidays / Seasonal, English Language Learning (ESL/EFL/ELL), Special Education, For All Subjects. Empty means all subjects. |
| `resourceTypes` | string\[] | `[]` | Only include these resource types or file formats: Worksheets, Activities, Task cards, Centers, Assessment, Lesson plans, Games, Printables, Projects, Google Apps, PDF, Microsoft PowerPoint, Microsoft Word, Easel activity, Internet activities. Empty means all types. |
| `onSaleOnly` | boolean | `false` | Only include resources that are currently on sale. |
| `minRating` | string | `"0"` | Only include resources with at least this overall quality score. Options: Any score, 3.0 & up, 3.5 & up, 4.0 & up, 4.5 & up, 5.0 & up (top rated). TpT shows an aggregate quality score out of 5. |
| `priceMin` | number | null | Only include resources priced at or above this amount in USD. Empty means no minimum. |
| `priceMax` | number | null | Only include resources priced at or below this amount in USD. Set to `0` to return only free resources. Empty means no maximum. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sort` | string | `"relevance"` | Order for search and store results: Relevance, Rating, Price: low to high, Price: high to low, Newest. Ignored for direct resource URLs. "Price: high to low" ranks the highest-priced resources within a relevance-based sample of up to 500 results, so on very large result sets the ranking is over that sample rather than the entire catalogue. |
| `maxResults` | integer | `100` | Maximum resources to collect for each search term or store. Set to `0` to collect everything (a broad search or large store can hold thousands). |

#### Reviews

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReviews` | boolean | `false` | Also collect each resource's individual ratings and reviews as separate rows. Adds rows and cost — a popular resource can have thousands of ratings. Off by default. |
| `maxReviewsPerProduct` | integer | `50` | When reviews are enabled, the maximum number of reviews to collect per resource. Set to `0` to collect all reviews. |

### Output

Every row carries a `recordType` field — `product` or `review` — so you can filter cleanly downstream. The Overview tab holds every record; the Resources and Reviews tabs are clean, type-filtered subsets of the same run.

#### Resource (`recordType: "product"`)

```json
{
    "recordType": "product",
    "id": "1234567",
    "type": "DigitalDownloadResource",
    "title": "Fraction Flip Book",
    "canonicalSlug": "Fraction-Flip-Book-1234567",
    "url": "https://www.teacherspayteachers.com/Product/Fraction-Flip-Book-1234567",
    "descriptionSnippet": "A hands-on flip book for teaching equivalent fractions...",
    "price": 4.5,
    "salePrice": 3.6,
    "onSale": true,
    "overallQualityScore": 3.9,
    "totalEvaluations": 442,
    "gradeLevels": ["3rd-grade", "4th-grade"],
    "subjectAreas": ["math"],
    "resourceCategories": ["activities", "printables"],
    "formats": ["activities", "printables"],
    "taxonomyTagIds": ["math", "3rd-grade", "fractions"],
    "standards": ["3.NF.A.1", "4.NF.A.1"],
    "authorId": "98765",
    "authorName": "The Fraction Teacher",
    "authorSlug": "the-fraction-teacher",
    "storeUrl": "https://www.teacherspayteachers.com/store/the-fraction-teacher",
    "thumbnailOriginalUrl": "https://ecdn.teacherspayteachers.com/thumbitem/original.jpg",
    "thumbnailLargeUrl": "https://ecdn.teacherspayteachers.com/thumbitem/large.jpg",
    "searchQuery": "fractions",
    "scrapedAt": "2026-07-04T14:30:00Z"
}
```

##### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"product"` |
| `id` | string | TpT resource id |
| `type` | string | Resource type (`DigitalDownloadResource`, `BundleResource`, etc.) |
| `title` | string | Resource title |
| `canonicalSlug` | string | URL slug for the resource |
| `url` | string | Full resource URL |
| `descriptionSnippet` | string | Short description snippet |
| `searchQuery` | string | The input entry that produced this row |
| `scrapedAt` | string | ISO timestamp of extraction |

##### Pricing & Quality

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | List price in USD |
| `salePrice` | number | Sale price in USD (`0` when not on sale; `null` for an on-sale resource whose listing does not expose the discounted price) |
| `onSale` | boolean | Whether the resource is currently on sale |
| `overallQualityScore` | number | Aggregate quality score on a 0–5 scale |
| `totalEvaluations` | integer | Number of ratings/reviews the resource has received |

##### Classification

| Field | Type | Description |
|-------|------|-------------|
| `gradeLevels` | string\[] | Grade-level tags |
| `subjectAreas` | string\[] | Subject-area tags |
| `resourceCategories` | string\[] | Resource type tags |
| `formats` | string\[] | File-format tags (PDF, Google Apps, etc.) |
| `taxonomyTagIds` | string\[] | All taxonomy tag ids, including fine-grained topics |
| `standards` | string\[] | Aligned academic standards (e.g. `3.NF.A.1`) |

##### Author & Media

| Field | Type | Description |
|-------|------|-------------|
| `authorId` | string | Author/store id |
| `authorName` | string | Author/store display name |
| `authorSlug` | string | Author/store slug |
| `storeUrl` | string | Full store URL |
| `thumbnailOriginalUrl` | string | Original-size thumbnail URL |
| `thumbnailLargeUrl` | string | Large thumbnail URL |

#### Review (`recordType: "review"`)

Emitted only when `includeReviews: true`. Each review links back to its resource by `productId` and `productUrl`.

```json
{
    "recordType": "review",
    "id": "eval-556677",
    "productId": "1234567",
    "productUrl": "https://www.teacherspayteachers.com/Product/Fraction-Flip-Book-1234567",
    "rating": 4,
    "ratingLabel": "EXTREMELY",
    "ratingScaleMax": 4,
    "title": "Perfect for my centers",
    "comment": "My students loved this — clear layout and easy to assemble.",
    "createdAt": "2026-05-12T09:15:00Z",
    "reviewerId": "44556",
    "reviewerName": "Ms. Rivera",
    "reply": "So glad it worked for your class — thank you!",
    "gradesUsed": ["3rd-grade"],
    "buyerLocation": "Texas",
    "searchQuery": "fractions",
    "scrapedAt": "2026-07-04T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` |
| `id` | string | Review id |
| `productId` | string | Parent resource id (links to the `product` row) |
| `productUrl` | string | Parent resource URL |
| `rating` | number | Numeric rating on a 0–4 scale |
| `ratingLabel` | string | Raw satisfaction label (e.g. `EXTREMELY`, `VERY`) |
| `ratingScaleMax` | number | Maximum of the rating scale (always `4`) |
| `title` | string | Review title / buyer-experience headline |
| `comment` | string | Reviewer comment text (nullable) |
| `createdAt` | string | When the review was left |
| `reviewerId` | string | Reviewer user id |
| `reviewerName` | string | Reviewer display name (when public) |
| `reply` | string | Author's reply to the review (nullable) |
| `gradesUsed` | string\[] | Grade levels the buyer taught with the resource |
| `buyerLocation` | string | Buyer's teaching location (when public) |
| `searchQuery` | string | The input entry that produced the parent resource |
| `scrapedAt` | string | ISO timestamp of extraction |

### Tips for Best Results

- **Point a store URL at a competitor to pull their whole catalogue.** Paste a `/store/...` link with `maxResults: 0` to collect every resource a seller lists — the fastest way to build a full competitive picture.
- **Leave reviews off unless you need sentiment.** Reviews add a row per review, and a popular resource can carry thousands. Turn `includeReviews` on only for the runs where buyer feedback matters, and cap `maxReviewsPerProduct` to keep volume in check.
- **Set the maximum price to zero to map the freebies.** `priceMax: 0` returns only free resources — a clean way to see what a market gives away versus what it charges for.
- **Filter to 4.5 & up (or 5.0 for top rated) to skip the long tail.** The `minRating` threshold runs on TpT's 0–5 aggregate quality score, so setting a high floor surfaces only proven best-sellers and you spend results on resources buyers actually rate highly.
- **Start with a modest `maxResults` to test filters.** Run 20–50 first to confirm your grade, subject, and format filters return the right resources, then scale up.
- **Combine terms and links in one run.** Mix keywords, resource URLs, and store URLs in `searchQueries` — each entry is processed independently with the same filters applied to search and store results.
- **Filters are ignored for direct resource URLs.** A `/Product/...` link always returns that exact resource; grade, subject, price, and sort settings only shape search and store results.

### Pricing

**From $7.50 per 1,000 resources + $0.50 per 1,000 reviews** — undercuts the market for TpT resource extraction while keeping optional reviews cheap and pay-only-if-you-use-them. This actor is billed pay-per-event: you are charged per resource and per review collected. No compute or time-based charges — you pay only for the resources and reviews you collect. Bronze, Silver, and Gold subscribers pay progressively less; loyalty discounts apply automatically on the Apify platform.

| Event | No discount | Bronze | Silver | Gold |
|-------|-------------|--------|--------|------|
| Per 1,000 resources | $9.00 | $8.50 | $8.00 | $7.50 |
| Per 1,000 reviews | $0.60 | $0.56 | $0.53 | $0.50 |

Example total costs at the Gold rate:

| What you collect | Resources cost | Reviews cost | Total |
|------------------|----------------|--------------|-------|
| 500 resources, no reviews | $3.75 | $0.00 | $3.75 |
| 500 resources + 20 reviews each (10,000 reviews) | $3.75 | $5.00 | $8.75 |
| 2,000 resources, no reviews | $15.00 | $0.00 | $15.00 |

A "resource" is one `product` row; a "review" is one `review` row. Reviews are only collected when you enable them. Platform fees (storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, competitive analysis, curriculum research, and academic study. Users are responsible for complying with applicable laws and Teachers Pay Teachers' terms of service, including making reasonable-rate requests and respecting content usage rules. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data (such as reviewer names) responsibly and in line with applicable privacy regulations.

# Actor input Schema

## `searchQueries` (type: `array`):

Add search terms (e.g. "fractions", "sight words") or paste Teachers Pay Teachers links — a resource page (e.g. https://www.teacherspayteachers.com/Product/...) returns that resource, and a store page (e.g. https://www.teacherspayteachers.com/store/...) returns that seller's resources. Each entry is processed on its own.

## `gradeLevels` (type: `array`):

Only include resources for these grade levels. Leave empty for all grades.

## `subjects` (type: `array`):

Only include resources in these subject areas. Leave empty for all subjects.

## `resourceTypes` (type: `array`):

Only include these resource types or file formats. Leave empty for all types.

## `onSaleOnly` (type: `boolean`):

Only include resources that are currently on sale.

## `minRating` (type: `string`):

Only include resources with at least this overall quality score. Teachers Pay Teachers shows each resource an aggregate quality score out of 5. Resources below the threshold (or with no score yet) are dropped from the results.

## `priceMin` (type: `number`):

Only include resources priced at or above this amount in US dollars. Leave empty for no minimum.

## `priceMax` (type: `number`):

Only include resources priced at or below this amount in US dollars. Set to 0 to return only free resources. Leave empty for no maximum.

## `sort` (type: `string`):

Order for search and store results. Ignored when you paste a direct resource URL. "Price: high to low" returns the most expensive resources first; because the site offers no true high-to-low price order, it ranks the highest-priced resources found within a relevance-based sample of up to 500 results (so on a very large result set the ranking is over that sample, not the entire catalogue).

## `maxResults` (type: `integer`):

Maximum number of resources to collect for each search term or store. Set to 0 to collect everything (use with care — a broad search or a large store can hold thousands of resources).

## `includeReviews` (type: `boolean`):

When enabled, each resource's individual ratings and reviews are collected as separate rows. This adds results and increases cost. Reviews are pulled for every resource collected, so total cost can far exceed Max results — a popular resource can have thousands of ratings. Off by default.

## `maxReviewsPerProduct` (type: `integer`):

When reviews are enabled, the maximum number of reviews to collect per resource. Set to 0 to collect all reviews.

## Actor input object example

```json
{
  "searchQueries": [
    "fractions"
  ],
  "gradeLevels": [],
  "subjects": [],
  "resourceTypes": [],
  "onSaleOnly": false,
  "minRating": "0",
  "sort": "relevance",
  "maxResults": 100,
  "includeReviews": false,
  "maxReviewsPerProduct": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

Every record from the run in one place — resources and reviews — distinguished by `recordType`.

## `products` (type: `string`):

Resources only, with title, price, sale price, quality score, ratings, grades, subjects, formats, standards, and author info.

## `reviews` (type: `string`):

Individual reviews only, linking each review to its resource. Present only when 'Also collect reviews' is enabled.

# 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 = {
    "searchQueries": [
        "fractions"
    ],
    "gradeLevels": [],
    "subjects": [],
    "resourceTypes": [],
    "onSaleOnly": false,
    "minRating": "0",
    "sort": "relevance",
    "maxResults": 100,
    "includeReviews": false,
    "maxReviewsPerProduct": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/teacherspayteachers-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 = {
    "searchQueries": ["fractions"],
    "gradeLevels": [],
    "subjects": [],
    "resourceTypes": [],
    "onSaleOnly": False,
    "minRating": "0",
    "sort": "relevance",
    "maxResults": 100,
    "includeReviews": False,
    "maxReviewsPerProduct": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/teacherspayteachers-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 '{
  "searchQueries": [
    "fractions"
  ],
  "gradeLevels": [],
  "subjects": [],
  "resourceTypes": [],
  "onSaleOnly": false,
  "minRating": "0",
  "sort": "relevance",
  "maxResults": 100,
  "includeReviews": false,
  "maxReviewsPerProduct": 50
}' |
apify call solidcode/teacherspayteachers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Teachers Pay Teachers Scraper",
        "description": "[💰 $7.5 / 1K] Extract Teachers Pay Teachers resources by search term, product URL, or store — titles, prices, sale prices, quality scores, ratings, grade levels, subjects, formats, standards, author info, thumbnails, and optional individual reviews.",
        "version": "1.0",
        "x-build-id": "tfE7ZFWEigNQ2pBhU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~teacherspayteachers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-teacherspayteachers-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/solidcode~teacherspayteachers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-teacherspayteachers-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/solidcode~teacherspayteachers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-teacherspayteachers-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",
                "properties": {
                    "searchQueries": {
                        "title": "Search terms or TpT URLs",
                        "type": "array",
                        "description": "Add search terms (e.g. \"fractions\", \"sight words\") or paste Teachers Pay Teachers links — a resource page (e.g. https://www.teacherspayteachers.com/Product/...) returns that resource, and a store page (e.g. https://www.teacherspayteachers.com/store/...) returns that seller's resources. Each entry is processed on its own.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "gradeLevels": {
                        "title": "Grade levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include resources for these grade levels. Leave empty for all grades.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "preschool",
                                "kindergarten",
                                "1st-grade",
                                "2nd-grade",
                                "3rd-grade",
                                "4th-grade",
                                "5th-grade",
                                "6th-grade",
                                "7th-grade",
                                "8th-grade",
                                "9th-grade",
                                "10th-grade",
                                "11th-grade",
                                "12th-grade",
                                "higher-education",
                                "adult-education",
                                "homeschool",
                                "staff",
                                "not-grade-specific"
                            ],
                            "enumTitles": [
                                "PreK / Preschool",
                                "Kindergarten",
                                "1st grade",
                                "2nd grade",
                                "3rd grade",
                                "4th grade",
                                "5th grade",
                                "6th grade",
                                "7th grade",
                                "8th grade",
                                "9th grade",
                                "10th grade",
                                "11th grade",
                                "12th grade",
                                "Higher education",
                                "Adult education",
                                "Homeschool",
                                "Staff",
                                "Not grade specific"
                            ]
                        },
                        "default": []
                    },
                    "subjects": {
                        "title": "Subjects",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include resources in these subject areas. Leave empty for all subjects.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "math",
                                "english-language-arts",
                                "science",
                                "social-studies",
                                "specialty",
                                "arts",
                                "music",
                                "world-languages",
                                "holidays-seasonal",
                                "esl-efl-ell",
                                "special-education",
                                "for-all-subjects"
                            ],
                            "enumTitles": [
                                "Math",
                                "English Language Arts",
                                "Science",
                                "Social Studies / History",
                                "Specialty",
                                "Arts",
                                "Music",
                                "World Languages",
                                "Holidays / Seasonal",
                                "English Language Learning (ESL/EFL/ELL)",
                                "Special Education",
                                "For All Subjects"
                            ]
                        },
                        "default": []
                    },
                    "resourceTypes": {
                        "title": "Resource types & formats",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include these resource types or file formats. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "worksheets",
                                "activities",
                                "task-cards",
                                "centers",
                                "assessment",
                                "lessons",
                                "games",
                                "printables",
                                "projects",
                                "google-apps",
                                "pdf",
                                "microsoft-powerpoint",
                                "microsoft-word",
                                "easel-activities",
                                "internet-activities"
                            ],
                            "enumTitles": [
                                "Worksheets",
                                "Activities",
                                "Task cards",
                                "Centers",
                                "Assessment",
                                "Lesson plans",
                                "Games",
                                "Printables",
                                "Projects",
                                "Google Apps",
                                "PDF",
                                "Microsoft PowerPoint",
                                "Microsoft Word",
                                "Easel activity",
                                "Internet activities"
                            ]
                        },
                        "default": []
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Only include resources that are currently on sale.",
                        "default": false
                    },
                    "minRating": {
                        "title": "Minimum quality score",
                        "enum": [
                            "0",
                            "3",
                            "3.5",
                            "4",
                            "4.5",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only include resources with at least this overall quality score. Teachers Pay Teachers shows each resource an aggregate quality score out of 5. Resources below the threshold (or with no score yet) are dropped from the results.",
                        "default": "0"
                    },
                    "priceMin": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include resources priced at or above this amount in US dollars. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include resources priced at or below this amount in US dollars. Set to 0 to return only free resources. Leave empty for no maximum."
                    },
                    "sort": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "rating",
                            "price-asc",
                            "price-desc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Order for search and store results. Ignored when you paste a direct resource URL. \"Price: high to low\" returns the most expensive resources first; because the site offers no true high-to-low price order, it ranks the highest-priced resources found within a relevance-based sample of up to 500 results (so on a very large result set the ranking is over that sample, not the entire catalogue).",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max results per entry",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of resources to collect for each search term or store. Set to 0 to collect everything (use with care — a broad search or a large store can hold thousands of resources).",
                        "default": 100
                    },
                    "includeReviews": {
                        "title": "Also collect reviews",
                        "type": "boolean",
                        "description": "When enabled, each resource's individual ratings and reviews are collected as separate rows. This adds results and increases cost. Reviews are pulled for every resource collected, so total cost can far exceed Max results — a popular resource can have thousands of ratings. Off by default.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per resource",
                        "minimum": 0,
                        "type": "integer",
                        "description": "When reviews are enabled, the maximum number of reviews to collect per resource. Set to 0 to collect all reviews.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
