# Doctor of Credit Bonus Scraper (`moving_beacon-owner1/doctor-of-credit-bonus-scraper`) Actor

Doctor of Credit Bonus Scraper — Selenium Edition is an Apify Actor that scrapes bank and credit card bonus offers from Doctor of Credit. It allows filtering by minimum bonus amount and configurable result limits, extracting structured data like amount, title, URL, and category.

- **URL**: https://apify.com/moving\_beacon-owner1/doctor-of-credit-bonus-scraper.md
- **Developed by:** [Jamshaid Arif](https://apify.com/moving_beacon-owner1) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Doctor of Credit Bonus Scraper — Selenium Edition (Apify Actor)

Scrapes bank-bonus listings from [Doctor of Credit](https://www.doctorofcredit.com)


### Input

| Field                | Type    | Prefill                          | Description |
|----------------------|---------|----------------------------------|-------------|
| `slug` *(req.)*      | string  | `"best-bank-account-bonuses"`    | DoC post path (with or without slashes). |
| `minAmount`          | integer | `100`                            | Drop matches below this $ amount. `0` = no floor. |
| `maxResults`         | integer | `50`                             | Cap on stored bonuses (1–500). |
| `headless`           | boolean | `true`                           | Run Chrome in Xvfb. |
| `proxyConfiguration` | object  | Apify Residential US             | Optional; DoC has no anti-bot. |

Useful slugs:

| Slug | What it lists |
|------|---------------|
| `best-bank-account-bonuses`              | Canonical bank/checking/savings bonuses (updated weekly) |
| `best-credit-card-bonuses`               | All credit card sign-up bonuses |
| `best-personal-credit-card-bonuses`      | Personal cards only |
| `best-business-credit-card-bonuses`      | Business cards only |

Example input:

```json
{
    "slug": "best-bank-account-bonuses",
    "minAmount": 200,
    "maxResults": 100
}
````

### Output

Each record:

```json
{
    "amount": 300,
    "title": "Chase Total Checking",
    "url": "https://www.doctorofcredit.com/chase-300-checking-coupon/",
    "raw_text": "$300 Chase Total Checking",
    "source_slug": "best-bank-account-bonuses"
}
```

- `amount` — integer dollar amount the regex parsed
- `title` — text after the `$AMOUNT` in the matched element (best-effort; sometimes prose)
- `url` — the link the matched element points to (may be the DoC detail page or the bank's page)
- `raw_text` — exact text the regex matched against, for debugging
- `source_slug` — the DoC post this came from

A `SUMMARY` blob lands on the KV store with the slug, parsed parameters,
result count, and total elapsed time.

# Actor input Schema

## `slug` (type: `string`):

The Doctor of Credit post path (with or without leading/trailing slashes). The default 'best-bank-account-bonuses' is the canonical bonuses roundup, updated weekly. Other useful slugs: 'best-credit-card-bonuses', 'best-personal-credit-card-bonuses', 'best-business-credit-card-bonuses'.

## `minAmount` (type: `integer`):

Drop matches below this dollar amount. Useful for filtering out small mentions (e.g. $5 referral bonuses) when you only care about real signup bonuses.

## `maxResults` (type: `integer`):

Cap on stored bonuses (1–500). The original DoctorOfCreditBrowser hardcoded 50; this exposes it as a knob.

## `headless` (type: `boolean`):

Run Chrome without a visible window. SeleniumBase UC mode + Xvfb means this still uses a real Chrome process (not --headless flag, which fingerprint detectors target). Leave true.

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

Doctor of Credit is a WordPress blog with no anti-bot — a proxy isn't strictly required, but Apify Residential US still helps avoid sporadic rate-limiting if you run this on a tight schedule.

## Actor input object example

```json
{
  "slug": "best-bank-account-bonuses",
  "minAmount": 100,
  "maxResults": 50,
  "headless": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "slug": "best-bank-account-bonuses",
    "minAmount": 100,
    "maxResults": 50,
    "headless": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("moving_beacon-owner1/doctor-of-credit-bonus-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 = {
    "slug": "best-bank-account-bonuses",
    "minAmount": 100,
    "maxResults": 50,
    "headless": True,
}

# Run the Actor and wait for it to finish
run = client.actor("moving_beacon-owner1/doctor-of-credit-bonus-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 '{
  "slug": "best-bank-account-bonuses",
  "minAmount": 100,
  "maxResults": 50,
  "headless": true
}' |
apify call moving_beacon-owner1/doctor-of-credit-bonus-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=moving_beacon-owner1/doctor-of-credit-bonus-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Doctor of Credit Bonus Scraper",
        "description": "Doctor of Credit Bonus Scraper — Selenium Edition is an Apify Actor that scrapes bank and credit card bonus offers from Doctor of Credit. It allows filtering by minimum bonus amount and configurable result limits, extracting structured data like amount, title, URL, and category.",
        "version": "0.0",
        "x-build-id": "WdXqULHNvq9rvUYBC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/moving_beacon-owner1~doctor-of-credit-bonus-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-moving_beacon-owner1-doctor-of-credit-bonus-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/moving_beacon-owner1~doctor-of-credit-bonus-scraper/runs": {
            "post": {
                "operationId": "runs-sync-moving_beacon-owner1-doctor-of-credit-bonus-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/moving_beacon-owner1~doctor-of-credit-bonus-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-moving_beacon-owner1-doctor-of-credit-bonus-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": [
                    "slug"
                ],
                "properties": {
                    "slug": {
                        "title": "Post slug",
                        "type": "string",
                        "description": "The Doctor of Credit post path (with or without leading/trailing slashes). The default 'best-bank-account-bonuses' is the canonical bonuses roundup, updated weekly. Other useful slugs: 'best-credit-card-bonuses', 'best-personal-credit-card-bonuses', 'best-business-credit-card-bonuses'."
                    },
                    "minAmount": {
                        "title": "Minimum bonus amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop matches below this dollar amount. Useful for filtering out small mentions (e.g. $5 referral bonuses) when you only care about real signup bonuses."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on stored bonuses (1–500). The original DoctorOfCreditBrowser hardcoded 50; this exposes it as a knob.",
                        "default": 50
                    },
                    "headless": {
                        "title": "Headless browser",
                        "type": "boolean",
                        "description": "Run Chrome without a visible window. SeleniumBase UC mode + Xvfb means this still uses a real Chrome process (not --headless flag, which fingerprint detectors target). Leave true.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Doctor of Credit is a WordPress blog with no anti-bot — a proxy isn't strictly required, but Apify Residential US still helps avoid sporadic rate-limiting if you run this on a tight schedule.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
