# Sprouts Farmers Market Store Hours & Address Scraper (`datacach/sprouts-farmers-market-store-hours-scraper`) Actor

Scrape Sprouts Farmers Market store hours, address, phone number, and GPS coordinates from any store page URL. Export store data to JSON, CSV, or Excel. Fast HTTP scraping — no browser or proxy needed.

- **URL**: https://apify.com/datacach/sprouts-farmers-market-store-hours-scraper.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 stores

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Sprouts Farmers Market Store Hours & Address Scraper

**Scrape Sprouts Farmers Market store hours, addresses, phone numbers, and GPS coordinates** — plus **Google Place IDs**, in-store services, and delivery/pickup availability — from any [Sprouts store page](https://www.sprouts.com/stores/) URL. No browser, no proxies to configure, and no coding required: paste a list of store URLs, click **Start**, and export clean structured **JSON, CSV, or Excel** data.

> ⚠️ **Free vs. Premium in one line:** free Apify accounts scrape only the **first 5 store URLs** per run; **paid accounts have no limit**. [Full details below](#free-vs-premium-how-many-sprouts-stores-can-i-scrape-per-run).

### What is Sprouts Farmers Market Store Hours & Address Scraper?

Sprouts Farmers Market Store Hours & Address Scraper is a fast, lightweight **web scraping API** for Sprouts store pages. Give it one or more `sprouts.com/store/...` URLs and it returns one structured record per store — **store name and number**, full **street address**, **phone number**, **latitude/longitude**, **Google Place ID**, **opening hours** (both human-readable and machine-readable), in-store services, delivery/pickup availability, nearby stores, and whether the location is currently open or an announced upcoming opening.

It uses **plain HTTP requests — no headless browser and no proxy** — so runs are fast and cheap in **compute units**.

This Actor is the **enrichment / detail step**, not the **discovery step** — it expects you to already have store URLs. Pair it with the **Sprouts Farmers Market Store Locator Scraper** (or your own list of URLs) to first collect the links, then feed them into this Actor to enrich every one with full store details.

### What can Sprouts Farmers Market Store Hours & Address Scraper do?

- 🏬 **Extract full store metadata** for any Sprouts store page: store name, store number, address, phone, geolocation, hours, and opening status
- 📍 **Google Place ID and Maps link** for every store — a ready-made **join key** onto Google Places / Google Maps data, with no fuzzy address matching
- 🕰️ **Machine-readable hours** — opening and closing times in 24-hour form plus a schema.org `openingHoursSpecification` block, alongside the raw display string
- 🛒 **In-store services and fulfillment flags** — Beer & Wine, Spirits, Fresh Sushi, Sandwich Bar, deli brand, and more, plus `has_delivery` and `has_pickup`
- 🧭 **Nearby stores** with distances in miles, straight from each store page
- 🔗 **Bulk input** — paste any number of store URLs at once and have them processed concurrently (subject to the free-plan cap below)
- ⚡ **No browser and no proxy needed** — plain HTTP scraping keeps runs quick and inexpensive in compute units
- 🕒 **Extraction timestamps** — every record is stamped with the exact UTC date and time it was scraped, so you can track data freshness across repeated runs
- 🎛️ **Configurable concurrency** — tune how many store pages are fetched in parallel to balance speed against rate-limiting risk
- 📤 **Export to JSON, CSV, Excel, HTML, or XML** directly from the Apify platform
- ☁️ **Run on the Apify platform** with built-in **scheduling**, **API access**, **webhooks**, **monitoring**, **proxy rotation**, and **Zapier / Make integrations** — no infrastructure to manage

### Free vs. Premium: how many Sprouts stores can I scrape per run?

This Actor applies a **usage limit based on your Apify account plan**. It is checked **automatically at run time** (via the Apify run environment) — it is **not** an input field, and you cannot configure, raise, or disable it yourself.

| | **Free Apify plan** | **Paid (Premium) Apify plan** |
|---|---|---|
| Store URLs processed per run | ⛔ **Only the first 5** URLs from `links` | ✅ **No cap** — every URL you provide |
| Extra URLs beyond the cap | Silently skipped for that run | n/a |
| User-configurable? | ❌ No — enforced in code at run time | ❌ No cap to configure |
| All output fields available? | ✅ Yes — identical data per store | ✅ Yes |

**What this means in practice:**

- 🆓 **Free-plan accounts** — each run processes **only the first 5 URLs** from the `links` input, no matter how many you paste in. Duplicate URLs are removed first, then the list is truncated to 5. The run log prints a warning (`Free plan detected — limiting to the first 5 links (stores)`) so you can confirm this is what happened.
- 💳 **Paid Apify accounts** — **no limit is applied**. Every URL in `links` is processed in the same run, so you can enrich hundreds or thousands of Sprouts stores in a single go.
- ❓ **If the plan cannot be verified** (a rare platform hiccup), the Actor fails safe and applies the free-plan 5-URL cap for that run.

If you are on a free plan and your list has more than 5 URLs, either **split the work across multiple runs** (5 URLs at a time) or **upgrade your Apify plan** to process the full list in one run. Everything else about the Actor — every output field, every service flag, the Google Place ID, the hours — is identical on both plans.

### What data does Sprouts Farmers Market Store Hours & Address Scraper extract?

| Field | Description |
|---|---|
| `url` | The Sprouts store page URL that was scraped |
| `name` | Brand name — always `"Sprouts Farmers Market"` |
| `store_name` | The location's own name (e.g. `"Birmingham"`, `"San Diego - Genesee Ave."`) |
| `store_number` | Sprouts' internal store number (e.g. `"482"`) |
| `store_id` | Sprouts' internal page ID — a stable identifier that survives URL changes |
| `street` | Street address |
| `city` | City |
| `state` | State abbreviation (e.g. `"AL"`) |
| `state_name` | Full state name (e.g. `"Alabama"`) |
| `zipcode` | ZIP code |
| `shopping_center` | Shopping center name or cross street, when the store page lists one |
| `phone` | Store phone number, digits only (e.g. `"2052632808"`) |
| `phone_formatted` | Store phone number as displayed (e.g. `"205-263-2808"`) |
| `latitude` | Store latitude |
| `longitude` | Store longitude |
| `google_place_id` | **Google Places ID** for the store — a ready-made join key to Google Maps data |
| `google_maps_url` | Direct Google Maps link to the store |
| `store_status` | Lifecycle status from the store page: `"open"` or `"opening-soon"` |
| `opening_status` | `"open"` for operating stores, `"upcoming"` for announced-but-not-yet-open stores |
| `opening_date` | Announced opening date text for `"upcoming"` stores (empty for open stores) |
| `independently_operated` | `true` for franchise-style locations run by a third party |
| `hours_display` | Human-readable store hours (e.g. `"7:00AM -10:00PM"`) |
| `hours_open` | Opening time in 24-hour form (e.g. `"07:00"`) |
| `hours_close` | Closing time in 24-hour form (e.g. `"22:00"`) |
| `hours_raw` | schema.org `openingHoursSpecification` block covering all seven days |
| `services` | In-store services array (e.g. `["Beer & Wine", "Fresh Sushi", "Sandwich Bar"]`) |
| `has_delivery` | Whether the store offers delivery |
| `has_pickup` | Whether the store offers pickup |
| `nearby_stores` | Nearby Sprouts locations, each with `name`, `url`, and `distance_mi` |
| `page_last_modified` | When Sprouts last updated the store page — a freshness signal for diffing runs |
| `extraction_datetime` | UTC timestamp of when the record was extracted, in ISO-8601 format |
| `extraction_date` | Extraction date only, in `mm-dd-yyyy` format |

### How do I scrape Sprouts Farmers Market store hours and addresses?

1. **Get store URLs.** Run the **Sprouts Farmers Market Store Locator Scraper** first, or gather `https://www.sprouts.com/store/<state>/<city>/<street>/` URLs yourself.
2. **Open the Input tab** of this Actor and paste the URLs into the **Store page URLs** (`links`) field — one per line.
3. **Check your plan cap.** On a free Apify plan only the **first 5 URLs** will run — see [Free vs. Premium](#free-vs-premium-how-many-sprouts-stores-can-i-scrape-per-run).
4. **Adjust concurrency (optional).** `maxConcurrency` controls how many store pages are fetched in parallel — lower it if you see blocked requests, raise it for faster large batches.
5. **Click Start.** The Actor fetches each store page and pushes one structured item per store to the dataset.
6. **Export your data** from the Output tab as **JSON, CSV, Excel, HTML, or XML** — or pull it programmatically via the [Apify API](https://docs.apify.com/api/v2).

<!-- TODO: embed a demo video or GIF here on its own line, e.g. https://www.youtube.com/watch?v=VIDEO_ID -->

<!-- TODO: screenshot of the Input tab showing the `links` and `maxConcurrency` fields (alt text: "Sprouts Farmers Market store scraper input form on Apify") -->

### Input

The Actor accepts two input fields — see the **Input** tab for the full form:

- 🔗 **Store page URLs (`links`)** — *required.* An array of Sprouts store page URLs to extract details from, e.g. `https://www.sprouts.com/store/al/birmingham/us-hwy-280/`. One URL per line. Search pages, category pages, and non-Sprouts URLs are not supported. Duplicates are removed automatically, and each valid URL produces exactly one dataset item. These URLs are typically the output of the Sprouts store locator Actor.
- 🎛️ **Parallel requests (`maxConcurrency`)** — *optional.* How many store pages are fetched at the same time (`1`–`20`, default `5`). Higher values finish large batches faster but raise the risk of being rate-limited; lower values (2–3) are gentler and more reliable.

There is **no input field for the free-plan limit** — it is applied automatically from your account plan.

```json
{
    "links": [
        "https://www.sprouts.com/store/al/birmingham/us-hwy-280/",
        "https://www.sprouts.com/store/az/avondale/n-dysart-rd/"
    ],
    "maxConcurrency": 5
}
````

### Output example

Every dataset item looks like this:

```json
{
    "url": "https://www.sprouts.com/store/al/birmingham/us-hwy-280/",
    "name": "Sprouts Farmers Market",
    "store_name": "Birmingham",
    "store_number": "482",
    "store_id": "1165",
    "street": "5265 US Hwy. 280",
    "city": "Birmingham",
    "state": "AL",
    "state_name": "Alabama",
    "zipcode": "35242",
    "shopping_center": "Brook Highland Plaza",
    "phone": "2052632808",
    "phone_formatted": "205-263-2808",
    "latitude": 33.42011,
    "longitude": -86.683403,
    "google_place_id": "ChIJr1-uqEEWiYgRF55SyzAxecs",
    "google_maps_url": "https://www.google.com/maps/search/?api=1&query=33.42011%2C-86.683403&query_place_id=ChIJr1-uqEEWiYgRF55SyzAxecs",
    "store_status": "open",
    "opening_status": "open",
    "opening_date": "",
    "independently_operated": false,
    "hours_display": "7:00AM -10:00PM",
    "hours_open": "07:00",
    "hours_close": "22:00",
    "hours_raw": {
        "openingHoursSpecification": [
            {
                "@type": "OpeningHoursSpecification",
                "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"],
                "opens": "07:00",
                "closes": "22:00"
            }
        ]
    },
    "services": ["Beer & Wine", "Boars Head Premium Meats & Cheeses", "Deli Catering Trays", "Fresh Sushi", "Sandwich Bar"],
    "has_delivery": true,
    "has_pickup": true,
    "nearby_stores": [
        { "name": "Hoover", "url": "https://www.sprouts.com/store/al/hoover/medford-dr/", "distance_mi": 9.4 }
    ],
    "page_last_modified": "2024-10-31T09:25:20-07:00",
    "extraction_datetime": "2026-07-27T14:30:00.123456+00:00",
    "extraction_date": "07-27-2026"
}
```

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**.

### Use cases

- 🗺️ **Store locator enrichment** — turn a bare list of Sprouts store URLs into a full database of addresses, phone numbers, and coordinates for a store-finder map or app.
- 🔗 **Google Places reconciliation** — use `google_place_id` to match Sprouts locations against Google Maps reviews, ratings, and popular-times data without any fuzzy address matching.
- 🍣 **Service-level analysis** — segment stores by `services`, `has_delivery`, and `has_pickup` to see which locations carry sushi, beer & wine, or spirits, and which support online fulfillment.
- 🕰️ **Hours-aware apps and feeds** — publish accurate opening hours with `hours_open`/`hours_close`, or drop `hours_raw` straight into schema.org structured data on a location page.
- 📍 **Local SEO and directory listings** — keep a business directory or franchise-locator page in sync with accurate Sprouts store hours and addresses.
- 🏗️ **Market and expansion research** — track newly announced Sprouts locations via `opening_status: "upcoming"` and `opening_date`.
- 📈 **Competitive and retail analytics** — monitor store counts, geographic coverage, and operating hours across regions over time using `extraction_datetime` / `extraction_date` and `page_last_modified`.
- 🔌 **Data pipeline integration** — feed structured Sprouts store data into a CRM, BI tool, or internal database via the Apify API, webhooks, or scheduled exports.

### Sprouts Farmers Market-related Actors

| Actor | What it does |
|---|---|
| **Sprouts Farmers Market Store Locator Scraper** | 🔍 The **discovery step** — collects Sprouts store page URLs in bulk. Run it first, then feed its output into this Actor. |
| **Sprouts Farmers Market Store Hours & Address Scraper** *(this Actor)* | 🏬 The **enrichment step** — turns each store URL into a full store record with hours, address, phone, coordinates, Google Place ID, and services. |

### FAQ

#### How many Sprouts stores can I scrape on the free Apify plan?

**Five per run.** Free-plan accounts are capped at the **first 5 URLs** in the `links` input; the rest are skipped for that run. **Paid (Premium) Apify accounts have no cap** and process every URL you provide. The limit is enforced automatically at run time from your account plan — it is not an input you can change. See the [Free vs. Premium section](#free-vs-premium-how-many-sprouts-stores-can-i-scrape-per-run) for the full comparison.

#### Why does my run only return 5 results even though I provided more URLs?

You are on a free Apify plan. Look for the `Free plan detected — limiting to the first 5 links (stores)` warning in the run log to confirm. Either split your URLs across multiple runs (5 at a time) or upgrade to a paid Apify plan to remove the limit entirely.

#### Do free and paid plans get different data per store?

No. The **per-store output is identical** on both plans — same 30+ fields, same Google Place ID, same hours, same services. The only difference is **how many URLs** each run processes.

#### Where do I get Sprouts store URLs to scrape?

From the **Sprouts Farmers Market Store Locator Scraper**, which discovers store page URLs in bulk. You can also paste URLs you already have, as long as they follow the `https://www.sprouts.com/store/<state>/<city>/<street>/` pattern.

#### Is it legal to scrape Sprouts Farmers Market store pages?

This Actor only extracts data that is **publicly visible** on Sprouts store pages — the same information any visitor sees in their browser. Scraping publicly available data is generally permitted, but you are responsible for reviewing Sprouts' Terms of Service and applicable law before using the extracted data, especially for commercial purposes. No personal data is collected.

#### Does this Actor need proxies or a browser?

No. It uses lightweight **HTTP requests** instead of a headless browser, which makes runs faster and cheaper in compute units. If a request is blocked by anti-bot protection, that link is skipped and logged — the run only fails if **no** link succeeds. If you do hit blocks, lower `maxConcurrency` to 2–3, or enable Apify Proxy on the run.

#### What happens if a store URL fails or is blocked?

Failed or blocked links are skipped and logged with a warning; they do not stop the rest of the run. The Actor fails the whole run only if none of the provided links succeed.

#### Can I run this Sprouts scraper on a schedule?

Yes. Use Apify's built-in **Scheduler** to re-run this Actor automatically (daily, weekly, or on any cron expression) and keep store hours, opening status, and addresses up to date. The `extraction_datetime` / `extraction_date` fields on every item let you track exactly when each snapshot was taken.

#### Can I access this Actor via API?

Yes. Every Apify Actor, including this one, can be started and its results retrieved through the [Apify API](https://docs.apify.com/api/v2), and integrated with tools like **Zapier**, **Make**, webhooks, or your own backend in Python or JavaScript.

#### How do I export Sprouts store data to CSV or Excel?

Open the **Output** tab after a run and choose your format — JSON, CSV, Excel, HTML, or XML — or hit the dataset items endpoint of the Apify API with `?format=csv`.

### Support

Found a bug or have a feature request? Open an issue on this Actor's **Issues** tab in Apify Console — it is the fastest way to reach the maintainer. For custom scraping solutions, larger-scale integrations, or additional Sprouts data points, reach out via the Actor's contact details on Apify Store.

# Actor input Schema

## `links` (type: `array`):

One Sprouts Farmers Market store page URL per line, in the form <code>https://www.sprouts.com/store/\<state>/\<city>/\<street>/</code>. Examples: <code>https://www.sprouts.com/store/al/birmingham/us-hwy-280/</code> and <code>https://www.sprouts.com/store/az/avondale/n-dysart-rd/</code>. Search pages, category pages, or non-Sprouts URLs are not supported. Duplicate URLs are removed automatically, and each valid URL produces one dataset item. These URLs are typically the output of a Sprouts store locator Actor. <b>On the free plan only the first 5 URLs are scraped;</b> upgrade to a paid plan to scrape an unlimited number of stores per run.

## `maxConcurrency` (type: `integer`):

How many store pages are fetched at the same time (1–20, default 5). Higher values finish large batches faster but raise the risk of being rate-limited or blocked by sprouts.com; lower values are gentler and more reliable. Leave it at 5 unless you see blocked requests in the log, then lower it to 2–3.

## Actor input object example

```json
{
  "links": [
    "https://www.sprouts.com/store/al/birmingham/us-hwy-280/",
    "https://www.sprouts.com/store/az/avondale/n-dysart-rd/"
  ],
  "maxConcurrency": 5
}
```

# Actor output Schema

## `stores` (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 = {
    "links": [
        "https://www.sprouts.com/store/al/birmingham/us-hwy-280/",
        "https://www.sprouts.com/store/az/avondale/n-dysart-rd/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacach/sprouts-farmers-market-store-hours-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 = { "links": [
        "https://www.sprouts.com/store/al/birmingham/us-hwy-280/",
        "https://www.sprouts.com/store/az/avondale/n-dysart-rd/",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datacach/sprouts-farmers-market-store-hours-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 '{
  "links": [
    "https://www.sprouts.com/store/al/birmingham/us-hwy-280/",
    "https://www.sprouts.com/store/az/avondale/n-dysart-rd/"
  ]
}' |
apify call datacach/sprouts-farmers-market-store-hours-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datacach/sprouts-farmers-market-store-hours-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sprouts Farmers Market Store Hours & Address Scraper",
        "description": "Scrape Sprouts Farmers Market store hours, address, phone number, and GPS coordinates from any store page URL. Export store data to JSON, CSV, or Excel. Fast HTTP scraping — no browser or proxy needed.",
        "version": "0.0",
        "x-build-id": "AeFLv8jiXvaUf97hu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datacach~sprouts-farmers-market-store-hours-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datacach-sprouts-farmers-market-store-hours-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/datacach~sprouts-farmers-market-store-hours-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datacach-sprouts-farmers-market-store-hours-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/datacach~sprouts-farmers-market-store-hours-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datacach-sprouts-farmers-market-store-hours-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",
                "required": [
                    "links"
                ],
                "properties": {
                    "links": {
                        "title": "Store page URLs",
                        "type": "array",
                        "description": "One Sprouts Farmers Market store page URL per line, in the form <code>https://www.sprouts.com/store/&lt;state&gt;/&lt;city&gt;/&lt;street&gt;/</code>. Examples: <code>https://www.sprouts.com/store/al/birmingham/us-hwy-280/</code> and <code>https://www.sprouts.com/store/az/avondale/n-dysart-rd/</code>. Search pages, category pages, or non-Sprouts URLs are not supported. Duplicate URLs are removed automatically, and each valid URL produces one dataset item. These URLs are typically the output of a Sprouts store locator Actor. <b>On the free plan only the first 5 URLs are scraped;</b> upgrade to a paid plan to scrape an unlimited number of stores per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Parallel requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many store pages are fetched at the same time (1–20, default 5). Higher values finish large batches faster but raise the risk of being rate-limited or blocked by sprouts.com; lower values are gentler and more reliable. Leave it at 5 unless you see blocked requests in the log, then lower it to 2–3.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
