# Sedo Domain Auctions Scraper (`parseforge/sedo-auctions-scraper`) Actor

Scrape live Sedo expiring domain auctions with reserve price, end time, traffic, TLD, and length filters. Built for domain investors, brand managers, and SEO professionals.

- **URL**: https://apify.com/parseforge/sedo-auctions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $18.75 / 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.
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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🌐 Sedo Domain Auctions Scraper

> 🚀 **Pull every live Sedo expiring-domain auction in seconds.** Filter by TLD, reserve price, traffic, length, and end time. No API key, no Sedo account, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-17 · **📊 16 fields** per record · **12,000+ live auctions** per snapshot · **21 TLDs** covered · **Refreshes every day**

The **Sedo Domain Auctions Scraper** turns the live Sedo expiring-domain auction roster into a clean, listing-level dataset. Every record is one ongoing or upcoming auction with the **domain name**, the **reserve price** in USD, the **start and end times** in UTC, the **monthly traffic estimate**, the **TLD**, the **second-level domain length**, and three machine-readable flags for **IDN**, **hyphenated**, and **numeric** domains. The scraper hits the official Sedo auction export so the data is identical to what shows up on the Sedo "Auctions ending soon" page, parsed into stable JSON columns.

Sedo is one of the largest domain aftermarkets in the world and its expiring-domain auctions move thousands of names every week. Pulling that inventory by hand means clicking through the Sedo search UI page by page, which is slow and breaks the moment Sedo tweaks its layout. This Actor turns the entire roster into a single dataset in under a second of compute. Domain investors get a fresh **shortlist of flip candidates** every morning, brand owners get **early warning when a misspelled lookalike of their mark hits auction**, and SEO researchers get a **clean view of expiring names with measurable historical traffic** ready for outreach.

| Target Audience | Primary Use Cases |
| --- | --- |
| Domain investors and flippers | Surface short, high-traffic .com names with low reserve prices before the market notices |
| Brand managers and trademark teams | Monitor expiring lookalike and misspelled-mark domains for protective acquisition |
| SEO professionals and link builders | Find expiring domains with backlinks and traffic for 301 migrations or PBN candidates |
| Domain brokers and marketplaces | Generate fresh inventory feeds and outbound contact lists from a single daily run |

---

### 📋 What the Sedo Domain Auctions Scraper does

- 🔍 **Live auction roster.** Every run pulls the current Sedo expiring-domain auction export, which Sedo refreshes daily, so the results are always in sync with the public Sedo search UI.
- 🌐 **TLD filters.** Restrict the roster to specific top-level domains (com, net, org, info, online, shop, xyz, and 14 more) with a single multi-select input.
- 💵 **Price, traffic, and length filters.** Pass `minPrice`, `maxPrice`, `minTraffic`, `minLength`, and `maxLength` to narrow the roster to the kind of names you actually want to buy.
- 🚫 **Quality filters.** Exclude hyphenated names, numeric names, or IDN (non-ASCII) names with one checkbox each.
- 📅 **Date filters.** Use `endsBefore`, `endsAfter`, and the `includeEnded` toggle to grab auctions ending today, this weekend, or any window inside the seven-day Sedo export.
- ↕️ **Eight sort orders.** Sort by ending soonest, ending latest, price, traffic, length, or alphabetical so the most useful rows land at the top of the dataset.

Each record carries the domain name, the TLD, the second-level domain length, three boolean attribute flags (IDN, hyphen, numbers), the reserve price in USD, the monthly traffic estimate, ISO-8601 start and end timestamps, the auction type label, the Sedo details URL for that listing, the source export URL, and an ISO-8601 scrape timestamp.

> 💡 **Why it matters:** Sedo's expiring auctions are a free, time-sensitive signal of which names are about to change hands, but the source is a UTF-16 CSV with European-style separators that most scraping stacks choke on. This Actor collapses that into one clean row per auction so you can run SQL, pandas, or Airtable filters against it directly.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing how to shortlist high-traffic .com auctions, build a brand-protection watchlist, and schedule a daily run.

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Notes</th></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>Total rows to return. Free plan caps at 10, paid plans up to 1,000,000.</td></tr>
<tr><td><code>tlds</code></td><td>array of strings</td><td>Restrict the roster to specific TLDs (e.g. <code>com</code>, <code>net</code>, <code>org</code>). Leave empty to keep all TLDs in the current Sedo export.</td></tr>
<tr><td><code>domainContains</code></td><td>string</td><td>Case-insensitive substring filter on the domain name.</td></tr>
<tr><td><code>minPrice</code></td><td>integer</td><td>Minimum reserve price in USD. Inclusive.</td></tr>
<tr><td><code>maxPrice</code></td><td>integer</td><td>Maximum reserve price in USD. Inclusive.</td></tr>
<tr><td><code>minTraffic</code></td><td>integer</td><td>Minimum monthly traffic estimate. Inclusive.</td></tr>
<tr><td><code>minLength</code></td><td>integer</td><td>Minimum second-level domain length (TLD and dot not counted).</td></tr>
<tr><td><code>maxLength</code></td><td>integer</td><td>Maximum second-level domain length (TLD and dot not counted).</td></tr>
<tr><td><code>excludeHyphens</code></td><td>boolean</td><td>Drop domains containing hyphens.</td></tr>
<tr><td><code>excludeNumbers</code></td><td>boolean</td><td>Drop domains containing digits.</td></tr>
<tr><td><code>excludeIdn</code></td><td>boolean</td><td>Drop IDN domains that use non-ASCII characters.</td></tr>
<tr><td><code>includeEnded</code></td><td>boolean</td><td>Include auctions whose end time has already passed. Off by default.</td></tr>
<tr><td><code>endsBefore</code></td><td>date</td><td>Upper bound on auction end time. Inclusive.</td></tr>
<tr><td><code>endsAfter</code></td><td>date</td><td>Lower bound on auction end time. Inclusive.</td></tr>
<tr><td><code>sortBy</code></td><td>enum</td><td>One of <code>endTimeAsc</code>, <code>endTimeDesc</code>, <code>priceAsc</code>, <code>priceDesc</code>, <code>trafficDesc</code>, <code>lengthAsc</code>, <code>lengthDesc</code>, <code>domainAsc</code>.</td></tr>
</table>

Example: shortlist short, high-traffic .com auctions ending in the next 48 hours, ignoring hyphenated names.

```json
{
    "tlds": ["com"],
    "maxLength": 8,
    "minTraffic": 500,
    "excludeHyphens": true,
    "sortBy": "trafficDesc",
    "maxItems": 100
}
````

Example: pull every auction containing a brand keyword for protective monitoring.

```json
{
    "domainContains": "acme",
    "includeEnded": true,
    "sortBy": "endTimeAsc",
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** The Sedo export contains the **next seven days** of expiring auctions in a single snapshot, refreshed daily. A full unfiltered pull is usually around **12,000 live listings**, so do not be surprised by big result counts. Reserve prices are quoted in **USD** regardless of language cookie. Traffic is Sedo's own monthly visitor estimate, with `0` meaning Sedo reports no measurable traffic.

***

### 📊 Output

Each row in the dataset is one Sedo expiring-domain auction. Below is the schema, then three real records from a live Sedo pull on 2026-05-17.

#### 🧾 Schema

| Field | Type | Example |
| --- | --- | --- |
| 🌐 `domainName` | string | `motorwayamerica.com` |
| 🏷️ `tld` | string | `com` |
| 📏 `domainLength` | number | `15` |
| 🌍 `isIdn` | boolean | `false` |
| ➖ `hasHyphen` | boolean | `false` |
| 🔢 `hasNumbers` | boolean | `false` |
| 💵 `reservePrice` | number | `79` |
| 💱 `currency` | string | `USD` |
| 📊 `traffic` | number | `2488` |
| 🟢 `startTime` | string (ISO datetime) | `2026-05-13T18:00:00.000Z` |
| 🔴 `endTime` | string (ISO datetime) | `2026-05-20T18:00:00.000Z` |
| 🏷️ `auctionType` | string | `Expiring Domain Auction` |
| 🔗 `detailsUrl` | string | Sedo listing details URL |
| 📡 `sourceUrl` | string | Sedo export URL |
| 🕒 `scrapedAt` | string (ISO datetime) | `2026-05-17T04:36:43.367Z` |
| ❌ `error` | string | Only set on listing-level failures |

#### 📦 Sample records

<details>
<summary>📈 Typical: a clean .com with measurable traffic and no flags</summary>

```json
{
    "domainName": "motorwayamerica.com",
    "tld": "com",
    "domainLength": 15,
    "isIdn": false,
    "hasHyphen": false,
    "hasNumbers": false,
    "reservePrice": 79,
    "currency": "USD",
    "traffic": 2488,
    "startTime": "2026-05-13T18:00:00.000Z",
    "endTime": "2026-05-20T18:00:00.000Z",
    "auctionType": "Expiring Domain Auction",
    "detailsUrl": "https://sedo.com/search/details/?domain=motorwayamerica.com&origin=export",
    "sourceUrl": "https://sedo.com/c7r/assets/static/documents/search/expiring_domain_auctions/expiring_domain_auctions.csv",
    "scrapedAt": "2026-05-17T04:36:43.367Z"
}
```

</details>

<details>
<summary>🪢 Edge case: a hyphenated .com still drawing five-figure monthly traffic</summary>

```json
{
    "domainName": "forum-musculation.com",
    "tld": "com",
    "domainLength": 17,
    "isIdn": false,
    "hasHyphen": true,
    "hasNumbers": false,
    "reservePrice": 79,
    "currency": "USD",
    "traffic": 6060,
    "startTime": "2026-05-12T18:00:00.000Z",
    "endTime": "2026-05-19T18:00:00.000Z",
    "auctionType": "Expiring Domain Auction",
    "detailsUrl": "https://sedo.com/search/details/?domain=forum-musculation.com&origin=export",
    "sourceUrl": "https://sedo.com/c7r/assets/static/documents/search/expiring_domain_auctions/expiring_domain_auctions.csv",
    "scrapedAt": "2026-05-17T04:36:43.367Z"
}
```

</details>

<details>
<summary>🪶 Sparse: a brand-new .info with zero reported traffic</summary>

```json
{
    "domainName": "paultseng.info",
    "tld": "info",
    "domainLength": 9,
    "isIdn": false,
    "hasHyphen": false,
    "hasNumbers": false,
    "reservePrice": 79,
    "currency": "USD",
    "traffic": 0,
    "startTime": "2026-05-15T18:00:00.000Z",
    "endTime": "2026-05-22T18:00:00.000Z",
    "auctionType": "Expiring Domain Auction",
    "detailsUrl": "https://sedo.com/search/details/?domain=paultseng.info&origin=export",
    "sourceUrl": "https://sedo.com/c7r/assets/static/documents/search/expiring_domain_auctions/expiring_domain_auctions.csv",
    "scrapedAt": "2026-05-17T04:36:43.367Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
| --- | --- |
| 🎯 | **Listing-level, not paginated HTML.** Every row is one Sedo auction with stable JSON columns. No card-by-card DOM parsing, no broken layouts when Sedo redesigns its UI. |
| 🌐 | **21 TLDs covered.** The full Sedo expiring-auction TLD palette is enumerated as a typed multi-select input, so you can pick exactly the namespaces you trade in. |
| 💵 | **Reserve price in plain USD.** No currency symbol parsing, no euro-versus-dollar guessing. Each row carries a numeric `reservePrice` and a `currency` field. |
| 📊 | **Traffic estimate per domain.** Sedo's own monthly visitor estimate is included on every row, ready for filters like "only show me names doing 500+ visits per month". |
| 📅 | **UTC timestamps.** Start and end times are normalised to ISO-8601 in UTC so they sort and compare cleanly across timezones. |
| 🧮 | **Eight sort orders.** Sort the roster by ending soonest, by price, by traffic, by length, or alphabetical before the `maxItems` cap is applied. |
| ✅ | **Official Sedo export source.** The scraper reads the same daily export Sedo publishes for its own UI, so every value is identical to the canonical Sedo "Auctions ending soon" view. |

> 📊 **A single run returns roughly 12,000 live auctions across .com, .net, .org, .info, .online, .shop, and 15 more TLDs**, all filterable with one JSON input.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
| --- | --- | --- | --- | --- | --- |
| **⭐ Sedo Domain Auctions Scraper** *(this Actor)* | Low Apify usage | Full live Sedo expiring auctions | Daily | TLD, price, traffic, length, attributes, dates | One JSON input |
| Manual Sedo UI browsing | Free, but slow | Same listings | Manual | UI filters only | Hours of clicking |
| Paid commercial domain feeds | Hundreds per month | Aggregated, sometimes stale | Vendor-defined | Vendor-specific | Contract negotiation |
| Legacy community CSV dumps | Free | Outdated, incomplete | Whenever someone remembers | Limited | Download and reformat |
| Building your own Sedo parser | Engineering time | Custom | Custom | Custom | Days to weeks |

For most teams, the value of this Actor is in skipping the UTF-16 CSV decoding and the filter plumbing, not in the data itself, which is free at the source.

***

### 🚀 How to use

1. 🆕 **Sign up.** Create a free Apify account at [console.apify.com/sign-up?fpr=vmoqkp](https://console.apify.com/sign-up?fpr=vmoqkp). No credit card required for the preview.
2. 🔎 **Open the Actor.** Find the Sedo Domain Auctions Scraper in the Apify Store.
3. ⚙️ **Configure the input.** Pick TLDs, set price and traffic floors, choose a sort order. Leave everything blank to pull the entire live roster.
4. ▶️ **Run.** Click Start. The Actor reads the live Sedo export, applies your filters, and streams matches to the dataset.
5. 📥 **Export.** Download the dataset as JSON, CSV, Excel, or RSS, or query it via the Apify API.

> ⏱️ **Total time:** about 10 seconds for a 10-item preview run, well under a minute for the full unfiltered 12,000-row roster.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 💰 Domain investors and flippers

- Shortlist short .com names with measurable historical traffic
- Filter the daily roster down to a personal portfolio buy list
- Spot pattern-match opportunities like keyword + .ai or .io
- Pipe winning bids into a CRM for portfolio tracking

</td>
<td width="50%">

#### 🛡️ Brand managers

- Monitor expiring lookalike and misspelled-mark domains
- Build a daily watchlist of names containing brand keywords
- Surface protective acquisition targets before squatters bid
- Generate evidence trails for UDRP complaints

</td>
</tr>
<tr>
<td width="50%">

#### 🔍 SEO and link builders

- Find expiring names with measurable referral traffic for 301s
- Source clean-history domains for content site portfolios
- Cross-reference Sedo traffic with internal backlink datasets
- Track which niches see the most expiring inventory each week

</td>
<td width="50%">

#### 🏢 Brokers and marketplaces

- Generate outbound contact lists from fresh auction inventory
- Detect pricing trends across TLDs and length buckets
- Power internal dashboards for senior brokers
- Feed downstream valuation and appraisal pipelines

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating Sedo Domain Auctions Scraper

Run this Actor on a schedule or from your own code.

- [**Apify Node.js SDK**](https://docs.apify.com/sdk/js) for JavaScript and TypeScript integrations.
- [**Apify Python SDK**](https://docs.apify.com/sdk/python) for data-science workflows.
- [**Apify API reference**](https://docs.apify.com/api/v2) for any HTTP client.

Schedules let you run the Actor every hour, every morning, or on any cron pattern. A common setup is to run a filtered shortlist every day at 06:00 UTC and pipe the new rows into Slack, Airtable, or a Google Sheet so the team starts the day with a fresh buy list.

***

### ❓ Frequently Asked Questions

<details>
<summary>📜 What kind of auctions does this Actor return?</summary>

Sedo's daily expiring-domain auction roster: names that have dropped from their original owners and are being re-auctioned through Sedo. Each auction has a defined start time, end time, and reserve price.

</details>

<details>
<summary>🔁 How often is the data refreshed?</summary>

Sedo publishes a fresh auction export once per day, typically in the late afternoon UTC. Every run of this Actor pulls the live export at the moment you click Start, so the dataset always reflects the current Sedo roster.

</details>

<details>
<summary>🌐 Which TLDs are covered?</summary>

Whichever TLDs Sedo includes in its export on the day you run. The current palette spans 21 TLDs (com, net, org, info, biz, online, shop, xyz, club, space, website, me, tv, cc, email, name, work, global, photography, bayern, koeln). The schema is updated as Sedo adds new TLDs to the export.

</details>

<details>
<summary>💵 What currency is the reserve price in?</summary>

USD. The Sedo export is published in US dollars regardless of language cookie or browser locale, so every `reservePrice` value is a plain integer dollar amount.

</details>

<details>
<summary>📊 What does the traffic field measure?</summary>

It is Sedo's own monthly visitor estimate for the domain. A value of `0` means Sedo reports no measurable traffic, not that the field is missing.

</details>

<details>
<summary>⏱️ Does the Actor include auctions that have already ended?</summary>

By default no. The roster covers a rolling seven-day window, and any rows where the end time has already passed are skipped. Set `includeEnded` to true to include those rows for historical analysis.

</details>

<details>
<summary>📅 Can I limit results to auctions ending today or tomorrow?</summary>

Yes. Pass `endsBefore` and `endsAfter` as ISO dates or datetimes. For "ending in the next 24 hours" set `endsAfter` to now and `endsBefore` to tomorrow at the same time.

</details>

<details>
<summary>💼 Can I use this commercially?</summary>

Yes. The Sedo auction export is publicly published as a downloadable CSV for the marketplace's own search UI, and the Actor itself is licensed for both commercial and non-commercial use under your Apify subscription.

</details>

<details>
<summary>💳 Do I need a paid plan?</summary>

The free plan returns up to 10 rows per run as a preview. Any paid plan unlocks up to 1,000,000 rows per run. There is no separate subscription for the Actor.

</details>

<details>
<summary>🛟 What happens if a run fails part-way?</summary>

If Sedo briefly returns a non-200 response or an empty file, the run logs the error and exits cleanly with a single error row in the dataset. There is no partial-row corruption, since the Actor only writes after the export has been parsed end to end.

</details>

<details>
<summary>⚖️ Is this scraper legal?</summary>

Yes. The Actor reads a CSV file that Sedo itself publishes on its public CDN to power its own search UI. No login, no captcha, no protected endpoint is involved.

</details>

<details>
<summary>📤 What output formats are available?</summary>

The Apify dataset can be exported as JSON, JSONL, CSV, Excel, HTML, XML, or RSS. You can also pull data via the Apify API, set up webhooks on dataset writes, or integrate with downstream tools.

</details>

***

### 🔌 Integrate with any app

- [**Zapier**](https://zapier.com/apps/apify/integrations) - trigger workflows whenever a fresh auction row lands.
- [**Make**](https://www.make.com/en/integrations/apify) - build visual automations on top of the dataset.
- [**Airtable**](https://docs.apify.com/integrations) - sync auctions into a base for collaborative review.
- [**Google Sheets**](https://docs.apify.com/integrations/google-sheets) - feed the daily roster into a shared spreadsheet.
- [**Slack**](https://docs.apify.com/integrations/slack) - alert a channel when a watched keyword hits auction.
- [**Webhooks**](https://docs.apify.com/integrations/webhooks) - push run results to any HTTP endpoint.

***

### 🔗 Recommended Actors

- [**🚗 Bring A Trailer Auctions Scraper**](https://apify.com/parseforge/bringatrailer-auctions-scraper) - live classic-car auction listings, bids, and ending times.
- [**🚜 Ritchie Bros Auctioneers Scraper**](https://apify.com/parseforge/ritchie-bros-auctioneers-scraper) - heavy-equipment auction inventory and lot details.
- [**🛠️ AuctionTime Scraper**](https://apify.com/parseforge/auctiontime-scraper) - farm and construction equipment auctions across North America.
- [**🏛️ GovDeals Government Auction Scraper**](https://apify.com/parseforge/govdeals-scraper) - municipal and state surplus auctions with bids and end times.
- [**🔗 Broken Link Checker**](https://apify.com/parseforge/broken-link-checker) - audit any site for dead outbound links, useful for domain-acquisition research.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more auction, marketplace, and domain-data scrapers.

***

**🆘 Need Help?** Reach out via [**Open our contact form**](https://tally.so/r/BzdKgA) and we will respond within one business day.

***

> ⚖️ **Disclaimer:** This Actor extracts publicly available data from Sedo's own auction export for legitimate research, investment, and brand-protection purposes. Sedo publishes the underlying CSV on its public CDN to power its own search UI. Users are responsible for ensuring their use of the data complies with applicable laws and regulations in their jurisdiction. ParseForge is not affiliated with Sedo or any of its parent or sister entities.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `tlds` (type: `array`):

Restrict to specific top-level domains (e.g. com, net, org, info). Leave empty for all TLDs available in the current auction roster.

## `domainContains` (type: `string`):

Case-insensitive substring filter on the domain name (e.g. "crypto" matches cryptohub.com, ai-crypto.net). Leave blank for no keyword filter.

## `minPrice` (type: `integer`):

Only return domains with a reserve price at or above this USD value.

## `maxPrice` (type: `integer`):

Only return domains with a reserve price at or below this USD value.

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

Only return domains with a monthly traffic estimate at or above this value.

## `minLength` (type: `integer`):

Only return domains whose second-level name is at least this many characters long (the TLD and dot are not counted, e.g. "hello.com" has length 5).

## `maxLength` (type: `integer`):

Only return domains whose second-level name is at most this many characters long (the TLD and dot are not counted, e.g. "hello.com" has length 5).

## `excludeHyphens` (type: `boolean`):

Filter out domain names containing hyphens.

## `excludeNumbers` (type: `boolean`):

Filter out domain names containing digits.

## `excludeIdn` (type: `boolean`):

Filter out IDN domains (those using non-ASCII characters).

## `includeEnded` (type: `boolean`):

By default only auctions still ongoing (end time in the future) are returned. Enable this to include auctions that have already ended in the Sedo export window.

## `endsBefore` (type: `string`):

ISO timestamp (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ). Only return auctions ending on or before this date.

## `endsAfter` (type: `string`):

ISO timestamp (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ). Only return auctions ending on or after this date.

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

Field used to order results before max-items truncation.

## Actor input object example

```json
{
  "maxItems": 10,
  "excludeHyphens": false,
  "excludeNumbers": false,
  "excludeIdn": false,
  "includeEnded": false,
  "sortBy": "endTimeAsc"
}
```

# Actor output Schema

## `auctions` (type: `string`):

Complete dataset of scraped Sedo expiring domain auctions

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

Tabular view of auctions with key fields displayed in a table

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/sedo-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/sedo-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 '{
  "maxItems": 10
}' |
apify call parseforge/sedo-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sedo Domain Auctions Scraper",
        "description": "Scrape live Sedo expiring domain auctions with reserve price, end time, traffic, TLD, and length filters. Built for domain investors, brand managers, and SEO professionals.",
        "version": "0.1",
        "x-build-id": "aWadpgNGJReKHR6EF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~sedo-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-sedo-auctions-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/parseforge~sedo-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-sedo-auctions-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/parseforge~sedo-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-sedo-auctions-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "tlds": {
                        "title": "TLDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict to specific top-level domains (e.g. com, net, org, info). Leave empty for all TLDs available in the current auction roster.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "com",
                                "net",
                                "org",
                                "info",
                                "biz",
                                "online",
                                "shop",
                                "xyz",
                                "club",
                                "space",
                                "website",
                                "me",
                                "tv",
                                "cc",
                                "email",
                                "name",
                                "work",
                                "global",
                                "photography",
                                "bayern",
                                "koeln"
                            ],
                            "enumTitles": [
                                ".com",
                                ".net",
                                ".org",
                                ".info",
                                ".biz",
                                ".online",
                                ".shop",
                                ".xyz",
                                ".club",
                                ".space",
                                ".website",
                                ".me",
                                ".tv",
                                ".cc",
                                ".email",
                                ".name",
                                ".work",
                                ".global",
                                ".photography",
                                ".bayern",
                                ".koeln"
                            ]
                        }
                    },
                    "domainContains": {
                        "title": "Domain name contains",
                        "type": "string",
                        "description": "Case-insensitive substring filter on the domain name (e.g. \"crypto\" matches cryptohub.com, ai-crypto.net). Leave blank for no keyword filter."
                    },
                    "minPrice": {
                        "title": "Minimum reserve price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return domains with a reserve price at or above this USD value."
                    },
                    "maxPrice": {
                        "title": "Maximum reserve price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return domains with a reserve price at or below this USD value."
                    },
                    "minTraffic": {
                        "title": "Minimum monthly traffic",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return domains with a monthly traffic estimate at or above this value."
                    },
                    "minLength": {
                        "title": "Minimum domain length (SLD)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only return domains whose second-level name is at least this many characters long (the TLD and dot are not counted, e.g. \"hello.com\" has length 5)."
                    },
                    "maxLength": {
                        "title": "Maximum domain length (SLD)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only return domains whose second-level name is at most this many characters long (the TLD and dot are not counted, e.g. \"hello.com\" has length 5)."
                    },
                    "excludeHyphens": {
                        "title": "Exclude domains with hyphens",
                        "type": "boolean",
                        "description": "Filter out domain names containing hyphens.",
                        "default": false
                    },
                    "excludeNumbers": {
                        "title": "Exclude domains with numbers",
                        "type": "boolean",
                        "description": "Filter out domain names containing digits.",
                        "default": false
                    },
                    "excludeIdn": {
                        "title": "Exclude internationalised (IDN) domains",
                        "type": "boolean",
                        "description": "Filter out IDN domains (those using non-ASCII characters).",
                        "default": false
                    },
                    "includeEnded": {
                        "title": "Include already-ended auctions",
                        "type": "boolean",
                        "description": "By default only auctions still ongoing (end time in the future) are returned. Enable this to include auctions that have already ended in the Sedo export window.",
                        "default": false
                    },
                    "endsBefore": {
                        "title": "Auction ends before",
                        "type": "string",
                        "description": "ISO timestamp (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ). Only return auctions ending on or before this date."
                    },
                    "endsAfter": {
                        "title": "Auction ends after",
                        "type": "string",
                        "description": "ISO timestamp (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ). Only return auctions ending on or after this date."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "endTimeAsc",
                            "endTimeDesc",
                            "priceAsc",
                            "priceDesc",
                            "trafficDesc",
                            "lengthAsc",
                            "lengthDesc",
                            "domainAsc"
                        ],
                        "type": "string",
                        "description": "Field used to order results before max-items truncation.",
                        "default": "endTimeAsc"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
