# 1st Phorm Product Scraper & Price Tracker (`superslowsloth/1stphorm-products`) Actor

1st Phorm scraper for 1stphorm.com (US): supplements, stacks and apparel, whole catalogue or any collection. One row per product: USD price range, price before markdown, discount percent, per-flavour and per-size stock and SKU, tags, photo, publish date. For supplement price and new-product alerts.

- **URL**: https://apify.com/superslowsloth/1stphorm-products.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.62 / 1,000 product scrapeds

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 1st Phorm Product Scraper & Price Tracker

A **1st Phorm scraper** and **1st Phorm price tracker** for
[1stphorm.com](https://1stphorm.com), the US supplement and apparel shop. Read
the whole catalogue or any collection (`products`, `amino-acids`, `collagen`,
`all-mens-apparel`) and get one flat row per product: the current price and its
range in **USD**, the price before markdown, the largest discount in percent,
whether it is in stock and how many flavours or sizes are, and every variant
with its own SKU, price and stock flag. Run it on a schedule for **supplement
price and new-product alerts**: which protein, pre-workout or stack went on
sale since yesterday, by how much, which new flavours went live this week, and
which came back in stock.

No account, no API key, no login, no browser. One request returns up to 250
products; the whole catalogue (about 485 products on 2026-10-19) is two
requests.

### Input

| Field | Notes |
|---|---|
| `collections` | 1st Phorm collections to read instead of the whole catalogue, one per line: the name from the address bar (`products`, `amino-acids`, `collagen`, `all-mens-apparel`) or the link (`https://1stphorm.com/collections/amino-acids`). Each is read in the shop's own order. A product found by two collections is returned once, under the first. Leave empty to read the whole catalogue, newest first. A collection name the shop does not have fails at no charge. |
| `publishedAfter` | Only products that went live after this moment: `24 hours`, `7 days`, `2 weeks`, a date (`2026-10-01`) or a date-time (`2026-10-01T12:00:00Z`). On the whole catalogue the run stops at the first older product, since the feed is newest-published first. Leave empty for no cut-off. |
| `onlyOnSale` | Return only products where at least one variant is priced below its price before markdown (`on_sale`). Others are read, not returned and not charged, and do not count toward `maxItems`. |
| `maxItems` | Products to return per collection, or for the whole catalogue (default 250, up to 25,000). Up to 250 per page. |
| `proxyConfiguration` | Apify datacenter proxy by default. |

Example input, products that went live in the last week:

```json
{
  "publishedAfter": "7 days",
  "maxItems": 500
}
```

Example input, every reduced product:

```json
{
  "onlyOnSale": true,
  "maxItems": 1000
}
```

### Output

Prices are numbers in US dollars; `currency` is `USD` (the shop's own
`/meta.json` says so). A field the shop did not send is `null`, never `0` or `""`.

| Field | Notes |
|---|---|
| `query`, `position` | The shop URL (whole catalogue) or collection URL that first found the product, and its place in that list (1 is first). The whole catalogue is newest-published first. |
| `store` | `1stphorm.com`. |
| `product_id`, `handle`, `url` | Shopify's product id (a string), its URL handle, and the product link. |
| `title`, `vendor`, `product_type` | As the shop sends them. **`vendor` is not a brand on this shop**: 1st Phorm uses it as its own merchandising label (`Stack`, `CORE`, `Health & Wellness`, `Weight Loss`, `Black Friday 2025 Apparel`, `App Subscription`), kept as sent. Null when empty. |
| `tags` | The shop's own merchandising tags, as sent. Not a standard vocabulary. |
| `price`, `price_max` | The lowest and highest current variant price. They differ across sizes (a 1 lb and a 2 lb tub) and when only some variants are reduced. |
| `original_price`, `original_price_max` | The lowest and highest price **before markdown**: per variant its `compare_at_price` when that is above its price, otherwise its price. Equal to the current price when nothing is reduced. |
| `on_sale` | True when at least one variant's `compare_at_price` is above its price. |
| `discount_percent` | The largest reduction of any variant, `(1 - price / compare_at_price) * 100`, one decimal place. Worked out from the prices, not sent. **Null when nothing is reduced**, never 0. |
| `available`, `variant_count`, `available_variant_count` | Whether any variant can be bought now, how many variants there are (up to 72 on one product: flavour times size), and how many can be bought: the restock signal. |
| `option_names` | The product's options, e.g. `["Flavor", "Size"]`. |
| `variants` | Every variant: `variant_id`, `title`, `sku`, `price`, `compare_at_price` (null when the shop sends none), `available`, and `options` (the variant's values in `option_names` order). |
| `created_at`, `published_at`, `updated_at` | ISO 8601 times with the shop's offset. `published_at` is when the product went live, which is what `publishedAfter` reads. `updated_at` is rewritten in bulk, so it is not a price-change time. |
| `image_url`, `image_count` | The first photo on cdn.shopify.com, as sent (null when there is none), and how many photos there are. |

Example row (real values, 2026-10-19; `tags` and `variants` shortened here to
two and one entries):

```json
{
  "query": "https://1stphorm.com",
  "position": 3,
  "store": "1stphorm.com",
  "product_id": "8058531151958",
  "title": "Pumpkin Spice Combo Pack",
  "handle": "pumpkin-spice-combo-pack",
  "url": "https://1stphorm.com/products/pumpkin-spice-combo-pack",
  "vendor": "Stack",
  "product_type": "Products",
  "tags": [
    "food",
    "protein"
  ],
  "created_at": "2026-09-17T13:29:38-05:00",
  "published_at": "2026-09-28T13:32:44-05:00",
  "updated_at": "2026-10-18T14:49:42-05:00",
  "image_url": "https://cdn.shopify.com/s/files/1/0072/7754/3493/files/Level-1BarPumpkinSpiceCrunch2026-COMBO2_b750271e-0c3e-432a-8ed8-8182117d488d.png?v=1789669782",
  "image_count": 1,
  "currency": "USD",
  "price": 94.99,
  "price_max": 94.99,
  "original_price": 107.98,
  "original_price_max": 107.98,
  "on_sale": true,
  "discount_percent": 12.0,
  "available": true,
  "variant_count": 1,
  "available_variant_count": 1,
  "option_names": [
    "Title"
  ],
  "variants": [
    {
      "variant_id": "45781641494614",
      "title": "Default Title",
      "sku": "100255",
      "price": 94.99,
      "compare_at_price": 107.98,
      "available": true,
      "options": [
        "Default Title"
      ]
    }
  ]
}
```

#### Honest nulls

- **No ratings, reviews, nutrition facts or stock counts.** The catalogue feed
  carries none. `available` says a variant can be bought, nothing more.
- **`discount_percent` is null when nothing is reduced.** Most 1st Phorm
  variants carry no `compare_at_price` at all (2,228 of 2,947 on 2026-10-19);
  a `compare_at_price` equal to or below the price is not a reduction either.
- **Not every row is a physical product.** The feed carries app-access
  subscriptions (`1st Phorm App Access`) and gift cards; they are returned as
  sent, so filter on `product_type` or `vendor` if you only want supplements.

### Pricing

Pay per event:

- **$0.002** per run (`actor-start`), charged only after your input is
  validated, so a run that fails on bad input costs nothing.
- **$0.000616** per product row written (`product-scraped`), i.e. $0.62 per
  1,000 products. A row that is not written is not charged: rows filtered by
  `onlyOnSale` or `publishedAfter`, and repeats of a product another collection
  already returned, are free.

### How it fetches

It reads `/products.json`, the public catalogue feed every Shopify shop serves
(and `/collections/<name>/products.json` for a collection). Measured
2026-10-19: HTTP 200 JSON, about 2.8 MB per 250 products, no key or cookie
needed, open from datacenter and residential addresses. A refusal (403, 429,
430, 5xx), a 200 that is not the feed, or a dropped connection is treated as
the address being blocked, and the actor rotates to a fresh one and retries.

Things worth knowing, all measured:

- **A short page is not the end.** Page 1 held 249 products at a limit of 250
  and page 2 held 236. Only an empty page, HTTP 200 with `{"products":[]}`,
  ends the list, and that is where the actor stops.
- **Newest-published first.** Both pages of the whole catalogue are in
  `published_at` order, which is what makes `publishedAfter` stop early.
- **There is no `sale` collection.** `/collections/sale` is HTTP 404 on this
  shop, and `all` exists but is empty; use `onlyOnSale` for markdowns.
- **`www.1stphorm.com` redirects to `1stphorm.com`.** Links on either host are
  accepted as input; requests go to `1stphorm.com`.
- **An unknown collection looks empty.** The feed answers an unknown name with
  an empty list; the actor asks the collection's own record, and a name that
  does not exist fails instead of being reported as empty.

If 1st Phorm changes its feed, the run fails with a message instead of
returning empty rows.

# Actor input Schema

## `collections` (type: `array`):

1st Phorm collections to read instead of the whole catalogue, one per line: the name from the shop's address bar (products, amino-acids, collagen, all-mens-apparel) or the whole link (https://1stphorm.com/collections/amino-acids). A collection is in the shop's own order, not newest first, so Published after filters it without stopping early. Leave empty to read the whole catalogue, newest first (about 485 products). A collection the shop does not have fails at no charge.

## `publishedAfter` (type: `string`):

Return only products that went live on 1st Phorm after this moment: a span back from now (24 hours, 7 days, 2 weeks), a date (2026-10-01, midnight UTC) or a date-time (2026-10-01T12:00:00Z). This is the product's publish time (published_at). On the whole catalogue the run stops at the first older product, because the feed is newest-published first, so a new-flavour or new-product check is fast and cheap. Leave empty for no cut-off.

## `onlyOnSale` (type: `boolean`):

Return only products where at least one flavour, size or colour is priced below its price before markdown (the on_sale field). Other products are read but not returned, not charged, and do not count toward Max products.

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

Return at most this many products for the catalogue or for each collection. The feed holds 250 per page. Up to 25,000 are accepted, which is the most Shopify serves for any one list.

## `proxyConfiguration` (type: `object`):

Use Apify's automatic datacenter proxy (the default). A refused request is retried from a fresh address.

## Actor input object example

```json
{
  "collections": [],
  "onlyOnSale": false,
  "maxItems": 250,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (type: `string`):

No description

# 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 = {
    "collections": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/1stphorm-products").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 = {
    "collections": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/1stphorm-products").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "collections": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/1stphorm-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/1stphorm-products"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FqQM2YZXCzm7JliI0/builds/41ZkK3SBZcH7Lw9OE/openapi.json