# Micro Center In-Store AI-Build Sniper (`pyralislabs/microcenter-ai-instore-sniper`) Actor

Scrape Micro Center for AI-optimized PC builds at your nearest store. Filters by budget, VRAM, NPU, and GPU brand. Returns complete builds with live prices, socket-matched parts, and open-box GPU deals.

- **URL**: https://apify.com/pyralislabs/microcenter-ai-instore-sniper.md
- **Developed by:** [PyralisLabs](https://apify.com/pyralislabs) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 ai build generateds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

## 🏬 Micro Center In-Store AI-Build Sniper

> **Find the cheapest AI-ready PC build at your local Micro Center — including open-box GPU deals you can pick up the same day.**

The **Micro Center In-Store AI-Build Sniper** is an Apify Actor that scrapes Micro Center search results for RTX 50-series GPUs, NPU-equipped CPUs, DDR5 RAM, NVMe SSDs, and socket-matched motherboards, then assembles complete builds tuned to your AI workload, your budget, and your nearest Micro Center store.

You give it a budget, an AI use case, and (optionally) a store ID. It returns up to 5 ready-to-buy build configurations with live prices, links, VRAM verification, and budget math — plus a list of open-box GPU deals if you opt in. Output is structured JSON ready for any AI agent or workflow.

> 🤝 **Companion Actor:** [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper) — use Newegg for shipping nationwide, Micro Center for in-store pickup and open-box deals.

---

### 🤔 What is the Micro Center In-Store AI-Build Sniper?

The Micro Center In-Store AI-Build Sniper is a specialized Apify Actor for the United States buyer who lives within driving distance of a Micro Center store. Most of Micro Center's best deals — open-box GPUs, store-exclusive bundles, in-store pickup pricing — are reserved for in-person buyers. This actor surfaces those deals automatically and assembles them into AI-optimized PC builds based on VRAM, NPU TOPS, and DDR5 capacity.

It is built on Crawlee + Playwright with Apify Residential Proxy support, mirrors the same AI build logic as the [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper), and is callable as an MCP tool through the Apify MCP Server.

---

### ⚡ What can the Micro Center scraper do?

- 🛒 Search Micro Center for **GPUs, CPUs, RAM, SSDs, and motherboards** in a single run.
- 📍 **Echo `storeId` and expose store-verification metadata** so downstream agents can tell whether location-specific pricing is currently validated.
- 📦 **Search open-box GPU deals** and label each result with `open_box_source` so agents know whether it came from the validated open-box gaming query or a keyword fallback.
- 🎯 **Filter GPUs by VRAM, brand (NVIDIA / AMD / Intel Arc / ANY), and budget**, anchored on GDDR/HBM/VRAM markers so it does not confuse storage capacity for video memory.
- 🧠 **Filter CPUs by NPU class** — Intel Core Ultra or AMD Ryzen AI / Ryzen AI Max families when `includeNpu` is enabled.
- 🔌 **Match motherboards to CPU socket** — Intel LGA 1851 / Z890 boards stay paired with Intel CPUs, AM5 / X870 / B850 / B650 boards stay paired with AMD CPUs.
- 🛠️ **Assemble up to 5 distinct builds** in one run, each with total price, budget remaining, and within-budget flag.
- ⚠️ **Surface honest disclaimers** — every build includes an `incomplete_build_notice` reminding the user that PSU, CPU cooler, and case are excluded.
- 🤖 **Run agentically** — callable as an MCP tool via `mcp.apify.com` so AI agents in Cursor, Claude Desktop, and similar clients can invoke it directly.

---

### 📦 What data does this Micro Center scraper extract?

For each component the actor returns:

- 🏷️ Product **title** (full name from the Micro Center listing)
- 💰 Live **price** in USD
- 🔗 **Direct link** to the Micro Center product page
- 🆔 **SKU** (where extractable) for in-store inventory lookups
- 📦 **Availability text** (`availability`) from the listing card — in-stock / sold-out state at the selected store
- 🎮 **VRAM in GB** for GPUs
- 🔧 **Socket detection** for motherboards (Intel LGA 1851 / AMD AM5 / both)
- 🏭 **CPU brand** for socket pairing

For each assembled build:

- 🆔 A unique `build_id`, the optional `store_id`, and a timestamp
- 💵 `total_price`, `budget_remaining`, and `within_budget`
- ✅ An `ai_readiness` label
- 🧪 A `build_quality` label plus `components_filled` / `components_total`
- ⚠️ A `build_warnings` array if any component is missing
- 📝 An `incomplete_build_notice` listing the parts the user still needs to buy
- 🔍 `search_config` echoing your input
- 📊 `crawl_stats`, `store_verification`, and `output_schema_version`

For open-box deals:

- 🏷️ Product `name`, `price`, `link`, `stock` text, `deal_type: "open_box"`, and `open_box_source`

---

### 🎯 Use cases

- 🧑‍💻 **AI developers near a Micro Center** — drive to the store same-day with a verified part list instead of waiting on Newegg shipping.
- 💎 **Open-box GPU hunters** — auto-detect Founders Edition and partner-card GPUs returned to Micro Center at 30–50% off.
- 🏢 **Procurement for office hardware refreshes** — spec a fleet of identical Copilot+ PCs you can pick up at one of 25 store locations.
- 🤖 **Local LLM hobbyists** — find the cheapest path to a 24 GB or 32 GB VRAM rig at the store you can actually drive to today.
- 📊 **Comparison shoppers** — pair this actor with the [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper) and let an AI agent compare both retailers for the same budget.
- ⏰ **Scheduled deal monitoring** — run the actor on a daily Apify cron and pipe new open-box deals into Slack, Discord, or email.
- 🛎️ **AI agent tool calls** — let an autonomous Claude or GPT agent call this actor as an MCP tool when a user asks "Is there an open-box RTX 5080 in stock at Tustin this week?".

---

### ⏱️ What to expect from a run

- **Typical runtime: 1–3 minutes** with default input. The actor pins a single residential exit and clears Micro Center's anti-bot check once on a homepage warm-up, then reuses that warmed session for every search — this keeps the success rate high without re-paying the check on each request. A built-in time budget guarantees it always returns results well within the run limit.
- **Proxy:** runs use **Apify Residential proxy automatically** (Micro Center blocks datacenter IPs outright). Images, fonts, and media are never fetched, which keeps residential bandwidth to a few MB per run.
- **Typical cost:** ~$0.15 in PPE charges (3 builds) plus a small platform-usage passthrough (compute + a few MB of residential bandwidth — usually under $0.15).
- **"Found 0 products" lines are normal** for discontinued cards — the actor treats empty searches as valid answers and moves on without retrying.
- **`open_box_deals` is often empty.** Open-box stock turns over daily and the actor only emits items whose listing title actually says "open box" — it will never mislabel a new-condition product as a deal.
- **`within_budget: false` can appear with an explanatory warning** when live GPU street prices exceed the goal's GPU budget share — the actor relaxes the cap rather than returning nothing, and tells you so in `warnings`.
- Every run pushes **one dataset record per build** (`record_type: "build"`), one per open-box deal (`record_type: "open_box_deal"`), and a final **`run_summary` record** (config echo, store verification, warnings, crawl stats) — even a zero-build run produces the summary, so you always get a machine-readable answer.

---

### 🚀 How to use the Micro Center In-Store AI-Build Sniper

1. 📍 Find your nearest Micro Center in the [store ID lookup table](#-find-your-micro-center-store-id) below and copy the store ID.
2. Open the actor in the Apify Console (or call it via API / MCP).
3. 🏬 Set **Store ID** (e.g., `101` for Tustin CA, `115` for Brooklyn NY). Leave blank to search shippable inventory only.
4. 💵 Set your **Budget** (USD). $1,000–$2,500 is the sweet spot for in-store AI builds.
5. 🎯 Pick an **AI Goal** — LLM Training, Image Generation, Local Agent Hosting, or Gaming + AI Hybrid.
6. 🎮 Set **Min VRAM** (GB) — 16 for 7B models, 24 for 13B–30B, 32 for 70B+.
7. 🏷️ Pick a **Preferred GPU Brand** — NVIDIA (default), AMD, Intel, or ANY.
8. 🧠 Toggle **Include NPU** if you require NPU-equipped CPUs.
9. 📦 Toggle **Include Open Box** to scan the open-box section.
10. 🔢 Set **Max Build Options** (1–5).
11. 🌐 Leave **Proxy Configuration** as `{ "useApifyProxy": true }` — Apify Residential Proxy is strongly recommended.
12. ▶️ Run the actor. Builds and open-box deals appear in the dataset as structured JSON.

#### 📡 Calling via API

```bash
curl -X POST "https://api.apify.com/v2/acts/pyralislabs~microcenter-ai-instore-sniper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "storeId": "101",
    "budget": 2000,
    "aiGoal": "LOCAL_AGENT_HOSTING",
    "minVram": 24,
    "preferredGpuBrand": "NVIDIA",
    "includeNpu": true,
    "includeOpenBox": true,
    "maxBuildOptions": 3,
    "proxyConfiguration": { "useApifyProxy": true }
  }'
````

#### 🤖 Calling as an MCP tool

The actor is exposed through the [Apify MCP Server](https://mcp.apify.com). In Claude Desktop, Cursor, or any MCP-compatible client connected to `mcp.apify.com`, an agent can discover the actor with `search-actors microcenter-ai-instore-sniper` and invoke it like any other tool. The output JSON structure is identical to the [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper), so an AI agent can request builds from both retailers and compare them in a single turn.

***

### ⚙️ Input parameters

| Field | Type | Required | Default | Description |
| :--- | :--- | :--- | :--- | :--- |
| `storeId` | string | ⬜ | `""` | Micro Center store ID — see lookup table below. Blank = shippable items only. |
| `budget` | integer | ✅ | 2000 | Total target price in USD. Minimum $600. |
| `aiGoal` | enum | ⬜ | `LOCAL_AGENT_HOSTING` | One of `LLM_TRAINING`, `IMAGE_GENERATION`, `LOCAL_AGENT_HOSTING`, `GAMING_AI_HYBRID`. |
| `minVram` | integer | ⬜ | 16 | Minimum GPU VRAM in GB. |
| `preferredGpuBrand` | enum | ⬜ | `NVIDIA` | One of `NVIDIA`, `AMD`, `INTEL`, `ANY`. |
| `includeNpu` | boolean | ⬜ | `true` | Require 50+ TOPS NPU CPUs. |
| `includeOpenBox` | boolean | ⬜ | `true` | Search Micro Center's open-box section for GPU deals. |
| `maxBuildOptions` | integer | ⬜ | 3 | Number of build variations to return (1–5). |
| `proxyConfiguration` | object | ✅ | `{ "useApifyProxy": true }` | Apify Residential Proxy strongly recommended. |

The full input schema lives in [`.actor/input_schema.json`](./.actor/input_schema.json) and is rendered as a form in the Apify Console.

***

### 📤 Output example

Each build is its own dataset record (`record_type: "build"` — easy to filter, export as CSV rows, or consume one at a time), each open-box deal is a `record_type: "open_box_deal"` record, and the run ends with a single `record_type: "run_summary"` record. The example below shows the legacy combined view of the same fields — in the dataset, `builds[i]` entries appear as individual records and the remaining top-level fields form the summary record:

```json
{
  "search_config": {
    "store_id": "101",
    "budget": 2000,
    "ai_goal": "LOCAL_AGENT_HOSTING",
    "min_vram": 16,
    "gpu_brand": "NVIDIA",
    "include_npu": true,
    "include_open_box": true
  },
  "builds": [
    {
      "build_id": "MC-LOCAL_AGENT_HOSTING-1711478400000-1-RTX508016GB",
      "ai_goal": "LOCAL_AGENT_HOSTING",
      "store_id": "101",
      "total_price": 1849.99,
      "budget_remaining": 150.01,
      "within_budget": true,
      "components": {
        "gpu": {
          "name": "NVIDIA GeForce RTX 5080 16GB",
          "price": 999.99,
          "link": "https://www.microcenter.com/...",
          "vram_gb": 16
        },
        "cpu": { "name": "Intel Core Ultra 9 385", "price": 549.99, "link": "https://www.microcenter.com/..." },
        "ram": { "name": "G.SKILL DDR5 32GB", "price": 149.99, "link": "https://www.microcenter.com/..." },
        "ssd": { "name": "Samsung 990 EVO Plus 2TB NVMe", "price": 199.99, "link": "https://www.microcenter.com/..." },
        "motherboard": { "name": "ASUS ROG Z890-E LGA 1851", "price": 349.99, "link": "https://www.microcenter.com/..." }
      },
      "ai_readiness": "7B Ready",
      "build_quality": "complete",
      "components_filled": 5,
      "components_total": 5,
      "build_warnings": [],
      "incomplete_build_notice": "Build excludes PSU (~$100-$300), CPU cooler (~$50-$200), and case (~$80-$250). Budget accordingly.",
      "timestamp": "2026-03-27T12:00:00.000Z"
    }
  ],
  "open_box_deals": [
    {
      "name": "RTX 5080 Founders Edition - Open Box",
      "price": 699.99,
      "link": "https://www.microcenter.com/...",
      "stock": "In Stock at Tustin",
      "deal_type": "open_box",
      "open_box_source": "facet"
    }
  ],
  "store_verification": {
    "cookie_set": true,
    "cookie_name": "storeSelected",
    "prices_localized": "unverified"
  },
  "total_results": 1,
  "warnings": [
    "Validated store cookies applied: 'storeSelected=101' and 'myStore=true'. Store selection is localized, but price deltas across the same SKU/store pair are still marked unverified until broader cross-store comparison is completed."
  ],
  "crawl_stats": {
    "requests_finished": 11,
    "requests_failed": 0,
    "requests_retried": 1,
    "requests_total": 11,
    "runtime_seconds": 48
  },
  "output_schema_version": "1.1.0"
}
```

You can download the full dataset in **JSON, CSV, HTML, or Excel** from the dataset tab after any run.

***

### 💰 Pricing

#### How much does it cost to scrape Micro Center?

This actor uses **Pay-per-Event (PPE)** pricing, billed only for the value it actually delivers. You are never charged for failed runs or zero-result runs.

| Event | When it fires | Price (USD) |
| :--- | :--- | :--- |
| 🏗️ `build-generated` | Each complete or partial build pushed to the dataset | **$0.05** |

Notes on cost:

- 💸 A typical run with `maxBuildOptions: 3` costs **$0.15** in PPE charges plus a few cents of Apify compute and proxy usage.
- ✅ Failed runs and runs that return zero builds are **not charged**.
- 🤝 Apify takes 20% as platform revenue share; the developer keeps 80%.
- 🌐 Apify Residential Proxy usage is billed separately by Apify per their proxy pricing.
- 📦 Open-box deals are returned at no additional charge in the current pricing tier.

***

### 📍 Find your Micro Center store ID

Micro Center currently exposes 30 US stores in the live store picker. The actor accepts the numeric store ID and pads it to the zero-prefixed cookie value Micro Center uses internally.

| Store ID | Location |
| :--- | :--- |
| 205 | 🌵 Phoenix, AZ |
| 195 | 💻 Santa Clara, CA |
| 101 | 🌴 Tustin, CA |
| 181 | 🏔️ Denver, CO |
| 185 | 🌴 Miami, FL |
| 065 | 🍑 Duluth, GA |
| 041 | 🍑 Marietta, GA |
| 151 | 🌆 Chicago, IL |
| 025 | 🌬️ Westmont, IL |
| 165 | 🏁 Indianapolis, IN |
| 191 | 🌾 Overland Park, KS |
| 121 | 🎓 Cambridge, MA |
| 085 | 🌉 Rockville, MD |
| 125 | 🦀 Parkville, MD |
| 055 | 🚗 Madison Heights, MI |
| 045 | ❄️ St. Louis Park, MN |
| 095 | 🎵 Brentwood, MO |
| 175 | 🏦 Charlotte, NC |
| 075 | 🛣️ North Jersey, NJ |
| 171 | 🌴 Westbury, NY |
| 115 | 🗽 Brooklyn, NY |
| 145 | 🏙️ Flushing, NY |
| 105 | 🏢 Yonkers, NY |
| 141 | 🌰 Columbus, OH |
| 051 | 🌰 Mayfield Heights, OH |
| 071 | 🌰 Sharonville, OH |
| 061 | 🌆 St. Davids, PA |
| 155 | 🤠 Houston, TX |
| 131 | 🤠 Dallas, TX |
| 081 | 🏛️ Fairfax, VA |

If you do not live within driving distance of one of these stores, use the [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper) instead — Newegg ships nationwide.

***

### ❓ Frequently asked questions

#### Do I need to provide a store ID?

No, but it is strongly recommended. Without a `storeId`, Micro Center will return shippable inventory only — and many of the best Micro Center deals (open-box, store exclusives) are pickup-only. The actor will warn you if you run it without a store ID.

#### Does the store ID actually change the prices I see?

The actor now applies the validated Micro Center store cookies `storeSelected=<zero-padded storeId>` and `myStore=true` before navigation. It still reports `store_verification.prices_localized: "unverified"` because same-SKU price/stock comparisons across multiple store IDs have not yet been exhaustively rechecked.

#### Why does open-box sometimes return non-GPU items?

The actor now uses Micro Center's validated open-box gaming query first and marks those results with `open_box_source: "facet"`. If that query returns zero GPU deals for your target, it falls back to a keyword search and marks those entries as `open_box_source: "keyword_fallback"`. You should still inspect the returned titles before automated purchasing decisions.

#### Does the actor work without Apify Proxy?

Micro Center returns 403 on several search URLs (notably AMD and AM5 motherboard searches) when called from a residential or unfamiliar IP. **Always use Apify Residential Proxy in production**, especially if you target AMD components.

#### Why does a build sometimes exceed the usual GPU budget ratio?

Each AI goal targets a GPU share of your budget (55–65%). When Micro Center's live GPU prices exceed that share — common with RTX 50-series street pricing — the actor relaxes the cap toward your full budget instead of returning zero builds, and tells you so in `warnings`. Check `budget_remaining` and `within_budget` before buying.

#### Can an AI agent call this actor?

Yes — the actor is callable as an MCP tool through the [Apify MCP Server](https://mcp.apify.com). The output JSON is identical to the [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper), making it easy to compare both retailers in a single agent turn.

#### What about PSU, case, and cooler?

Excluded by design. Every build includes an `incomplete_build_notice` field reminding you to budget ~$230–$750 extra for a PSU, CPU cooler, and case.

#### My city does not have a Micro Center — can I still use this actor?

Technically yes (with a blank `storeId`), but most of the in-store value will be hidden from you. If shipping to your address is the priority, use the [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper) instead.

#### Is it legal to scrape Micro Center?

This actor loads public Micro Center search pages exactly as a browser would. It does not log in, bypass paywalls, access any private or authenticated API, or collect personal data. All scraped information is publicly visible to any visitor. Use it for personal research and purchasing decisions at reasonable run frequencies.

***

### 🛠️ Troubleshooting

| Issue | Solution |
| :--- | :--- |
| 🚫 `total_results: 0` with AMD selected | Micro Center frequently 403s on AMD search URLs without a residential proxy. Ensure `proxyConfiguration.useApifyProxy: true` and re-run. |
| 📦 Open-box deals look wrong | Check `open_box_source`. `facet` means the validated open-box gaming query matched; `keyword_fallback` means the fallback search had to be used. Filter downstream by the exact GPU family you requested. |
| 🔁 Different store IDs return identical prices | Store selection cookies are now validated, but `store_verification.prices_localized` remains `unverified` until more same-SKU cross-store comparisons are logged. File an issue with two `(storeId, sku)` examples that should differ. |
| 💸 `within_budget: false` even at $4,000 budget | Try `aiGoal: "LOCAL_AGENT_HOSTING"` to relax the GPU budget ratio. |
| 🧱 Selectors broken after a Micro Center redesign | Report it on the **Issues** tab of this actor's Apify Store page — selector fixes ship within days. |

***

### 🆚 Newegg Sniper vs Micro Center Sniper — which one?

| Use case | Newegg Sniper | Micro Center Sniper |
| :--- | :---: | :---: |
| Fastest delivery to my address | ✅ | ❌ (most stock is pickup-only) |
| Live near one of the 25 US Micro Center stores, willing to drive | ➖ | ✅ |
| Open-box / clearance GPU deals | ❌ | ✅ |
| Nationwide availability, 24/7 | ✅ | ❌ |
| Component ratings & review counts | ✅ | ➖ |
| Store-level stock + SKU for pickup | ❌ | ✅ |
| Cross-retailer price comparison | run both — identical output schema | run both — identical output schema |

***

### 🔗 Related Apify Actors by PyralisLabs

- 🧠 [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper) — same AI build intelligence for nationwide shipping.
- ⚖️ [OSHA Inspections, Violations & Penalty Screener](https://apify.com/pyralislabs/osha-violations-penalty-screener) — screen any US company's workplace safety record with citation-level violation detail.

More AI hardware and procurement actors are on the PyralisLabs roadmap. Watch the org's Apify Store profile.

***

### 📜 Disclaimers and support

- 🔓 This actor scrapes **public** Micro Center search pages. It does not log in, bypass paywalls, or scrape personal data.
- ™️ "Micro Center" and related branding belong to Micro Center Computers, Inc. This actor is not affiliated with, endorsed by, or sponsored by Micro Center.
- 💱 Component prices and store inventory change minute by minute. Always verify the final price and stock at your local store before driving over.
- 📦 Open-box detection is best-effort and may include adjacent or non-GPU items in edge cases.
- 🇺🇸 The actor currently supports the 25+ US Micro Center retail locations and is not intended for international users.
- 📩 For bugs, feature requests, and selector breakage reports, use the **Issues** tab on this actor's Apify Store page or contact `dev@pyralislabs.io`.

***

### 📚 Resources and further reading

- 🧠 [Newegg AI-Build Sniper](https://apify.com/pyralislabs/newegg-ai-build-sniper) — companion actor for nationwide shipping.
- 💳 [Apify Pay-per-Event docs](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing-model)
- 🌐 [Apify MCP Server](https://mcp.apify.com) — call this actor from Claude Desktop, Cursor, or any MCP-compatible client.
- 🕷️ [Crawlee documentation](https://crawlee.dev) — the scraping framework powering the actor.

# Actor input Schema

## `storeId` (type: `string`):

Store ID for location-specific pricing and inventory. Examples: 141=Tustin CA, 101=Brooklyn NY, 125=Atlanta GA, 151=St. Louis MO. Leave blank for shippable items only.

## `budget` (type: `integer`):

Your target price. In-store AI-Ready builds typically start at $1,000.

## `aiGoal` (type: `string`):

Determines whether to prioritize VRAM (LLMs) or NPU TOPS (Local Copilots).

## `minVram` (type: `integer`):

Critical for 2026 models. 16GB is the baseline for 7B models; 32GB+ for 30B+ models.

## `preferredGpuBrand` (type: `string`):

NVIDIA is recommended for CUDA compatibility in 2026.

## `includeNpu` (type: `boolean`):

If true, will only select CPUs with 50+ TOPS (e.g., Ryzen 10000 or Core Ultra Series 3).

## `includeOpenBox` (type: `boolean`):

If true, searches Micro Center's open box section for 30-50% off MSRP deals.

## `maxBuildOptions` (type: `integer`):

How many different hardware configurations to return.

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

Residential proxy is required in production — both retailers hard-block datacenter IPs with 403s. If omitted or left on automatic groups, the actor forces Apify Residential (US) automatically. Local runs without proxy input use your own IP.

## Actor input object example

```json
{
  "storeId": "",
  "budget": 2000,
  "aiGoal": "LOCAL_AGENT_HOSTING",
  "minVram": 16,
  "preferredGpuBrand": "NVIDIA",
  "includeNpu": true,
  "includeOpenBox": true,
  "maxBuildOptions": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset records: record\_type = 'build' | 'open\_box\_deal' | 'run\_summary' | 'error'.

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

// Run the Actor and wait for it to finish
const run = await client.actor("pyralislabs/microcenter-ai-instore-sniper").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 = {
    "budget": 2000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("pyralislabs/microcenter-ai-instore-sniper").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 '{
  "budget": 2000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call pyralislabs/microcenter-ai-instore-sniper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=pyralislabs/microcenter-ai-instore-sniper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Micro Center In-Store AI-Build Sniper",
        "description": "Scrape Micro Center for AI-optimized PC builds at your nearest store. Filters by budget, VRAM, NPU, and GPU brand. Returns complete builds with live prices, socket-matched parts, and open-box GPU deals.",
        "version": "1.8",
        "x-build-id": "aetn1qY2ozsJdLmIx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pyralislabs~microcenter-ai-instore-sniper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pyralislabs-microcenter-ai-instore-sniper",
                "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/pyralislabs~microcenter-ai-instore-sniper/runs": {
            "post": {
                "operationId": "runs-sync-pyralislabs-microcenter-ai-instore-sniper",
                "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/pyralislabs~microcenter-ai-instore-sniper/run-sync": {
            "post": {
                "operationId": "run-sync-pyralislabs-microcenter-ai-instore-sniper",
                "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": [
                    "budget"
                ],
                "properties": {
                    "storeId": {
                        "title": "Micro Center Store ID",
                        "type": "string",
                        "description": "Store ID for location-specific pricing and inventory. Examples: 141=Tustin CA, 101=Brooklyn NY, 125=Atlanta GA, 151=St. Louis MO. Leave blank for shippable items only.",
                        "default": ""
                    },
                    "budget": {
                        "title": "Total Budget (USD)",
                        "minimum": 600,
                        "type": "integer",
                        "description": "Your target price. In-store AI-Ready builds typically start at $1,000.",
                        "default": 2000
                    },
                    "aiGoal": {
                        "title": "Primary AI Use Case",
                        "enum": [
                            "LLM_TRAINING",
                            "IMAGE_GENERATION",
                            "LOCAL_AGENT_HOSTING",
                            "GAMING_AI_HYBRID"
                        ],
                        "type": "string",
                        "description": "Determines whether to prioritize VRAM (LLMs) or NPU TOPS (Local Copilots).",
                        "default": "LOCAL_AGENT_HOSTING"
                    },
                    "minVram": {
                        "title": "Minimum VRAM (GB)",
                        "minimum": 8,
                        "type": "integer",
                        "description": "Critical for 2026 models. 16GB is the baseline for 7B models; 32GB+ for 30B+ models.",
                        "default": 16
                    },
                    "preferredGpuBrand": {
                        "title": "Preferred GPU Brand",
                        "enum": [
                            "NVIDIA",
                            "AMD",
                            "INTEL",
                            "ANY"
                        ],
                        "type": "string",
                        "description": "NVIDIA is recommended for CUDA compatibility in 2026.",
                        "default": "NVIDIA"
                    },
                    "includeNpu": {
                        "title": "Require Dedicated NPU?",
                        "type": "boolean",
                        "description": "If true, will only select CPUs with 50+ TOPS (e.g., Ryzen 10000 or Core Ultra Series 3).",
                        "default": true
                    },
                    "includeOpenBox": {
                        "title": "Include Open Box Deals?",
                        "type": "boolean",
                        "description": "If true, searches Micro Center's open box section for 30-50% off MSRP deals.",
                        "default": true
                    },
                    "maxBuildOptions": {
                        "title": "Number of Build Variations",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many different hardware configurations to return.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is required in production — both retailers hard-block datacenter IPs with 403s. If omitted or left on automatic groups, the actor forces Apify Residential (US) automatically. Local runs without proxy input use your own IP."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```