# Grainger Stock & Branch Availability (`axlymxp/grainger-stock-availability`) Actor

Check Grainger stock for your item numbers and US ZIP codes: ship status, units in the first shipment, delivery and backorder dates, plus pickup status and dates at the nearest Grainger branches. Built for procurement and supply monitoring. Pay only for results.

- **URL**: https://apify.com/axlymxp/grainger-stock-availability.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 dataset items

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

## Grainger Stock & Branch Availability

**Find out whether Grainger can deliver your parts — and when — before you place the order.** For every Grainger item number and US ZIP code you provide, get the shipping status, how many units come in the first shipment, the delivery date, the date the full quantity arrives if part is backordered, and the pickup status and date at the nearest Grainger branches.

No Grainger account, no browser automation and no proxy setup needed.

### Who uses it

- **Procurement & maintenance teams** — check a parts list against your site's ZIP code: what ships tomorrow, what can be picked up at the branch down the road, and what is backordered until next month.
- **Distributors, resellers & drop-shippers** — monitor Grainger's lead times and backorders for the SKUs you source or compete on, on a schedule.
- **Supply-chain analysts** — track regional availability and lead-time changes across ZIP codes over time.

### What you get (one row per item × ZIP code)

| Field | Type | Example |
|---|---|---|
| `sku` | string | `52RW10` |
| `zip_code` | string | `60601` |
| `quantity_requested` | integer | `500` |
| `ship_status` | string | `available`, `partial`, `backordered`, `unavailable` |
| `ship_quantity_available` | integer | `9` — units committed to the first shipment |
| `ship_date` | string | `2026-10-05` — first shipment arrives |
| `ship_complete_date` | string | `2026-10-30` — full quantity arrives |
| `ship_message` | string | `9 expected to arrive Mon. Oct 05. Balance expected to arrive by end of Oct, 2026.` |
| `drop_ship` | boolean | ships directly from the manufacturer |
| `ship_from_plant` | string | Grainger distribution center code |
| `branches_available_for_pickup` | integer | branches (of those reported) where pickup is available |
| `nearest_pickup_branch`, `nearest_pickup_date` | string | `139`, `2026-10-05` |
| `branches` | array | nearest branches with `branch_code`, `city`, `state`, `address`, `postal_code`, `distance_miles`, `phone`, `hours`, `curbside`, `pickup_status` (`available` / `backordered` / `unavailable`), `pickup_date`, `pickup_message` |
| `price`, `currency` | number, string | current web price (optional) |
| `name`, `brand`, `manufacturer_part_number` | string | product info (optional) |
| `url` | string | product page |
| `checked_at` | string | ISO-8601 UTC timestamp |

### Use cases

1. **Daily parts-availability check** — schedule a run every morning for your critical spares list and ZIP code; alert when `ship_status` turns `backordered`.
2. **Pick the fastest source** — compare `nearest_pickup_date` (will-call at a branch) with `ship_date` to decide between pickup and delivery.
3. **Multi-site procurement** — check the same SKU list against every plant's ZIP code in one run.
4. **Lead-time intelligence** — record `ship_complete_date` over time to see how Grainger's backorders evolve for a product line.

### Input

| Parameter | Description | Default |
|---|---|---|
| **Item numbers or product URLs** (required) | e.g. `1FEW8` or `https://www.grainger.com/product/…-1FEW8`. Checked 50 at a time. | — |
| **US ZIP codes** (required) | Every item is checked for every ZIP code. | — |
| **Quantity** | Quantity to check for every item. Statuses and dates are evaluated for this quantity. | 1 |
| **Include branch pickup status** | Add pickup status and dates at the nearest branches. | on |
| **Nearest branches per ZIP** | How many branches to report (1–12). | 5 |
| **Include web price** | Add the current web price. | on |
| **Include product name, brand and part number** | Extra product info. | off |

#### Example input

```json
{
    "skus": ["1FEW8", "52RW10", "https://www.grainger.com/product/ANSELL-Disposable-Gloves-Chemical-793JR4"],
    "zipCodes": ["60601", "77002"],
    "quantity": 2,
    "maxBranches": 3,
    "includePrice": true,
    "includeProductInfo": true
}
```

#### Example output

```json
{
    "sku": "52RW10",
    "zip_code": "60601",
    "quantity_requested": 500,
    "ship_status": "partial",
    "ship_quantity_available": 9,
    "ship_date": "2026-10-05",
    "ship_complete_date": "2026-10-30",
    "ship_message": "9 expected to arrive Mon. Oct 05. Balance expected to arrive by end of Oct, 2026.",
    "drop_ship": false,
    "ship_from_plant": "005",
    "branches_available_for_pickup": 0,
    "nearest_pickup_branch": null,
    "nearest_pickup_date": null,
    "branches": [
        {
            "branch_code": "139", "city": "Chicago", "state": "IL", "address": "2356 S Ashland Ave",
            "postal_code": "60608-5304", "distance_miles": 2.0, "phone": "1-800-472-4643",
            "hours": "7:00 AM - 4:00 PM Central", "curbside": true,
            "pickup_status": "backordered", "pickup_date": "2026-10-05",
            "pickup_message": "Backordered, available for pickup by end of Oct, 2026."
        }
    ],
    "price": 49.99,
    "currency": "USD",
    "name": null,
    "brand": null,
    "manufacturer_part_number": null,
    "url": "https://www.grainger.com/product/52RW10",
    "checked_at": "2026-10-02T06:30:00Z"
}
```

### Scheduling, webhooks and integrations

- **Schedule** runs from the *Schedules* tab (e.g. every weekday at 06:00) to monitor lead times.
- **Export** to JSON, CSV or Excel, or read results through the Apify API.
- **Integrate** with Google Sheets, Make, Zapier, Slack or a webhook — e.g. post to Slack when an item becomes `backordered`.

### Use with AI assistants (MCP)

Works with the [Apify MCP server](https://mcp.apify.com): ask Claude, ChatGPT or Cursor *"Can I get 20 of Grainger 1FEW8 delivered to 60601 this week, or picked up nearby?"* and let the assistant run this Actor.

### FAQ

**Does it show how many units a branch has on the shelf?** No. Grainger only says whether the requested quantity can be picked up at a branch and when (`pickup_status`, `pickup_date`) — it does not publish branch shelf counts, so this Actor doesn't either.

**What is `ship_quantity_available`?** The number of units Grainger commits to the first shipment from the serving distribution center. It can be capped at the quantity you ask for, so it is not a warehouse stock count. When you request more than ships first, `ship_status` is `partial` and `ship_complete_date` tells you when the rest arrives.

**How fresh is it?** Every run asks Grainger live, at run time — exactly what a customer would see at that moment for that ZIP code.

**Which branches are reported?** The branches closest to each ZIP code (up to 12), ordered by distance; set how many with *Nearest branches per ZIP*.

**What about item numbers Grainger doesn't sell online?** They're skipped and listed in the run log.

**Is it legal?** The Actor reads publicly available availability information. You are responsible for using the data in line with Grainger's terms and applicable law.

**Need a feature or found a bug?** Open an issue on the Actor's *Issues* tab.

# Actor input Schema

## `skus` (type: `array`):

Grainger item numbers (e.g. 1FEW8) or product URLs (https://www.grainger.com/product/...-1FEW8). Checked 50 at a time.

## `zipCodes` (type: `array`):

Delivery / pickup locations to check. Each SKU is checked once per ZIP code.

## `quantity` (type: `integer`):

Quantity to check for every item. Ship and pickup status are evaluated for this quantity (e.g. a large quantity shows when the full amount arrives).

## `includeBranchPickup` (type: `boolean`):

Add pickup status (available / backordered) and pickup date at the nearest Grainger branches.

## `maxBranches` (type: `integer`):

How many of the closest Grainger branches to report (1–12).

## `includePrice` (type: `boolean`):

Add the current Grainger web price for each item.

## `includeProductInfo` (type: `boolean`):

Add name, brand and manufacturer part number (one extra lookup per 100 items).

## Actor input object example

```json
{
  "skus": [
    "1FEW8",
    "52RW10",
    "https://www.grainger.com/product/ANSELL-Disposable-Gloves-Chemical-793JR4"
  ],
  "zipCodes": [
    "60601",
    "77002",
    "90012"
  ],
  "quantity": 1,
  "includeBranchPickup": true,
  "maxBranches": 5,
  "includePrice": true,
  "includeProductInfo": false
}
```

# Actor output Schema

## `availability` (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 = {
    "skus": [
        "1FEW8",
        "52RW10"
    ],
    "zipCodes": [
        "60601"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/grainger-stock-availability").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 = {
    "skus": [
        "1FEW8",
        "52RW10",
    ],
    "zipCodes": ["60601"],
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/grainger-stock-availability").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 '{
  "skus": [
    "1FEW8",
    "52RW10"
  ],
  "zipCodes": [
    "60601"
  ]
}' |
apify call axlymxp/grainger-stock-availability --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axlymxp/grainger-stock-availability"
        }
    }
}
```

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/5gb9bOla97HFfBld6/builds/fxjEKeMqrVNdOkrL9/openapi.json