# GoDaddy Auctions Scraper (`automation-lab/godaddy-auctions-scraper`) Actor

Extract public GoDaddy Auctions domains with prices, bids, traffic, backlinks, valuation, end times, status, and listing URLs for acquisition monitoring.

- **URL**: https://apify.com/automation-lab/godaddy-auctions-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## GoDaddy Auctions Scraper

Extract public **GoDaddy Auctions** domain listings for expiring-domain acquisition monitoring. The Actor returns structured prices, bids, traffic indicators, backlink metrics, valuation, end time, status, and listing URLs without placing bids or requiring a GoDaddy account.

Use it to build a one-time acquisition shortlist, feed a spreadsheet, or schedule recurring inventory snapshots that you compare in your own database.

### What does GoDaddy Auctions Scraper do?

The Actor opens a browser session in the United States, clears GoDaddy's public access checks, and replays the auction site's JSON pagination in that same session. It can:

- search domain names by a keyword or fragment;
- collect broad inventory without a keyword;
- order auctions by end time, bids, price, or traffic;
- filter by current price, minimum bids, and minimum traffic;
- paginate up to your requested result limit;
- return clean JSON, JSONL, CSV, Excel, XML, or HTML through Apify datasets.

It reads public listing data only. It does not sign in, join Auctions, watch domains, bid, buy, or modify an account.

### Who is this Actor for?

- **Domain investors** screening expiring inventory before auction end.
- **Acquisition teams** building repeatable candidate lists for review.
- **SEO analysts** using backlinks, referring domains, and traffic as prioritization signals.
- **Market researchers** comparing active prices, valuations, and bidding activity.
- **Data engineers** loading current auction snapshots into a warehouse or dashboard.

### Why use this Actor?

The normal GoDaddy Auctions site is interactive and protected by session-level access controls. A simple HTTP request is not enough. This Actor keeps browser fingerprint, cookies, and sticky US residential identity together, then uses GoDaddy's structured result feed instead of scraping fragile table text.

That design provides typed records, deterministic limits, and pagination while avoiding unnecessary detail-page and media downloads. Blocked identities are rotated a bounded number of times rather than retried forever.

### What GoDaddy auction data can I extract?

| Field | Meaning |
| --- | --- |
| `auctionId` | GoDaddy's numeric auction identifier |
| `domain` | Fully qualified domain name |
| `currentPriceUsd` | Current listed auction price in USD |
| `currentBidPriceUsd` | Current bid amount when GoDaddy provides it |
| `bids` | Number of bids |
| `monthlyTraffic` | GoDaddy-reported monthly traffic indicator |
| `backlinksCount` | Majestic external backlink count exposed by GoDaddy |
| `referringDomains` | Majestic referring-domain count |
| `citationFlow`, `trustFlow` | Majestic quality indicators when present |
| `valuationPriceUsd` | GoDaddy valuation in USD when present |
| `auctionEndTime` | ISO timestamp for auction end |
| `status` | Normalized active/inactive status |
| `auctionStatusCode` | Source status code when present |
| `auctionTypeCode` | Source auction type code |
| `buyNowAvailable` | Whether buy-now is enabled |
| `buyNowPriceUsd` | Buy-now amount when present |
| `domainCreatedAt` | Source-reported domain creation time |
| `domainExpiresAt` | Source-reported expiry time when present |
| `listingUrl` | GoDaddy Auctions listing link |
| `scrapedAt` | Time this Actor collected the record |

A missing optional source value is omitted rather than invented. Traffic, backlink, and valuation values are third-party indicators, not guarantees of future performance.

### How to scrape GoDaddy Auctions

1. Open the Actor's **Input** tab.
2. Enter an optional domain keyword such as `ai`.
3. Choose the maximum result count and sort order.
4. Add price, bid, or traffic filters when needed.
5. Click **Start**.
6. Open the default dataset to inspect or export results.
7. For monitoring, schedule the Actor and save each run's dataset in your own destination.

The Console prefill searches `ai`, requests 20 auctions, and puts auctions ending soon first. If those prefilled values are removed, the schema defaults to broad inventory with a 50-record limit.

### Input parameters

#### `keyword`

Optional domain word or fragment. Leave it blank for broad public inventory.

#### `startUrls`

Optional single `auctions.godaddy.com` URL. A `query` or `keyword` parameter in the URL overrides `keyword`. Other domains fail validation.

#### `maxItems`

Maximum unique records, from 1 to 5,000. The default is 50.

#### `minPrice` and `maxPrice`

Current-price bounds in USD. Both must be non-negative, and minimum cannot exceed maximum.

#### `minBids`

Only include auctions with at least this many bids.

#### `minTraffic`

Only include auctions with at least this source-reported monthly traffic value.

#### `sortBy`

Choose `endTimeAsc`, `bidsDesc`, `priceAsc`, `priceDesc`, or `trafficDesc`.

#### `maxSessionRetries`

Maximum fresh sticky US residential browser sessions when an identity is blocked. The default is 4 and the allowed range is 1–8. Raising it can increase proxy use and runtime.

### Example input

```json
{
  "keyword": "ai",
  "maxItems": 20,
  "sortBy": "endTimeAsc",
  "maxPrice": 500
}
```

For a repeat acquisition-monitoring shortlist:

```json
{
  "minBids": 5,
  "maxItems": 100,
  "sortBy": "bidsDesc"
}
```

### Example output

A current local run returned records in this shape:

```json
{
  "auctionId": 714534185,
  "domain": "aimeerosemary.com",
  "currentPriceUsd": 1,
  "bids": 0,
  "monthlyTraffic": 0,
  "backlinksCount": 0,
  "referringDomains": 0,
  "citationFlow": 0,
  "trustFlow": 0,
  "valuationPriceUsd": 15,
  "auctionEndTime": "2026-07-30T16:00:00Z",
  "status": "active",
  "auctionTypeCode": 38,
  "buyNowAvailable": false,
  "buyNowPriceUsd": 0,
  "domainCreatedAt": "2025-06-27T07:00:00Z",
  "listingUrl": "https://auctions.godaddy.com/beta/domain/aimeerosemary.com",
  "sourceUrl": "https://auctions.godaddy.com/beta",
  "scrapedAt": "2026-07-30T08:35:12.069Z"
}
```

Auction inventory changes continuously. Example domains and values describe one observed public result and are not promised to remain active.

### How much does it cost to scrape GoDaddy Auctions?

Pricing uses one **$0.018 start event** per run plus one `item` event per saved auction. Item prices decrease across six usage tiers, from **$0.0022954 on FREE** to **$0.00055888 on DIAMOND**.

At the FREE tier, 100 records cost about **$0.25** and 1,000 records cost about **$2.31**, including the start event. At BRONZE, the same runs cost about **$0.22** and **$2.01**. The Actor never charges item events for retries or failed records; see the live pricing panel for your tier.

The Actor never charges an item event for rejected, duplicate, empty, or failed records.

### Scheduling acquisition monitoring

Use an Apify schedule to run the same input daily or hourly. Each run produces a fresh default dataset. To detect change over time:

1. use `auctionId` as the stable listing key;
2. store `currentPriceUsd`, `bids`, `auctionEndTime`, and `scrapedAt`;
3. compare the newest row with your previous snapshot;
4. alert only on changes meaningful to your acquisition rules.

This Actor outputs snapshots; it does not maintain history or send alerts itself.

### Export and integration workflows

- Export the dataset as CSV or Excel for manual domain review.
- Send run data to Google Sheets, Make, Zapier, or a webhook.
- Load JSONL into BigQuery, Snowflake, PostgreSQL, or object storage.
- Filter candidates in code by valuation/price ratio or bidding activity.
- Join the results with your own legal, trademark, DNS, or availability checks.

### Run with the Apify API

Replace `APIFY_TOKEN` with your token.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~godaddy-auctions-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"ai","maxItems":20,"sortBy":"endTimeAsc"}'
```

Fetch dataset items from the `defaultDatasetId` returned by the run.

### JavaScript integration

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/godaddy-auctions-scraper').call({
  minBids: 5,
  maxItems: 100,
  sortBy: 'bidsDesc',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python integration

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/godaddy-auctions-scraper').call(run_input={
    'keyword': 'ai',
    'maxItems': 20,
    'sortBy': 'endTimeAsc',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/godaddy-auctions-scraper"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this equivalent MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/godaddy-auctions-scraper"
    }
  }
}
```

Example prompts:

- “Find 20 AI domains on GoDaddy Auctions ending soon and summarize price and bids.”
- “Collect 100 GoDaddy Auctions records with at least five bids and rank acquisition candidates.”
- “Export this run's domains, prices, backlinks, valuation, and end times as a review table.”

AI-generated rankings are research aids, not legal, trademark, financial, or investment advice.

### Limits and reliability

- GoDaddy may block individual proxy identities; the Actor rotates them within `maxSessionRetries`.
- A run fails clearly after retry exhaustion instead of returning a false empty dataset.
- Residential proxy access is required and restricted to the United States for this workflow.
- Results reflect the public API response at collection time and may change or disappear.
- The Actor does not enrich records by visiting each domain or auction detail page.
- Very selective filters can legitimately produce zero results.
- Source status/type codes are retained because GoDaddy does not publicly document every value.

### FAQ and troubleshooting

#### Why did the run fail before returning records?

GoDaddy rejected all allowed browser sessions or its API was temporarily unavailable. Retry later, or raise `maxSessionRetries` within the allowed limit if the extra proxy traffic is acceptable.

#### Why are some traffic or backlink values zero?

Zero is the value provided by GoDaddy's public auction response. It does not necessarily prove that a domain has no traffic or links.

#### Why is an auction no longer available?

Auctions expire, close, or change status. Use `auctionEndTime` and `scrapedAt` to understand when the snapshot was collected.

#### Can this Actor place bids?

No. It is read-only and does not authenticate, bid, buy, join Auctions, or update watchlists.

### Legality and responsible use

Collect only data you are permitted to use. Follow GoDaddy's terms, applicable database and privacy rules, rate expectations, and trademark law. Domain names can contain personal names or protected brands; perform appropriate legal review before acquisition or outreach. Avoid attempts to identify private bidders or circumvent account controls.

### Related scrapers

- [Domain Availability Checker](https://apify.com/automation-lab/domain-availability-checker) — check exact domains with DNS and WHOIS after you build an acquisition shortlist.

GoDaddy and Majestic are trademarks of their respective owners. This Actor is an independent data automation and is not affiliated with or endorsed by GoDaddy.

# Actor input Schema

## `keyword` (type: `string`):

Optional word or domain fragment to search. Leave blank to monitor broad auction inventory.

## `startUrls` (type: `array`):

Optionally provide one public auctions.godaddy.com search URL. The Actor reads its query or keyword parameter and uses it instead of Domain keyword; URLs on other hosts are rejected.

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

Stop after this many unique matching auction records.

## `minPrice` (type: `number`):

Only include auctions at or above this current price.

## `maxPrice` (type: `number`):

Only include auctions at or below this current price.

## `minBids` (type: `integer`):

Only include auctions with at least this many bids.

## `minTraffic` (type: `integer`):

Only include auctions with at least this GoDaddy-reported monthly traffic value.

## `sortBy` (type: `string`):

Choose how GoDaddy orders matching auctions before the limit is applied.

## `maxSessionRetries` (type: `integer`):

Number of fresh sticky US residential identities allowed when GoDaddy blocks a session. Increase only for difficult runs because each attempt uses proxy traffic.

## Actor input object example

```json
{
  "keyword": "ai",
  "maxItems": 20,
  "sortBy": "endTimeAsc",
  "maxSessionRetries": 4
}
```

# Actor output Schema

## `overview` (type: `string`):

Link to typed public GoDaddy Auctions records in the default dataset overview view.

# 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 = {
    "keyword": "ai",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/godaddy-auctions-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 = {
    "keyword": "ai",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/godaddy-auctions-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 '{
  "keyword": "ai",
  "maxItems": 20
}' |
apify call automation-lab/godaddy-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/WdEe1uSKTOncBpUN9/builds/pjofEcrkjLmw0HaA2/openapi.json