# Gordon Food Service Product Catalog Scraper (`parseforge/gordon-food-service-catalog-scraper`) Actor

Scrapes product listings from any Gordon Food Service department or category page. Returns each product as a flat row with name, price, pack size, and availability.

- **URL**: https://apify.com/parseforge/gordon-food-service-catalog-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.57 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Gordon Food Service Product Catalog Scraper

**Scrape the Gordon Food Service product catalog from any department or category page, up to 10,000 items per run.** Every product row includes its name, price, pack size, and availability. No login required. Export to CSV, JSON, Excel, or XML.

Gordon Food Service lists thousands of foodservice products across dozens of departments, but browsing the GFS store manually makes price comparisons and catalog audits slow. This Actor reads the public product catalog directly from any category URL you give it. It returns a clean dataset you can filter, sort, and feed into your own tools.

| Who uses it | What they scrape Gordon Food Service for |
|---|---|
| Restaurant operators | Build a price book for weekly ordering across multiple GFS categories. |
| Foodservice distributors | Monitor GFS pricing and assortment to stay competitive in your local market. |
| Procurement analysts | Audit contracted pricing against the public GFS store catalog. |
| Menu planners | Pull ingredient specs and pack sizes for recipe costing and nutritional analysis. |

### What it does

This Actor collects product listings from a Gordon Food Service department or category page and returns each product as a flat row.

- 📦 **Full product row:** name, price, pack size, unit of measure, and stock status for every item on the page.
- 🔗 **Category-driven:** point the Actor at any department or subcategory URL and it paginates through all products.
- 🛑 **Max items control:** set a hard cap from 1 to 10,000 products so you only pull what you need.
- 📂 **Structured export:** download your dataset as CSV, JSON, Excel, or XML for direct use in spreadsheets and databases.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Gordon Food Service data

**📋 Build a master price book.**

A multi-unit restaurant group scrapes the Produce, Dairy, and Meat departments weekly to maintain an internal price book for store-level ordering.

**📊 Monitor competitor pricing.**

A regional foodservice distributor runs the Actor on key GFS categories each Monday to track price movements and adjust their own quotes.

**🧾 Audit contract compliance.**

A procurement analyst scrapes the catalog monthly and compares the public GFS prices against the contracted rates in their supply agreement.

**🍽️ Cost out new menu items.**

A menu planner pulls ingredient prices and pack sizes from multiple GFS categories to calculate plate costs before launching a seasonal menu.

### Why choose this scraper

|  | What you get |
|---|---|
| **No login or API key** | The Actor reads the public GFS store pages, so you start scraping immediately. |
| **Fixed flat schema** | Every product comes out with the same columns, ready for analysis with no cleanup. |
| **Paginates automatically** | It walks through every page of results behind the category URL until it hits your max items cap. |
| **Runs on Apify infrastructure** | Schedule it, run it from the API, or integrate it with hundreds of other apps via webhooks. |

### How it compares

No other Store actor targets Gordon Food Service the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Gordon Food Service Product Catalog Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Gordon Food Service changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from any Gordon Food Service department or category URL, and set a maximum product count so only the items you need reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "startUrl": "https://www.gfsstore.com/departments/Produce"
}
```

A larger pull:

```json
{
  "startUrl": "https://www.gfsstore.com/departments/Produce",
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.015 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.50 |
| 1,000 results | $15.00 |
| 10,000 results | $150.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Gordon Food Service Product Catalog Scraper](https://apify.com/parseforge/gordon-food-service-catalog-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Gordon Food Service through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/gordon-food-service-catalog-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that the startUrl points to a valid GFS department or category page with product listings. If the page is empty or the URL is a product detail page, the Actor will return nothing. Also verify that maxItems is set to 1 or higher.

**The Actor stops before reaching my maxItems limit.**

The category likely has fewer products than your maxItems value. The Actor stops when it exhausts all pages in the category. Try a broader department URL to capture more items.

**Some products are missing prices.**

GFS sometimes shows prices only after you select a store location or log in. The Actor scrapes what is publicly visible. If prices are hidden behind a location selector, those fields may be blank in your output.

**The run fails with a timeout error.**

Large categories with many pages can take time. Increase the run timeout in the Actor's advanced settings, or lower the maxItems value to reduce the number of pages the Actor must visit.

**My start URL redirects or shows an error.**

GFS may have changed their URL structure. Visit gfsstore.com in a browser, navigate to the category you want, and copy the current URL. Use that fresh URL as your startUrl.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Gordon Food Service account to scrape the catalog? | No. The Actor reads the publicly accessible GFS store pages. You do not need to log in or provide any credentials. |
| What data does each product row contain? | Each row includes the product name, price, pack size, unit of measure, and stock availability as displayed on the GFS store page. The exact fields are shown in the sample output on the Actor's page. |
| Can I scrape multiple categories in one run? | One run scrapes one start URL. To scrape multiple categories, run the Actor once per category URL, or use Apify's scheduler to run a sequence of calls with different start URLs. |
| How many products can I scrape? | You set the maximum with the maxItems input, up to 10,000 products per run. The Actor stops when it reaches that number or when the category has no more pages. |
| Does the Actor handle pagination? | Yes. It follows the next page links on the category page automatically until it collects the number of products you requested or reaches the end of the catalog. |
| What if a product is out of stock? | The Actor captures the stock status exactly as shown on the GFS store page. If the page says out of stock, that status appears in your dataset row. |
| Can I get product images or descriptions? | The Actor returns the data fields visible on the category listing page. If the listing includes a short description or image URL, those will appear in the output. Full product detail pages are not opened. |
| How do I find the right category URL to use? | Go to gfsstore.com, browse to the department or category you want, and copy the full URL from your browser's address bar. Paste it into the startUrl input field. |
| Can I schedule this Actor to run automatically? | Yes. Apify lets you schedule any Actor on a recurring basis, daily, weekly, or at any custom interval you choose. |
| What export formats are supported? | You can export your dataset in CSV, JSON, Excel, or XML format directly from the Apify console or via the API. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Gordon Food Service, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `startUrl` (type: `string`):

URL of the Gordon Food Service department or category page to scrape products from. Default is the Produce department.

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

Maximum number of products to scrape (default 100).

## Actor input object example

```json
{
  "startUrl": "https://www.gfsstore.com/departments/Produce",
  "maxItems": 100
}
```

# Actor output Schema

## `results` (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 = {
    "startUrl": "https://www.gfsstore.com/departments/Produce"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/gordon-food-service-catalog-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 = { "startUrl": "https://www.gfsstore.com/departments/Produce" }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/gordon-food-service-catalog-scraper").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 '{
  "startUrl": "https://www.gfsstore.com/departments/Produce"
}' |
apify call parseforge/gordon-food-service-catalog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/gordon-food-service-catalog-scraper"
        }
    }
}

```

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/ghmxX1svjyWiNpdRY/builds/fa7upR0ciVfHbV7ea/openapi.json