# South Africa Government Tenders & Awards (eTenders) (`dottti/south-africa-tender-radar`) Actor

Open South African government tenders and awarded contracts from the National Treasury eTenders portal as clean JSON: organ of state, province, category, closing time, briefing session, document links, winning company and award value in ZAR. Keyword and province filters, new-only alerts.

- **URL**: https://apify.com/dottti/south-africa-tender-radar.md
- **Developed by:** [Dottti](https://apify.com/dottti) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 tender delivereds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## South Africa Government Tenders & Awards (eTenders)

Get open South African government tenders and awarded contracts from the National Treasury eTenders portal (etenders.gov.za) as clean JSON, CSV or Excel. National and provincial departments, municipalities and state companies such as Eskom and Transnet publish their tenders there.

Filter by keyword, province, organ of state, category and closing date. Schedule it every morning and you have a tender alert feed for your sector.

- **Planned price:** $5.00 per 1,000 tenders and $12.00 per 1,000 awards. You pay only for records that pass your filters. `maxItems` caps the cost of any run.
- **First run:** click **Start** with the default input. You get the 20 newest open tenders, with document links, in under 10 seconds.

### Who uses this

- **Suppliers and contractors** get a daily list of new tenders in their province and category.
- **Bid teams** see the closing time, the compulsory briefing session and the bid documents in one row.
- **Market analysts** see which companies win, with which organs of state, and for how much.

### What you get

Two record types share one dataset. The `recordType` field tells them apart.

#### Tender (`recordType: "tender"`)

Taken from a real run on 5 November 2026:

```json
{
  "recordType": "tender",
  "tenderId": 176921,
  "tenderNumber": "KZNB 65P 2026/27",
  "title": "APPOINTMENT OF THE SERVICE PROVIDER TO SUPPLY AND DELIVER MOTOR VEHICLE.",
  "organOfState": "Kwazulu Natal - Office of the Premier",
  "province": "KwaZulu-Natal",
  "category": "Supplies: General",
  "tenderType": "Request for Bid(Open-Tender)",
  "status": "Published",
  "publishedDate": "2026-11-05",
  "closingAt": "2026-11-27T11:00:00+02:00",
  "daysLeft": 21,
  "briefingSession": false,
  "deliveryLocation": "300 LANGALIBALELE STREET-PIETERMARITZBURG CENTRAL-PIETERMARITZBURG-3201",
  "bidValidityDays": 180,
  "documents": [
    {
      "title": "MOTOR VEHICLE ADVERT.pdf",
      "url": "https://www.etenders.gov.za/home/Download?blobName=77402b43-9d85-468c-a4a0-3a8a325fbeeb.pdf&downloadedFileName=MOTOR%20VEHICLE%20ADVERT.pdf"
    }
  ],
  "currency": "ZAR"
}
```

#### Award (`recordType: "award"`)

One row per winning company. A tender with three winners gives three rows.

```json
{
  "recordType": "award",
  "tenderNumber": "SO/VO/08/11/206",
  "title": "VO - Construction of PV Solar Plant at SANSA - Hartebeesthoek Site",
  "organOfState": "South African National Space Agency",
  "province": "Gauteng",
  "category": "Services: Electrical",
  "tenderType": "Restricted Bidding",
  "winner": "NEWTHINGS LEFATSHE",
  "enterpriseType": "GEN",
  "awardDate": "2026-11-05",
  "awardValueZar": 23612431,
  "awardValueText": "R23 612 431,00",
  "winnersOnTender": 1
}
```

Notes on the fields:

- Text fields keep the wording exactly as the buyer published it. You can search eTenders for any of it.
- `closingAt` and `briefingAt` are South African time (UTC+2) in ISO 8601.
- `awardValueZar` is the published award value as a number. `awardValueText` keeps the original text. Some awards show `R0,00` or `R1,00`. In those cases the buyer did not publish a total value.
- `enterpriseType` is the size class the buyer recorded for the winner, for example `EME` (exempted micro enterprise), `QSE` or `GEN`.
- `documents` links straight to each bid document.

### Input

| Field | What it does |
| --- | --- |
| `recordTypes` | `tenders`, `awards` or both. |
| `keywords` | Matched against description, tender number, organ of state, category and winner. Case is ignored. |
| `provinces` | For example `Gauteng`, `Western Cape`, `KwaZulu-Natal`. `National` covers national departments and state companies. |
| `tenderTypes` | For example `Request for Bid(Open-Tender)`, `Request for Quotation`, `Request for Proposal`. |
| `organContains`, `categoryContains`, `winnerContains` | Text filters, for example `eskom`, `construction`. |
| `closingWithinDays` | Open tenders that close within N days. |
| `minAwardValueZar` | Awards at or above this value in rand. |
| `publishedWithinDays`, `publishedSince` | Date window. Awards default to the last 30 days. |
| `includeContactDetails` | Adds the contact person, email and phone the buyer published for bid questions. Off by default. |
| `onlyNew`, `stateKey` | Daily alert mode. Records delivered before are skipped. |
| `maxItems` | Cap per record type, newest first. This is also your cost cap. |

#### Example: solar and electrical tenders in Gauteng and the Western Cape

```json
{
  "keywords": ["solar", "electrical"],
  "provinces": ["Gauteng", "Western Cape"],
  "maxItems": 100
}
```

#### Example: awards above R1 million in the last 30 days

```json
{
  "recordTypes": ["awards"],
  "minAwardValueZar": 1000000,
  "publishedWithinDays": 30,
  "maxItems": 200
}
```

### Daily alert in 3 steps

1. Set your filters and turn on `onlyNew`.
2. Click **Save as a new task**, then add a daily schedule.
3. Connect the task to email, Slack or Google Sheets from the **Integrations** tab.

### Status rows and run summary

Every run ends with status SUCCEEDED when the input can be read. Problems come back as free rows with `recordType: "status"`:

- `bad_input`: a value in your input is wrong, for example an unknown province. Nothing is fetched or charged.
- `no_results` or `no_new_results`: the filters matched nothing.
- `failed`: the portal did not answer after retries. Records delivered before the failure are kept.

The `RUN_SUMMARY` record in the key-value store lists the rows read, the rows matched, the rows skipped and the requests made.

### Need a custom scraper or a source we don't cover?

We build and maintain data Actors for government tenders, contract awards and business data, with 80+ public Actors on this account across the Gulf, the Middle East and beyond. If you need another country's portal, extra fields, a different output format or a ready scheduled feed for your team, open an issue on this Actor's **Issues** tab: name the source, the fields you need and how often. We reply there with what we can build, how long it takes and a fixed price.

### Pricing

Pay per record delivered to your dataset. Status rows are free. Platform usage is included in the price. When you set a maximum cost per run, the Actor stops at that limit and keeps what it already delivered.

### Notes and limits

- Data comes from the public tender list on etenders.gov.za. No login.
- About 2,000 tenders are open at any time. All of them fit in 40 pages, so keyword filters see the whole open list.
- The portal fails to serve a few awarded records. The Actor reads those pages one row at a time and skips the broken rows. The run log and `RUN_SUMMARY` give the count.
- Award contact people and the uploader's login are never returned.
- Fields the buyer leaves empty or marks N/A come back as `null`.

# Actor input Schema

## `recordTypes` (type: `array`):

Tenders are open notices you can still bid on. Awards are tenders marked Awarded, with the winning company and the award value.

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

Words matched against the tender description, tender number, organ of state, category and, for awards, the winner. Case is ignored. Examples: solar, security services, catering, ICT.

## `matchMode` (type: `string`):

any: at least one keyword. all: every keyword.

## `provinces` (type: `array`):

Keep records from these provinces. National covers national departments and state companies.

## `tenderTypes` (type: `array`):

Keep these tender types only, for example Request for Bid(Open-Tender) or Request for Quotation.

## `organContains` (type: `string`):

Keep records whose organ of state or department contains this text, for example eskom, transnet or city of cape town.

## `categoryContains` (type: `string`):

Keep records whose category contains this text, for example construction or services: electrical.

## `winnerContains` (type: `string`):

Keep awards whose winning company name contains this text.

## `minAwardValueZar` (type: `integer`):

Keep awards whose published award value is at least this many rand.

## `closingWithinDays` (type: `integer`):

Keep open tenders that close within this many days. Leave empty for all open tenders.

## `publishedWithinDays` (type: `integer`):

Tenders: leave empty for every open tender. Awards: default window is the last 30 days.

## `publishedSince` (type: `string`):

Date in YYYY-MM-DD format. Overrides the N days setting.

## `includeContactDetails` (type: `boolean`):

Contact person, email and phone that the buyer published for bid questions. Some are personal: only turn it on if you have a lawful reason to process them.

## `onlyNew` (type: `boolean`):

Remember delivered IDs and skip them next time. Use it with a daily schedule for alerts.

## `stateKey` (type: `string`):

Separate memory for each alert when you run several schedules with onlyNew.

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

Hard cap on delivered tenders and, separately, on delivered awards, newest first. You pay per record delivered, so this is also your cost cap.

## `maxPages` (type: `integer`):

Tender pages hold 50 rows, award pages 10. About 2,000 open tenders fit in 40 pages.

## `requestDelayMs` (type: `integer`):

Pause before each request. Never lower than 1000 ms.

## `maxRetries` (type: `integer`):

Retries with backoff when the portal fails or asks to slow down.

## Actor input object example

```json
{
  "recordTypes": [
    "tenders"
  ],
  "matchMode": "any",
  "includeContactDetails": false,
  "onlyNew": false,
  "stateKey": "default",
  "maxItems": 20,
  "maxPages": 60,
  "requestDelayMs": 1000,
  "maxRetries": 3
}
```

# Actor output Schema

## `records` (type: `string`):

Tenders with closing time, briefing and documents; awards with winning company and award value in ZAR.

## `summary` (type: `string`):

Lists read, rows read, rows skipped and matched, delivered counts, requests and any failure.

# 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 = {
    "recordTypes": [
        "tenders"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("dottti/south-africa-tender-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 = {
    "recordTypes": ["tenders"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("dottti/south-africa-tender-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "recordTypes": [
    "tenders"
  ],
  "maxItems": 20
}' |
apify call dottti/south-africa-tender-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dottti/south-africa-tender-radar"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dCiX6rcJW0MvCXs57/builds/tmmr2PQ6vrGoofuCJ/openapi.json
