# Sheffield Pottery Scraper — Catalog & Prices (`muhammadafzal/sheffield-pottery-scraper`) Actor

Scrape public Sheffield Pottery product catalogs with product names, prices, stock, variants, images, categories, and descriptions.

- **URL**: https://apify.com/muhammadafzal/sheffield-pottery-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** E-commerce, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 product scrapeds

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

Learn more: https://docs.apify.com/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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Sheffield Pottery Scraper — Catalog & Prices

Scrape public [Sheffield Pottery](https://www.sheffield-pottery.com/) catalog data into structured JSON. This actor returns product names, prices, availability, public variants, images, tags, product categories, descriptions, and canonical product URLs. Use it for pottery-supply price monitoring, studio purchasing research, catalog enrichment, and building a searchable inventory reference. Do not use it to purchase products, access customer information, bypass account restrictions, or collect private checkout data.

### What data can I extract?

Each dataset item represents one public product. The actor reads Sheffield Pottery's publicly available Shopify catalog endpoint, then normalizes its data into a small, stable shape suitable for spreadsheets, APIs, and AI agents.

| Field | Meaning |
| --- | --- |
| `title`, `brand`, `category`, `tags` | Product identity and public catalog classification |
| `currentPrice`, `originalPrice`, `currency` | Lowest active variant price and public compare-at price |
| `available`, `variantCount`, `variants` | Product availability and optional public SKU-level options |
| `description`, `images`, `mainImage` | Public product copy and image URLs |
| `productUrl`, `sourceUrl`, `scrapedAt` | Traceable source links and extraction time |

### When to use this actor

Use this actor when the task specifically concerns Sheffield Pottery product data: comparing glaze, clay, kiln, tool, or equipment prices; monitoring catalog availability; or feeding a product dataset into an internal research workflow. It accepts the complete catalog by default, or one or more public Sheffield Pottery collection URLs.

It is deliberately narrow. It does not scrape other retailers, reviews, customer accounts, checkout flows, order history, or hidden inventory. For a multi-store project, use a general Shopify store scraper instead; this actor is optimized for Sheffield Pottery's public catalog format.

### Pricing

The actor uses predictable Pay-Per-Event pricing and also supports Apify's usage-based billing option.

| Event | Price |
| --- | ---: |
| Actor start | $0.00005 per run |
| Product scraped | $0.005 per successfully stored product |

For example, a run capped at 100 products costs at most **$0.50005** in PPE charges. The actor prints the cap before it requests catalog pages, only charges after a product is safely stored, and never charges beyond `maxResults`.

### Input

The default input is intentionally useful for health checks and quick catalog exploration:

```json
{
  "startUrls": [{ "url": "https://www.sheffield-pottery.com/collections/all-products" }],
  "maxResults": 20,
  "includeDescription": true,
  "includeVariants": true,
  "requestDelayMs": 250
}
```

`startUrls` may contain public collection URLs, for example `/collections/all-products` or another Sheffield Pottery collection. `maxResults` is a whole-run cap, including when several collection URLs are supplied. Set `includeVariants` to `false` when you only need product-level pricing and availability. Setting `includeDescription` to `false` creates lighter result records for repeated monitoring runs.

### Output

The actor returns one record per product. Optional values are explicitly `null` when Sheffield Pottery does not expose a value publicly.

```json
{
  "productId": "15403886707059",
  "title": "Olander - Texture Sphere 35 Gingko L",
  "brand": "Olander Earthworks",
  "category": "Texture Tools",
  "currentPrice": 36.95,
  "originalPrice": null,
  "currency": "USD",
  "available": true,
  "variantCount": 1,
  "productUrl": "https://www.sheffield-pottery.com/products/olander-texture-sphere-35-gingko-l",
  "scrapedAt": "2026-07-22T03:00:00.000Z"
}
```

A `SUMMARY` key-value record is also saved at the end of each run. It reports pushed products, billed product events, the requested maximum, whether the cap stopped the run, and the completion time. This makes it easy for an automation to distinguish a deliberately capped run from a short catalog.

### API and MCP use

Run the actor from the Apify API with your account and actor slug:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/sheffield-pottery-scraper').call({
  maxResults: 50,
  includeVariants: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

AI agents can invoke the actor through Apify MCP when they need a structured Sheffield Pottery catalog rather than generic web search. The useful prompt-level instruction is: “Scrape up to 20 Sheffield Pottery products with prices and availability.” The dataset's stable field names let agents compare prices or pass product URLs to a downstream workflow without parsing raw HTML.

### Reliability and limits

The scraper uses Sheffield Pottery's public Shopify JSON endpoint, which is faster and less brittle than browser-only page parsing. It fetches catalog pages of up to 250 products, applies a small configurable delay between pages, retries transient requests, and stops immediately once the requested cap is met. Valid empty collections produce a successful completion with a summary; invalid or non-Sheffield URLs exit with an actionable warning rather than consuming a failed-run signal.

Catalog information changes without notice. Product availability and price are snapshots from the time shown in `scrapedAt`; always check `productUrl` before making a purchasing decision. Public variant SKUs and availability are catalog signals, not a reservation or a guarantee of fulfilment.

### FAQ

#### How many results can I scrape with Sheffield Pottery Scraper?

Set `maxResults` from 1 to 10,000. The default is 100. The total cap applies across every supplied collection URL.

#### Can I integrate Sheffield Pottery Scraper with other apps?

Yes. Read the default dataset through the Apify API, export it as JSON/CSV, or connect it to your automation after a run completes.

#### Can I use Sheffield Pottery Scraper with the Apify API?

Yes. The API example above starts a run and reads the default dataset. Use your own Apify token and actor owner name.

#### Can I use Sheffield Pottery Scraper through an MCP Server?

Yes. Apify MCP can run this actor and return its declared dataset shape to compatible AI-agent clients.

#### Do I need proxies to scrape Sheffield Pottery data?

No proxy configuration is required for normal public-catalog use. The actor respects a result cap and page delay; reduce volume or retry later if the target rate-limits a run.

#### Is it legal to scrape Sheffield Pottery data?

You are responsible for ensuring your use complies with applicable law, the target site's terms, and your organization's policies. This actor is designed only for publicly available catalog data and must not be used to access personal, account, checkout, or restricted information.

### Your feedback

If a public catalog field changes or a collection needs support, share the collection URL and a small expected-output example in the actor's issue channel. That is the fastest way to improve the data contract without adding unrelated scope.

# Actor input Schema

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

Use this when you need one or more public Sheffield Pottery collection catalogs. Supply URLs such as https://www.sheffield-pottery.com/collections/all-products. Defaults to the full catalog and accepts only Sheffield Pottery URLs. This is not for other Shopify stores or checkout URLs.

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

Use this to cap returned product records and the resulting bill. Enter an integer such as 100; the default is 100 and the maximum is 10000. Each returned product costs $0.005 after the run-start charge. This is a total cap across all supplied collections, not pages per collection.

## `includeDescription` (type: `boolean`):

Use this when product copy is needed for catalog analysis or content research. Set true to return cleaned public product descriptions; it defaults to true. Set false for smaller records. This does not retrieve reviews, private notes, or checkout data.

## `includeVariants` (type: `boolean`):

Use this when SKU-level options, prices, and availability are needed. Set true to return up to 250 public variants per product; it defaults to true. Set false for a concise catalog feed. This is not an inventory reservation or a purchase action.

## `requestDelayMs` (type: `integer`):

Use this to pace requests while fetching multi-page collections. Enter milliseconds such as 500; the default is 250 and the maximum is 10000. Increase it if the site begins rate limiting. This is not a delay per product record.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.sheffield-pottery.com/collections/all-products"
    }
  ],
  "maxResults": 20,
  "includeDescription": true,
  "includeVariants": true,
  "requestDelayMs": 250
}
```

# Actor output Schema

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

Structured catalog product records.

## `summary` (type: `string`):

Product and billing counts for the completed run.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.sheffield-pottery.com/collections/all-products"
        }
    ],
    "maxResults": 20,
    "includeDescription": true,
    "includeVariants": true,
    "requestDelayMs": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/sheffield-pottery-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 = {
    "startUrls": [{ "url": "https://www.sheffield-pottery.com/collections/all-products" }],
    "maxResults": 20,
    "includeDescription": True,
    "includeVariants": True,
    "requestDelayMs": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/sheffield-pottery-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 '{
  "startUrls": [
    {
      "url": "https://www.sheffield-pottery.com/collections/all-products"
    }
  ],
  "maxResults": 20,
  "includeDescription": true,
  "includeVariants": true,
  "requestDelayMs": 250
}' |
apify call muhammadafzal/sheffield-pottery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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