# Groupon Coupons Scraper (`crawlerbros/groupon-coupons-scraper`) Actor

Scrape Groupon Coupons - one of the largest coupon aggregators with 10,000+ brands. Fetch coupons by store name, browse by category, or get popular deals. Extracts coupon codes, discount values, verified status, usage counts, and more. No proxy required.

- **URL**: https://apify.com/crawlerbros/groupon-coupons-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 1 total users, 0 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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

## Groupon Coupons Scraper

Scrape coupon codes, promo deals, and discount offers from **Groupon Coupons** — one of the largest coupon aggregators in the US, featuring 10,000+ brands and stores.

### What You Can Scrape

- Coupon codes ready to use at checkout
- Deals and reward offers with no code required
- Discount value (%, $, free shipping, BOGO)
- Verified status — manually checked by Groupon editors
- Usage counts (how many people used a coupon today)
- Expiry information

### Modes

| Mode | Description |
|------|-------------|
| **byStore** | Fetch all coupons from one or more specific stores (e.g. amazon, nike, doordash) |
| **byCategory** | Browse coupons by category (electronics, travel, food-drink, etc.) |
| **popular** | Get today's popular and featured deals from the Groupon homepage |

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | Select | `byStore` / `byCategory` / `popular` |
| `storeNames` | String List | Store slugs to scrape (e.g. `amazon`, `nike`). Used in `byStore` mode. |
| `category` | Select | Category to browse. Used in `byCategory` mode. |
| `couponTypeFilter` | Select | Filter by type: Code, Deal, or Reward |
| `verifiedOnly` | Boolean | Only return Groupon-verified coupons |
| `maxItems` | Integer | Maximum coupons to return (1–500, default: 50) |

#### Store Slugs

Store slugs match the URL on Groupon: `https://www.groupon.com/coupons/<slug>`. Examples:

- `amazon` → amazon.com
- `nike` → Nike
- `target` → Target
- `doordash` → DoorDash
- `best-buy` → Best Buy
- `sams-club` → Sam's Club

#### Available Categories

`food-drink`, `attractions`, `entertainment`, `womens-clothing`, `mens-clothing`, `health-beauty`, `travel`, `gifts`, `electronics`, `sports-outdoors`, `home-garden`, `auto`, `department-stores`, `office-supplies`, `kids-baby`, `pets`, `seasonal`

### Output

Each record contains:

```json
{
  "couponId": "3468551",
  "storeName": "Amazon",
  "storeUrl": "https://www.groupon.com/coupons/amazon",
  "couponTitle": "30% Off Subscribe & Save with Amazon Promo Code",
  "couponDescription": "Subscribe for auto-delivery and save up to 30% off your next delivery.",
  "couponCode": "CLIPCOUPON",
  "couponType": "Code",
  "discountValue": "30% Off",
  "discountType": "Percent",
  "isVerified": true,
  "usedToday": 2881,
  "expiresAt": "2026-07-03T05:00:00.0000000Z",
  "url": "https://www.groupon.com/coupons/article/3468551",
  "sourceUrl": "https://www.groupon.com/coupons/amazon",
  "recordType": "coupon",
  "scrapedAt": "2026-06-30T10:00:00+00:00"
}
````

### Technical Details

- **No proxy required** — works on the free Apify plan with datacenter IPs
- **Memory**: 1024 MB
- **Anti-bot tier**: curl\_cffi Chrome 131 TLS impersonation (Tier 2)
- **Data source**: [groupon.com/coupons](https://www.groupon.com/coupons)

### FAQs

**Do I need a proxy or API key?**
No. This actor works without any proxy configuration or credentials on the free Apify plan.

**How many coupons can I get?**
Each store page typically has 10–50 active coupons. The `maxItems` limit caps total output.

**Are the coupon codes visible?**
Yes — Groupon shows coupon codes directly in the HTML (no click required to reveal them).

**How often are coupons updated?**
Groupon updates their coupons daily. Run this actor daily to get fresh data.

**What does `isVerified` mean?**
Groupon's editorial team manually tests and marks coupons as "Verified" when confirmed working.

**Can I scrape all stores?**
Use `byCategory` mode to get coupons from stores in a specific category, or use `popular` mode for trending deals. For specific stores, use `byStore` with a list of store slugs.

# Actor input Schema

## `mode` (type: `string`):

Choose how to scrape Groupon Coupons: by specific store names, by category, or popular/trending deals.

## `storeNames` (type: `array`):

List of store names or Groupon URL slugs to scrape (e.g. 'amazon', 'nike', 'doordash'). Used in byStore mode.

## `category` (type: `string`):

Category to browse for coupons. Used in byCategory mode.

## `couponTypeFilter` (type: `string`):

Only return coupons of this type. Leave blank to return all types.

## `verifiedOnly` (type: `boolean`):

When enabled, only return coupons marked as verified by Groupon editors.

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

Maximum number of coupon records to return (1–500).

## Actor input object example

```json
{
  "mode": "byStore",
  "storeNames": [
    "amazon",
    "walmart",
    "doordash",
    "nike",
    "target"
  ],
  "category": "electronics",
  "couponTypeFilter": "",
  "verifiedOnly": false,
  "maxItems": 20
}
```

# Actor output Schema

## `coupons` (type: `string`):

Dataset containing all scraped Groupon coupon records.

# 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 = {
    "mode": "byStore",
    "storeNames": [
        "amazon",
        "nike"
    ],
    "category": "electronics",
    "couponTypeFilter": "",
    "verifiedOnly": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/groupon-coupons-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 = {
    "mode": "byStore",
    "storeNames": [
        "amazon",
        "nike",
    ],
    "category": "electronics",
    "couponTypeFilter": "",
    "verifiedOnly": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/groupon-coupons-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 '{
  "mode": "byStore",
  "storeNames": [
    "amazon",
    "nike"
  ],
  "category": "electronics",
  "couponTypeFilter": "",
  "verifiedOnly": false,
  "maxItems": 20
}' |
apify call crawlerbros/groupon-coupons-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/groupon-coupons-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Groupon Coupons Scraper",
        "description": "Scrape Groupon Coupons - one of the largest coupon aggregators with 10,000+ brands. Fetch coupons by store name, browse by category, or get popular deals. Extracts coupon codes, discount values, verified status, usage counts, and more. No proxy required.",
        "version": "1.0",
        "x-build-id": "a0CXQ8GPVON2VlNQV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~groupon-coupons-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-groupon-coupons-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/crawlerbros~groupon-coupons-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-groupon-coupons-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/crawlerbros~groupon-coupons-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-groupon-coupons-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",
                "properties": {
                    "mode": {
                        "title": "Scraping mode",
                        "enum": [
                            "byStore",
                            "byCategory",
                            "popular"
                        ],
                        "type": "string",
                        "description": "Choose how to scrape Groupon Coupons: by specific store names, by category, or popular/trending deals.",
                        "default": "byStore"
                    },
                    "storeNames": {
                        "title": "Store names or slugs",
                        "type": "array",
                        "description": "List of store names or Groupon URL slugs to scrape (e.g. 'amazon', 'nike', 'doordash'). Used in byStore mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "food-drink",
                            "attractions",
                            "entertainment",
                            "womens-clothing",
                            "mens-clothing",
                            "health-beauty",
                            "travel",
                            "gifts",
                            "electronics",
                            "sports-outdoors",
                            "home-garden",
                            "auto",
                            "department-stores",
                            "office-supplies",
                            "kids-baby",
                            "pets",
                            "seasonal"
                        ],
                        "type": "string",
                        "description": "Category to browse for coupons. Used in byCategory mode.",
                        "default": "electronics"
                    },
                    "couponTypeFilter": {
                        "title": "Coupon type filter",
                        "enum": [
                            "",
                            "Code",
                            "Deal",
                            "Reward"
                        ],
                        "type": "string",
                        "description": "Only return coupons of this type. Leave blank to return all types.",
                        "default": ""
                    },
                    "verifiedOnly": {
                        "title": "Verified only",
                        "type": "boolean",
                        "description": "When enabled, only return coupons marked as verified by Groupon editors.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of coupon records to return (1–500).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
