# New French Public Contracts Finder (DECP) (`fit_melon/new-french-public-contracts-finder-decp`) Actor

Find newly awarded French public contracts from official DECP open data. Get each winner's SIREN/SIRET, the public buyer, amount, CPV code, award date & department. Discovery + bulk-SIRET modes. Weekly-fresh B2B leads & tender monitoring. Free.

- **URL**: https://apify.com/fit\_melon/new-french-public-contracts-finder-decp.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Business, Lead generation
- **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 French Public Contracts Finder (DECP) 🇫🇷

**Find newly awarded French public contracts (marchés publics attribués) from official open data — and get the winning company behind each one.** This actor queries the government DECP dataset (*Données Essentielles de la Commande Publique*) and returns clean, structured records: the winning supplier (SIREN / SIRET), the public buyer, the amount, the CPV code, the award date and the department. **Free** — you only pay your own Apify platform usage.

Every French public buyer (collectivités, ministères, hôpitaux, établissements publics) is legally required to publish the essential data of its awarded contracts, so this source is official, exhaustive and effectively unbreakable. New awards appear continuously, which makes this a **weekly lead-generation and market-monitoring** tool, not a one-off lookup: the companies that just won a contract are active, funded and ready to talk.

Keywords: French public contracts, marchés publics, DECP, appels d'offres attribués, commande publique, public procurement France, tender winners, government contracts open data, B2B lead generation France, SIRET, SIREN.

### What it does

- **Discovery mode** — pull the most recently awarded contracts, filtered by award date, department, CPV code prefix, keyword and minimum amount.
- **Bulk lookup mode** — paste a list of supplier SIRETs and get every public contract each company has won (one `not_found` row for SIRETs with no contract).
- Resolves each winner's **SIREN** and gives you a ready-made link to enrich it further.

### Input

| Field | Type | Description |
|---|---|---|
| `dateNotificationMin` | string (YYYY-MM-DD) | Only contracts awarded on/after this date. Default `2024-01-01`. |
| `dateNotificationMax` | string (YYYY-MM-DD) | Optional upper bound on the award date. |
| `departement` | string | Optional department code of the place of performance or buyer (e.g. `59`, `75`, `2A`, `974`). |
| `cpvPrefix` | string | Optional CPV code prefix (e.g. `45` works, `72` IT). |
| `keyword` | string | Optional keyword matched against object / buyer / winner. |
| `minAmount` | integer | Optional minimum awarded amount in euros. |
| `supplierSirets` | array | Optional bulk mode: list of winner SIRETs to look up. Overrides discovery mode. |
| `maxResults` | integer | Cap on returned rows (per SIRET in bulk mode). Default `100`. |

All fields are optional — running with defaults returns recent awarded contracts.

### Output

One dataset item **per contract × winner**, each with an explicit `status` (`found` / `not_found` / `error`). A contract with several co-winners produces one row per winner (`supplierRank` 1–3), sharing the same contract fields:

```json
{
  "status": "found",
  "marketId": "2024-XYZ-0001",
  "uid": "213105554000132024-XYZ-0001",
  "object": "Travaux de rénovation énergétique de groupes scolaires",
  "amount": 485000,
  "cpvCode": "45214210",
  "procedure": "Procédure adaptée",
  "notificationDate": "2024-06-14",
  "publicationDate": "2024-06-20",
  "buyerSiret": "21310555400013",
  "supplierSiret": "39284712300025",
  "supplierSiren": "392847123",
  "supplierIdType": "SIRET",
  "supplierRank": 1,
  "department": "31",
  "annuaireEntreprisesUrl": "https://annuaire-entreprises.data.gouv.fr/entreprise/392847123"
}
````

> **Names:** the official DECP source identifies buyers and winners by **SIRET only** — company names are not part of the mandatory essential data. Resolve them in one step with the **[French Company Data Enricher (SIREN)](https://apify.com/fit_melon/french-company-data-enricher-siren-dirigeants-sirene)** using the `supplierSiren` field. `amount` is the total awarded contract amount, not a per-winner split.

### Use cases

- **B2B prospecting** — build weekly lists of companies that just won public contracts in your sector or region.
- **Competitive intelligence** — track which suppliers win which buyers, and at what amounts.
- **Market & tender monitoring** — watch a department or CPV segment for fresh awards.
- **Supplier due diligence** — pull a company's public-contract history from its SIRET.

### Limitations & fair use

- Source: official **DECP** open data via `data.economie.gouv.fr` (dataset `decp-2022-marches-valides`), published under **Licence Ouverte 2.0**. Coverage depends on buyers publishing their data; recent awards can take a few weeks to appear.
- The actor returns the initial award record; amounts may be revised later by amendments (avenants).
- Please keep runs reasonable and respect the source; a polite delay is applied between requests.

### More actors by this developer

Part of an integrated **French business-data pipeline** — find → enrich → verify:

- **[French Company Data Enricher (SIREN)](https://apify.com/fit_melon/french-company-data-enricher-siren-dirigeants-sirene)** — feed a winner's SIREN to get full company details & directors.
- **[New French Companies Finder (SIRENE)](https://apify.com/fit_melon/new-french-companies-finder-sirene)** — freshly registered French companies for prospecting.
- **[French Legal Notices Scraper](https://apify.com/fit_melon/french-legal-notices-scraper-mentions-legales)** — extract legal / contact info from company websites.
- **[EU VAT Number Validator (VIES)](https://apify.com/fit_melon/eu-vat-number-validator-vies)** — validate EU VAT numbers before invoicing.
- **[Bulk Email Verifier & List Cleaner](https://apify.com/fit_melon/bulk-email-verifier-list-cleaner)** — clean your outreach lists.

👉 See all actors: **[apify.com/fit\_melon](https://apify.com/fit_melon)**

# Actor input Schema

## `dateNotificationMin` (type: `string`):

Only return contracts notified (awarded) on or after this date. Leave the default for a stable test; set to a recent date for weekly lead-generation runs.

## `dateNotificationMax` (type: `string`):

Optional upper bound on the award (notification) date.

## `departement` (type: `string`):

Optional. Filter by French department code of the place of performance or the buyer (e.g. 59, 75, 2A, 974).

## `cpvPrefix` (type: `string`):

Optional. Keep only contracts whose CPV code starts with this prefix (e.g. 45 for construction works, 72 for IT services).

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

Optional. Keep only contracts whose object, buyer or winner name contains this keyword (case-insensitive).

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

Optional. Only return contracts with an awarded amount greater than or equal to this value.

## `supplierSirets` (type: `array`):

Optional bulk mode. Paste a list of company SIRET numbers to retrieve the public contracts each one has won. Overrides discovery mode. One result row per contract; SIRETs with no contract return a 'not\_found' item.

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

Maximum number of contract rows to return (in discovery mode) or per SIRET (in bulk mode).

## Actor input object example

```json
{
  "dateNotificationMin": "2024-01-01",
  "supplierSirets": [],
  "maxResults": 20
}
```

# 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 = {
    "dateNotificationMin": "2024-01-01",
    "supplierSirets": [],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/new-french-public-contracts-finder-decp").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 = {
    "dateNotificationMin": "2024-01-01",
    "supplierSirets": [],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/new-french-public-contracts-finder-decp").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 '{
  "dateNotificationMin": "2024-01-01",
  "supplierSirets": [],
  "maxResults": 20
}' |
apify call fit_melon/new-french-public-contracts-finder-decp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "New French Public Contracts Finder (DECP)",
        "description": "Find newly awarded French public contracts from official DECP open data. Get each winner's SIREN/SIRET, the public buyer, amount, CPV code, award date & department. Discovery + bulk-SIRET modes. Weekly-fresh B2B leads & tender monitoring. Free.",
        "version": "0.0",
        "x-build-id": "vapTDAvPGKVX4uDgV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fit_melon~new-french-public-contracts-finder-decp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fit_melon-new-french-public-contracts-finder-decp",
                "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-french-public-contracts-finder-decp/runs": {
            "post": {
                "operationId": "runs-sync-fit_melon-new-french-public-contracts-finder-decp",
                "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-french-public-contracts-finder-decp/run-sync": {
            "post": {
                "operationId": "run-sync-fit_melon-new-french-public-contracts-finder-decp",
                "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": {
                    "dateNotificationMin": {
                        "title": "Awarded on or after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only return contracts notified (awarded) on or after this date. Leave the default for a stable test; set to a recent date for weekly lead-generation runs.",
                        "default": "2024-01-01"
                    },
                    "dateNotificationMax": {
                        "title": "Awarded on or before (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional upper bound on the award (notification) date."
                    },
                    "departement": {
                        "title": "Department code",
                        "type": "string",
                        "description": "Optional. Filter by French department code of the place of performance or the buyer (e.g. 59, 75, 2A, 974)."
                    },
                    "cpvPrefix": {
                        "title": "CPV code prefix",
                        "type": "string",
                        "description": "Optional. Keep only contracts whose CPV code starts with this prefix (e.g. 45 for construction works, 72 for IT services)."
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional. Keep only contracts whose object, buyer or winner name contains this keyword (case-insensitive)."
                    },
                    "minAmount": {
                        "title": "Minimum amount (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional. Only return contracts with an awarded amount greater than or equal to this value."
                    },
                    "supplierSirets": {
                        "title": "Winner SIRETs (bulk lookup)",
                        "type": "array",
                        "description": "Optional bulk mode. Paste a list of company SIRET numbers to retrieve the public contracts each one has won. Overrides discovery mode. One result row per contract; SIRETs with no contract return a 'not_found' item.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of contract rows to return (in discovery mode) or per SIRET (in bulk mode).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
