# Swedish Public Procurement Radar (TED) (`fabriken2026/swedish-procurement-radar`) Actor

Find active Swedish public procurement tenders live from TED, the EU's official database — never hallucinated. Search by CPV code, keyword or region; get buyer, deadline and the official notice link in clean JSON. Deadline-sorted, Sweden-locked, deterministic.

- **URL**: https://apify.com/fabriken2026/swedish-procurement-radar.md
- **Developed by:** [David](https://apify.com/fabriken2026) (community)
- **Categories:** Automation, Developer tools
- **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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Swedish Public Procurement Radar (TED)

**Verified official source - never hallucinated.** Every tender this
Actor returns comes live from **TED (Tenders Electronic Daily)**, the
EU's official procurement database - not from an AI summary, not from a
scraped portal, not from a stale index.

### Why this Actor?

The Swedish public sector buys for hundreds of billions of SEK every
year, and the tenders are announced in TED. LLMs know nothing about
tenders published yesterday, generic AI web search cannot reliably list
what is open right now, and scraping procurement portals breaks
constantly. This Actor queries TED's official open API directly and
returns clean, structured results your sales agent or monitoring
workflow can act on - deadline-sorted, Sweden-locked and deterministic.

### Features

- **Find active Swedish public procurement tenders** - open notices from
  the official EU database, sorted most-urgent-deadline first.
- **Search Swedish government tenders by CPV code** (e.g. `72` = IT
  services, `45` = construction) - 2 to 8 digits, broad or precise.
- **Search public tenders by keyword** - free text, sanitised before it
  reaches TED's query language (injection-safe).
- **Filter tenders by Swedish region** - optional NUTS code, e.g. `SE11`
  for Stockholm.
- **Get buyer, deadline and the official notice link** for every hit -
  everything a bid/no-bid decision needs, in one JSON row.
- **Sweden-locked at the query level** - the search always filters on
  Swedish buyers and cannot be tricked into other markets.
- **Live at the source, no AI in the loop** - same query, same behaviour,
  fetched from TED at search time.

### Use cases

- **Daily tender monitoring for your industry:** schedule one search per
  CPV category you sell into and get new tenders to webhook, e-mail or
  your CRM (about $12/month for a daily radar).
- **Sales agents that hunt public contracts:** let an AI agent watch
  procurement in your niche and draft a bid/no-bid summary per tender.
- **Bid management pipelines:** feed deadline-sorted tenders straight
  into your task system so nothing expires unnoticed.
- **Market analysis:** which Swedish authorities are buying what, and
  how often - grounded in official notices.
- **Consultancy and reseller prospecting:** a fresh, legal source of
  high-intent leads (a published tender is a budget with a deadline).

### Input

```json
{
    "cpvCode": "72",
    "keywords": "cloud",
    "region": "SE11",
    "onlyActive": true,
    "maxResults": 20
}
````

Provide `cpvCode` (2-8 digits) and/or `keywords`. `region` is an optional
Swedish NUTS code (`SE11` = Stockholm). Max 50 results per search.

### Output (dataset items)

```json
{
    "title": "Sverige - IT-tjänster - Nytt verksamhetssystem",
    "buyer": "Exempelstads kommun",
    "cpvCodes": ["72000000", "72268000"],
    "tenderDeadline": "2026-08-15",
    "published": "2026-07-01",
    "publicationNumber": "111111-2026",
    "tedUrl": "https://ted.europa.eu/sv/notice/-/detail/111111-2026",
    "source": "TED - Tenders Electronic Daily (ted.europa.eu)"
}
```

Always verify deadlines and requirements in the official notice (the
`tedUrl` link) before submitting a bid.

### Pricing (pay-per-event)

| Event | Price | When |
|---|---|---|
| `procurement-search` | $0.40 | Per successful search (up to 50 results) |

One search returns up to 50 tenders - $0.40 flat, not per result. Invalid
searches are free. A daily monitoring schedule costs about $12/month;
twice daily about $24/month. No subscription, no minimum. Compare that
with commercial tender-alert services that start at thousands of SEK per
year for the same public notices.

**Tip:** combine with Apify Schedules to get a daily radar for your CPV
categories, delivered to webhook, e-mail or your own agent.

### FAQ

**How do I find Swedish government tenders for free?**
The notices are public on ted.europa.eu, but the search UI is built for
humans, not pipelines. This Actor gives you the same official data as
structured JSON for $0.40 per search - cheap enough to automate daily.

**Which tenders are included?**
Everything Swedish in TED: tenders **above the EU thresholds** plus
voluntarily published ones. Small below-threshold Swedish tenders may be
missing - that is a property of the source, stated honestly.

**What is a CPV code?**
The EU's common procurement vocabulary - a numeric taxonomy of what is
being bought. Two digits is a whole sector (`72` = IT services); more
digits narrow it down. You can combine a CPV filter with keywords.

**Can I get notified about new tenders automatically?**
Yes: put this Actor on an Apify Schedule and attach a webhook or e-mail
integration. New results land in your inbox, Slack or CRM without any
manual searching.

**Can my AI agent use this?**
Yes - via the Apify API or MCP. The output is compact JSON with the
official notice link, so the agent can cite its source instead of
guessing what might be procured somewhere.

**Is the data really live?**
Every search hits TED's Search API v3 at run time. If a notice was
published this morning and matches your query, it is in your results.

### Privacy (GDPR by design)

Contact persons and other personal data that may appear in notices are
**never requested from the source and never returned** - organisation-
level data only.

### Permissions & security

This Actor runs with Apify's **limited permissions** model: it reads its
own input, writes to its own default dataset and calls TED's open API
over HTTPS - nothing else. No API key is needed anywhere, and it requests
no access to your other Actors, storages or account data.

### Data source & license

Data comes from **TED - Tenders Electronic Daily** (ted.europa.eu), the
official journal of EU public procurement, via its open Search API v3.
Reuse is free, including for commercial purposes, under Commission
Decision 2011/833/EU; the notice metadata license is CC0 1.0. TED is
credited as the source in every result. This Actor is independent and not
affiliated with or endorsed by the European Union.

### Terms of use

- **Business use only.** This Actor is intended exclusively for use in the
  course of business (B2B). By using it you confirm you are acting as a
  business, not a consumer.
- **As is.** The service and all data are provided "as is", without
  warranties of any kind - no guarantee of accuracy, completeness,
  timeliness or availability. A missed tender or deadline based on data
  from this service is not compensated.
- **Liability cap.** Total aggregate liability for all claims in any
  12-month period is limited to the amount you paid for the service in
  that period. No liability for indirect or consequential damages, lost
  profits, lost business opportunities (including missed bid deadlines) or
  lost data. Nothing in these terms limits liability that cannot lawfully
  be limited.
- **Fair use.** No bulk re-selling of raw data, no circumventing rate
  limits, no use that violates TED's terms.

### Versioning & support

Versions are locked - the Actor never silently changes behaviour under
you. Changes are released as new versions with a changelog entry.

Part of the **Swedish Data Tools** family: company lookup, company
financials, new company registrations, public procurement search and
official statistics - all built on official Swedish and EU data sources.

#### Changelog

- **0.1** - initial release: CPV/keyword/region search of active Swedish
  tenders on TED, deadline-sorted, pay-per-search pricing.

# Actor input Schema

## `cpvCode` (type: `string`):

EU procurement category code, 2-8 digits. Shorter codes match whole categories: <code>72</code> = IT services, <code>45</code> = construction, <code>90</code> = environmental services. Provide a CPV code and/or keywords.

## `keywords` (type: `string`):

Free-text search in the notices, e.g. <code>skolskjuts</code> or <code>cloud</code>. Letters, digits, spaces and hyphens only - other characters are stripped for safety.

## `region` (type: `string`):

Optional place-of-performance filter: <code>SE</code> whole country, <code>SE11</code> Stockholm, <code>SE22</code> South Sweden, etc.

## `onlyActive` (type: `boolean`):

Only return tenders whose submission deadline has not yet passed (sorted by deadline, most urgent first).

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

How many tenders to return (1-50).

## Actor input object example

```json
{
  "cpvCode": "72",
  "onlyActive": true,
  "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 = {
    "cpvCode": "72"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabriken2026/swedish-procurement-radar").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 = { "cpvCode": "72" }

# Run the Actor and wait for it to finish
run = client.actor("fabriken2026/swedish-procurement-radar").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 '{
  "cpvCode": "72"
}' |
apify call fabriken2026/swedish-procurement-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fabriken2026/swedish-procurement-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swedish Public Procurement Radar (TED)",
        "description": "Find active Swedish public procurement tenders live from TED, the EU's official database — never hallucinated. Search by CPV code, keyword or region; get buyer, deadline and the official notice link in clean JSON. Deadline-sorted, Sweden-locked, deterministic.",
        "version": "0.1",
        "x-build-id": "FwezcaLqaYUMccISX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabriken2026~swedish-procurement-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabriken2026-swedish-procurement-radar",
                "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/fabriken2026~swedish-procurement-radar/runs": {
            "post": {
                "operationId": "runs-sync-fabriken2026-swedish-procurement-radar",
                "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/fabriken2026~swedish-procurement-radar/run-sync": {
            "post": {
                "operationId": "run-sync-fabriken2026-swedish-procurement-radar",
                "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": {
                    "cpvCode": {
                        "title": "CPV code",
                        "type": "string",
                        "description": "EU procurement category code, 2-8 digits. Shorter codes match whole categories: <code>72</code> = IT services, <code>45</code> = construction, <code>90</code> = environmental services. Provide a CPV code and/or keywords."
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Free-text search in the notices, e.g. <code>skolskjuts</code> or <code>cloud</code>. Letters, digits, spaces and hyphens only - other characters are stripped for safety."
                    },
                    "region": {
                        "title": "Region (Swedish NUTS code)",
                        "type": "string",
                        "description": "Optional place-of-performance filter: <code>SE</code> whole country, <code>SE11</code> Stockholm, <code>SE22</code> South Sweden, etc."
                    },
                    "onlyActive": {
                        "title": "Only active tenders",
                        "type": "boolean",
                        "description": "Only return tenders whose submission deadline has not yet passed (sorted by deadline, most urgent first).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many tenders to return (1-50).",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```