# New .fr Domains Finder (AFNIC Daily Registrations) (`fit_melon/new-fr-domains-finder-afnic`) Actor

Daily list of newly registered .fr, .re, .pm, .tf, .wf and .yt domains straight from AFNIC official open data. Filter by keywords to detect new French businesses, protect your brand from cybersquatting, and feed your B2B prospecting pipeline. Free, official, unbreakable source.

- **URL**: https://apify.com/fit\_melon/new-fr-domains-finder-afnic.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## New .fr Domains Finder — AFNIC Daily Registrations

### What it does

This actor fetches the **official daily list of newly registered French domain names** (nouveaux noms de domaine .fr) published by **AFNIC**, the French domain registry, as open data. Every day, AFNIC publishes the complete list of domains registered the previous day for the extensions it manages: **.fr, .re, .pm, .tf, .wf and .yt**, available in a 7-day rolling window. This actor turns those raw files into a clean, structured dataset — and lets you **filter domains by keywords** (e.g. `immo`, `renov`, `avocat`, `coach`, your brand name) to instantly spot relevant new registrations. A newly registered domain is one of the strongest early signals of a **new French business or web project**: perfect raw material for B2B lead generation, brand protection and market watch (veille). This actor is **free** — you only pay your own Apify platform usage.

### Input

| Field | Type | Description |
|---|---|---|
| `tlds` | array | AFNIC zones to fetch: `fr`, `re`, `pm`, `tf`, `wf`, `yt`. Default: `["fr"]`. |
| `days` | integer | How many past days to fetch (1–7, starting from yesterday). Default: `1`. |
| `keywords` | array | Optional keyword filter (case-insensitive, matches both punycode and accented Unicode forms). Empty = all domains. |
| `maxResults` | integer | Cap on total items. `0` = unlimited. |

### Output

One item per newly registered domain, with explicit statuses (`found` / `not_found` / `error`):

```json
{
    "domain": "xn--ara-zma.fr",
    "domainUnicode": "araña.fr",
    "isIdn": true,
    "tld": "fr",
    "registrationDate": "2026-07-04",
    "status": "found"
}
````

When a keyword filter is active, each item also includes a `matchedKeywords` array. A typical day brings **1,500–2,500 new .fr domains**.

### Use cases

- **B2B lead generation in France**: a fresh domain like `plomberie-lyon.fr` means someone is launching a business or a website *right now* — the perfect moment to pitch web design, hosting, SEO, insurance or accounting services.
- **Brand protection & cybersquatting watch**: filter on your brand name and get alerted the day a lookalike domain (typosquatting, `avis-*`, `arnaque-*` variants) is registered.
- **Market & trend watch (veille)**: track how many new domains mention `ia`, `cbd`, `renovation` or any emerging niche, day after day.
- **Feed your prospecting pipeline**: schedule a daily run and push results to Make, n8n, Zapier, Google Sheets or your CRM via the Apify API.

### Works great with (French business data suite)

This actor is part of a suite dedicated to **French company data (données entreprises françaises)**:

- 📄 **[French Legal Notices Scraper (Mentions Légales)](https://apify.com/fit_melon/french-legal-notices-scraper-mentions-legales)** — once the new website is live, extract the owner, SIREN and contact email from its mentions légales.
- 🔎 **[French Company Data Enricher (SIREN, Dirigeants)](https://apify.com/fit_melon/french-company-data-enricher-siren-dirigeants-sirene)** — enrich the SIREN with directors and full legal details.
- 🆕 **[New French Companies Finder (SIRENE)](https://apify.com/fit_melon/new-french-companies-finder-sirene)** — cross-reference with freshly created French companies from the official SIRENE register.
- 📬 **[Bulk Email Verifier & List Cleaner](https://apify.com/fit_melon/bulk-email-verifier-list-cleaner)** — verify contact emails before any outreach.

Typical pipeline: **Detect** a new domain (this actor) → **Extract** owner & SIREN from the website → **Enrich** the company → **Verify** contacts.

[Browse all our actors →](https://apify.com/fit_melon)

### Limitations & fair use

- AFNIC publishes each daily list **the following day**, with a **7-day rolling window**: older files are no longer available at the source.
- The lists contain **domain names only** (no registrant data) — GDPR-friendly by design.
- Data source: **AFNIC open data** (Association Française pour le Nommage Internet en Coopération). Reuse, including commercial reuse, is permitted subject to respecting data integrity and crediting the source, as stated in the files themselves. This actor identifies itself with a dedicated User-Agent and applies a politeness delay between requests.

*Keywords: nouveaux noms de domaine .fr, new .fr domains, AFNIC open data, domaines enregistrés, newly registered domains France, French domain registry, veille noms de domaine, cybersquatting monitoring, brand protection France, leads B2B France, prospection création site web, domain drop list France, .fr zone file.*

# Actor input Schema

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

Which AFNIC-managed extensions to fetch. Supported: fr, re, pm, tf, wf, yt.

## `days` (type: `integer`):

How many past days of registrations to fetch, starting from yesterday. AFNIC keeps a 7-day rolling window.

## `keywords` (type: `array`):

Only return domains containing at least one of these keywords (case-insensitive, matches both ASCII and accented Unicode forms). Leave empty to get all new domains. Examples: immo, renov, agence, avocat, coach.

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

Maximum number of domain items to return across all TLDs and days. 0 or empty = unlimited.

## Actor input object example

```json
{
  "tlds": [
    "fr"
  ],
  "days": 1,
  "keywords": [],
  "maxResults": 0
}
```

# 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 = {
    "tlds": [
        "fr"
    ],
    "days": 1,
    "keywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/new-fr-domains-finder-afnic").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 = {
    "tlds": ["fr"],
    "days": 1,
    "keywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/new-fr-domains-finder-afnic").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 '{
  "tlds": [
    "fr"
  ],
  "days": 1,
  "keywords": []
}' |
apify call fit_melon/new-fr-domains-finder-afnic --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fit_melon/new-fr-domains-finder-afnic",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New .fr Domains Finder (AFNIC Daily Registrations)",
        "description": "Daily list of newly registered .fr, .re, .pm, .tf, .wf and .yt domains straight from AFNIC official open data. Filter by keywords to detect new French businesses, protect your brand from cybersquatting, and feed your B2B prospecting pipeline. Free, official, unbreakable source.",
        "version": "0.0",
        "x-build-id": "MFYCapDvejWmeLhqt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fit_melon~new-fr-domains-finder-afnic/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fit_melon-new-fr-domains-finder-afnic",
                "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/fit_melon~new-fr-domains-finder-afnic/runs": {
            "post": {
                "operationId": "runs-sync-fit_melon-new-fr-domains-finder-afnic",
                "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/fit_melon~new-fr-domains-finder-afnic/run-sync": {
            "post": {
                "operationId": "run-sync-fit_melon-new-fr-domains-finder-afnic",
                "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": {
                    "tlds": {
                        "title": "TLDs (AFNIC zones)",
                        "type": "array",
                        "description": "Which AFNIC-managed extensions to fetch. Supported: fr, re, pm, tf, wf, yt.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fr",
                                "re",
                                "pm",
                                "tf",
                                "wf",
                                "yt"
                            ],
                            "enumTitles": [
                                ".fr (France)",
                                ".re (Réunion)",
                                ".pm (Saint-Pierre-et-Miquelon)",
                                ".tf (Terres australes)",
                                ".wf (Wallis-et-Futuna)",
                                ".yt (Mayotte)"
                            ]
                        },
                        "default": [
                            "fr"
                        ]
                    },
                    "days": {
                        "title": "Days to look back (1–7)",
                        "minimum": 1,
                        "maximum": 7,
                        "type": "integer",
                        "description": "How many past days of registrations to fetch, starting from yesterday. AFNIC keeps a 7-day rolling window.",
                        "default": 1
                    },
                    "keywords": {
                        "title": "Keyword filter (optional)",
                        "type": "array",
                        "description": "Only return domains containing at least one of these keywords (case-insensitive, matches both ASCII and accented Unicode forms). Leave empty to get all new domains. Examples: immo, renov, agence, avocat, coach.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of domain items to return across all TLDs and days. 0 or empty = unlimited.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
