# Nobel Prize Laureates and Prizes by Year, Category, Country (`yadroo/nobel-prize-laureates`) Actor

Nobel laureates and prizes from the official keyless Nobel Prize API as rows: award year, category, laureate, motivation, prize share, amount, affiliation, birth and death place, age at award, Wikipedia link. Filter by year, category, birth country, gender, name. For newsrooms, teachers and agents.

- **URL**: https://apify.com/yadroo/nobel-prize-laureates.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** Education, News, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 laureate or prize rows

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

Nobel laureates and prizes from the official keyless Nobel Prize API as rows: award year, category, laureate, motivation, prize share, amount, affiliation, birth and death place, age at award and Wikipedia link. Filter by year range, category, birth country, gender or name. UTC dates.

Every Nobel Prize since 1901 as a flat table, read from the Nobel Foundation's own API (`api.nobelprize.org`, version 2.1) and published under CC0. Pick what one row stands for: **one row per laureate and award** — name, year, category, the committee's motivation, the share of the prize, the institution the laureate worked at, birth and death place, age at the award, Wikipedia and Wikidata links — or **one row per prize**, with the laureates of that year and category joined into one line. Built for newsrooms during prize week, teachers and quiz builders, university and country reporting, dashboards, and agents that need a short factual answer.

No API key, no account, no proxy and no browser: the source is a public JSON API and this actor reads nothing else.

> **Need it tailored to your workflow?** Missing a field, a filter, another source or a different output format? [Open an issue](https://apify.com/yadroo/nobel-prize-laureates/issues) and describe what you need — we read every request and adapt the actor.

### Use cases

- **Prize-week newsroom table**: run it on the announcement days with `yearFrom`/`yearTo` set to the current year and `onlyNew` on, and a scheduled task hands you exactly the laureates announced since your last run — name, category, motivation, affiliation, age.
- **Teaching and quiz material per field**: one category over a long window (`categories: ["Physics"]`, `yearFrom: 1901`) gives a ready question bank with the official citation text for every answer.
- **Women laureates report**: `gender: "female"` with `laureateType: "person"` returns every woman ever awarded, newest first, with field, year and birth country — the figure every equality report and prize-week explainer needs.
- **"Our laureates" page for a country or a university**: `birthCountries` cuts by place of birth and gives both the historical and the modern country name, so your count does not quietly mix Prussia with Poland; `affiliationName` gives the institution side.
- **Charts and year-by-year tables**: `mode: "prizes"` returns one row per year and category with the laureate names, the shared motivation and the prize money in Swedish kronor, nominal and inflation adjusted.
- **An agent answering factual questions**: "who won the Nobel Prize in Physics in 1965, and for what" is one call with `categories`, `yearFrom`, `yearTo` and `maxItems: 10`.

### Input

No field is required: an empty input returns the most recent laureates of every category, newest first.

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `mode` | string (enum) | `laureates` | `laureates` = one row per laureate and award (a two-time laureate gives two rows, with the biographical columns); `prizes` = one row per year and category, laureates joined into lists. Strict: the platform refuses any other value before the run starts. |
| `categories` | string\[] (enum) | all six | `Chemistry`, `Economic Sciences`, `Literature`, `Peace`, `Physics`, `Physiology or Medicine` — see [Prize categories](#prize-categories). Several values are combined with OR. Strict list: an off-list value is refused by the platform with an error naming the six, so write them exactly as above. |
| `yearFrom` | integer | `1901` | Earliest award year, inclusive. Sent to the source, so a narrow range is the cheapest filter there is. Prefilled with `2015`. |
| `yearTo` | integer | current year | Latest award year, inclusive. Set both years to the same number for a single year. Prefilled with `2026`. |
| `birthCountries` | string\[] | none | Free text, up to 10 values, matched against a list of 119 country names the source uses — see [Birth countries](#birth-countries). Case, extra spaces, missing diacritics and the listed aliases are accepted (`usa`, `United States`, `UK`, `netherlands`, `Deutschland`); any other spelling is refused with the closest names instead of returning a different country. Ignored in `prizes` mode. |
| `gender` | string (enum) | all | `female` or `male`, the two values the source records. Empty = every laureate. Organizations carry no gender and drop out when this is set. Strict list. Ignored in `prizes` mode. |
| `laureateType` | string (enum) | `all` | `all`, `person` or `organization`. The source has no parameter for this, so the actor applies it to the rows. Strict list. Ignored in `prizes` mode. |
| `nameContains` | string | none | Keep only laureates whose name contains this text, matched case-, space- and accent-insensitively (`curie`, `red cross`, `maria`). Applied to the rows, not by the source — pair it with a year range or a category. |
| `sort` | string (enum) | `yearDesc` | `yearDesc` (newest award year first) or `yearAsc`. Decides which rows you get when `maxItems` cuts the answer. With several `birthCountries` the rows come country by country, ordered by year inside each country (see [Birth countries](#birth-countries)). Strict list. |
| `onlyNew` | boolean | `false` | Remember the rows this run wrote and, on the next run of the same actor or task, write only rows that were not written before. Built for watching the October announcements. |
| `maxItems` | integer | `50` | 1–1000. Hard cap on the rows written, and therefore on what the run costs. |
| `fields` | string\[] | all | Keep only these columns, **in this order**. `awardYear`, `category`, `url`, `fetchedAt` and `sourceMode` are always kept and come first unless you list them — name one of them here and it moves to the position you gave it. A name this mode has no column for is reported in the status message instead of being dropped in silence. |

### Reference

#### Prize categories

The six categories are an enum field: the platform checks the value before the run starts, so a misspelling never reaches the actor — it is refused with the list of allowed values. Write them as printed here. Each row carries the same words in its `category` column.

| `categories` value | Official name (`categoryFullName`) | Source code | Prize page slug | Note |
|---|---|---|---|---|
| `Chemistry` | The Nobel Prize in Chemistry | `che` | `chemistry` | since 1901 |
| `Economic Sciences` | The Sveriges Riksbank Prize in Economic Sciences in Memory of Alfred Nobel | `eco` | `economic-sciences` | since 1969 only |
| `Literature` | The Nobel Prize in Literature | `lit` | `literature` | since 1901 |
| `Peace` | The Nobel Peace Prize | `pea` | `peace` | the only category awarded to organizations |
| `Physics` | The Nobel Prize in Physics | `phy` | `physics` | since 1901 |
| `Physiology or Medicine` | The Nobel Prize in Physiology or Medicine | `med` | `medicine` | the official name of what is usually called the medicine prize |

The `url` column of every row is the prize page of that year and category, built from the slug: `https://www.nobelprize.org/prizes/medicine/2025/`.

#### Birth countries

`birthCountries` is free text on purpose. The source records a birth place under the country name it carried **at the time of birth**, so historical names are valid filter values next to today's names, and people type country names loosely. What is accepted: the exact name, a different case, extra or missing spaces and hyphens, missing diacritics (`Osterreich` for `Österreich`), and the aliases listed below. Anything else is refused with a message naming the closest values (`Unknown birthCountries "Germny" (did you mean "Germany"?)`) — a near miss is another country as often as a typo, so the actor never substitutes one for you.

A row matches when **either** the historical name (`birthCountry`) **or** today's name (`birthCountryNow`) is the country you asked for, and the row says which value matched in `requestedBirthCountry`. Asking for `Germany` therefore also finds laureates the source records as born in Prussia, Bavaria or West Germany; asking for `Prussia` finds only those recorded as Prussian.

Each country you name is read and written as its own block, so a run that is cut short still has the countries it finished complete. With one country the rows are ordered by award year throughout; with several, they are ordered by year inside each country, in the order you listed the countries.

**Today's names** (87): `Algeria`, `Argentina`, `Australia`, `Austria`, `Azerbaijan`, `Bangladesh`, `Belarus`, `Belgium`, `Bosnia and Herzegovina`, `Brazil`, `Bulgaria`, `Canada`, `Chile`, `China`, `Colombia`, `Costa Rica`, `Croatia`, `Cyprus`, `Czech Republic`, `Democratic Republic of the Congo`, `Denmark`, `East Timor`, `Egypt`, `Ethiopia`, `Faroe Islands (Denmark)`, `Finland`, `France`, `Germany`, `Ghana`, `Greece`, `Guadeloupe, France`, `Guatemala`, `Hungary`, `Iceland`, `India`, `Indonesia`, `Iran`, `Iraq`, `Ireland`, `Israel`, `Italy`, `Japan`, `Jordan`, `Kenya`, `Latvia`, `Lebanon`, `Liberia`, `Lithuania`, `Luxembourg`, `Madagascar`, `Mexico`, `Morocco`, `Myanmar`, `the Netherlands`, `New Zealand`, `Nigeria`, `North Macedonia`, `Northern Ireland`, `Norway`, `Pakistan`, `Peru`, `Philippines`, `Poland`, `Portugal`, `Romania`, `Russia`, `Saint Lucia`, `Scotland`, `Slovakia`, `Slovenia`, `South Africa`, `South Korea`, `Spain`, `Sweden`, `Switzerland`, `Taiwan`, `Trinidad and Tobago`, `Tunisia`, `Turkey`, `USA`, `Ukraine`, `United Kingdom`, `Venezuela`, `Vietnam`, `Yemen`, `Zimbabwe`.

**Historical names the source still uses** (32): `Austria-Hungary`, `Austrian Empire`, `Bavaria`, `Belgian Congo`, `Bosnia`, `British India`, `British Mandate of Palestine`, `British Protectorate of Palestine`, `British West Indies`, `Burma`, `Crete`, `Czechoslovakia`, `East Friesland`, `Free City of Danzig`, `French Algeria`, `French protectorate of Tunisia`, `German-occupied Poland`, `Gold Coast`, `Hesse-Kassel`, `Java, Dutch East Indies`, `Korea`, `Mecklenburg`, `Ottoman Empire`, `Persia`, `Prussia`, `Russian Empire`, `Schleswig`, `Southern Rhodesia`, `Tibet`, `Tuscany`, `USSR`, `West Germany`, `Württemberg`.

**Aliases accepted** (a selection; two-letter ISO codes work for the countries that have one): `USA` ← `United States`, `United States of America`, `US`, `America`; `United Kingdom` ← `UK`, `GB`, `Great Britain`, `Britain`, `England`; `the Netherlands` ← `Netherlands`, `Holland`, `NL`; `Germany` ← `Deutschland`, `DE`; `Austria` ← `Österreich`, `Osterreich`, `AT`; `Russia` ← `Russian Federation`, `RU`; `Czech Republic` ← `Czechia`, `CZ`; `North Macedonia` ← `Macedonia`, `MK`; `South Korea` ← `Republic of Korea`, `KR`; `Democratic Republic of the Congo` ← `DR Congo`, `DRC`, `CD`; `Turkey` ← `Türkiye`, `TR`; `USSR` ← `Soviet Union`; `West Germany` ← `Federal Republic of Germany`, `FRG`; `Prussia` ← `Kingdom of Prussia`.

#### What the filters do where

| Filter | Applied by |
|---|---|
| `yearFrom`, `yearTo`, one `categories` value, `gender`, one `birthCountries` value | the source, so the run pays only for what it asked for (and the actor re-checks every one of them on the rows) |
| two or more `categories`, `laureateType`, `nameContains`, the historical/modern country match | the actor, on the rows it read (the API has no parameter for them, and it silently ignores a joined category value) |

### Examples

**Prize-week table: everyone announced in the last two years, all categories**

```json
{ "mode": "laureates", "yearFrom": 2025, "yearTo": 2026, "sort": "yearDesc", "maxItems": 25 }
```

**One field over a long window, for teaching or a quiz bank**

```json
{ "mode": "laureates", "categories": ["Chemistry"], "yearFrom": 2010, "yearTo": 2026, "maxItems": 25 }
```

**Every woman awarded a Nobel Prize, newest first**

```json
{ "mode": "laureates", "gender": "female", "laureateType": "person", "sort": "yearDesc", "maxItems": 30 }
```

**The Peace Prizes that went to institutions rather than people**

```json
{ "mode": "laureates", "categories": ["Peace"], "laureateType": "organization", "maxItems": 20 }
```

**Laureates born in one country, with the historical and the modern country name**

```json
{ "mode": "laureates", "birthCountries": ["USA"], "yearFrom": 1990, "maxItems": 20 }
```

**One row per prize, for a chart or a year-by-year table**

```json
{ "mode": "prizes", "yearFrom": 2000, "yearTo": 2026, "sort": "yearDesc", "maxItems": 40 }
```

**Only the citation text, four columns, in that order**

```json
{ "mode": "laureates", "categories": ["Literature"], "yearFrom": 1990, "fields": ["name", "awardYear", "motivation", "birthCountryNow"], "maxItems": 20 }
```

### Output

A real row from a cloud run (`mode: "laureates"`, Chemistry 2015–2026, newest first):

```json
{
  "awardYear": 2026,
  "category": "Chemistry",
  "url": "https://www.nobelprize.org/prizes/chemistry/2026/summary/",
  "fetchedAt": "2026-10-07T21:31:38.340Z",
  "sourceMode": "laureates",
  "name": "Henri B. Kagan",
  "fullName": "Henri B. Kagan",
  "laureateId": "1065",
  "laureateType": "person",
  "gender": "male",
  "motivation": "for the discovery of non-linear effects and autocatalysis in asymmetric organic synthesis",
  "categoryFullName": "The Nobel Prize in Chemistry",
  "portion": "1/2",
  "shareOrder": 1,
  "prizeStatus": "received",
  "dateAwarded": "2026-10-07",
  "prizeAmount": 12000000,
  "prizeAmountAdjusted": 12000000,
  "prizeCount": 1,
  "affiliationName": "Université Paris-Sud",
  "affiliationCity": "Orsay",
  "affiliationCountry": "France",
  "birthDate": "1930-12-15",
  "birthCity": "Boulogne-Billancourt",
  "birthCountry": "France",
  "birthCountryNow": "France",
  "birthContinent": "Europe",
  "deathDate": null,
  "deathCity": null,
  "deathCountry": null,
  "ageAtAward": 95,
  "organizationAcronym": null,
  "laureatePageUrl": "https://www.nobelprize.org/prizes/chemistry/2026/kagan/facts/",
  "wikipediaUrl": "https://en.wikipedia.org/wiki/Henri_B._Kagan",
  "wikidataId": "Q354979",
  "requestedBirthCountry": null,
  "source": "api.nobelprize.org"
}
```

And one row from `mode: "prizes"` (same run plan, 2000–2026, newest first):

```json
{
  "awardYear": 2026,
  "category": "Physiology or Medicine",
  "url": "https://www.nobelprize.org/prizes/medicine/2026/",
  "fetchedAt": "2026-10-07T21:31:43.079Z",
  "sourceMode": "prizes",
  "categoryFullName": "The Nobel Prize in Physiology or Medicine",
  "dateAwarded": "2026-10-05",
  "prizeStatus": "awarded",
  "prizeAmount": 12000000,
  "prizeAmountAdjusted": 12000000,
  "laureateCount": 3,
  "laureateNames": [
    "Karl Deisseroth",
    "Peter Hegemann",
    "Georg Nagel"
  ],
  "laureateIds": [
    "1061",
    "1062",
    "1063"
  ],
  "laureatePortions": [
    "1/3",
    "1/3",
    "1/3"
  ],
  "topMotivation": null,
  "motivations": [
    "for their discoveries concerning light-gated ion channels and optogenetics",
    "for their discoveries concerning light-gated ion channels and optogenetics",
    "for their discoveries concerning light-gated ion channels and optogenetics"
  ],
  "source": "api.nobelprize.org"
}
```

| Field | Type | Mode | Meaning |
|---|---|---|---|
| `awardYear` | integer | both | Year the prize was awarded. Always filled. |
| `category` | string | both | One of the six categories, in the same words the `categories` input takes. Always filled. |
| `url` | string | both | Prize page of that year and category on the Nobel Prize website. Always filled. |
| `fetchedAt` | string | both | When this run read the record, UTC ISO-8601. Always filled. |
| `sourceMode` | string | both | `laureates` or `prizes` — which shape this row is. Always filled. |
| `name` | string | laureates | Name of the person or organization as the source prints it. |
| `fullName` | string | laureates | Longer form where the source has one, otherwise the same as `name`. |
| `laureateId` | string | laureates | The source's own laureate id — stable, and what `onlyNew` remembers rows by. |
| `laureateType` | string | laureates | `person` or `organization`. |
| `gender` | string | laureates | `female` or `male` for people, empty for organizations. |
| `motivation` | string | laureates | The committee's citation for this laureate, in English. Filled on every award. |
| `categoryFullName` | string | both | The full official prize name (it differs from `category` for Economic Sciences and Physiology or Medicine). |
| `portion` | string | laureates | Share of the prize money: `1`, `1/2`, `1/3` or `1/4`. |
| `shareOrder` | integer | laureates | The committee's order inside a shared prize (1, 2, 3). Rows of one prize are written in this order. |
| `prizeStatus` | string | both | Laureates mode: the source's status for the award — `received`, `declined` (two cases) or `restricted` (one). Prizes mode: `awarded`, or `notAwarded` for a year when the prize was withheld. |
| `dateAwarded` | string | both | Announcement date, `YYYY-MM-DD`. Empty when the source has no exact date (most pre-1950 prizes in prizes mode, and the years with no award). |
| `prizeAmount` | number | both | Prize money for the whole prize in Swedish kronor of that year — not the laureate's share. |
| `prizeAmountAdjusted` | number | both | The same amount restated by the source in recent kronor, so years can be compared. |
| `prizeCount` | integer | laureates | How many Nobel Prizes this laureate has in total. 2 for the five double laureates. |
| `affiliationName`, `affiliationCity`, `affiliationCountry` | string | laureates | The institution the laureate worked at when the prize was awarded (the first one when the source lists several). Empty on about a quarter of the awards — most Peace and Literature ones have none. |
| `birthDate`, `birthCity`, `birthCountry`, `birthCountryNow`, `birthContinent` | string | laureates | Birth place. `birthCountry` is the country name of the time, `birthCountryNow` today's name — use the second one for counts. For an organization these columns hold the founding date and place. |
| `deathDate`, `deathCity`, `deathCountry` | string | laureates | Death date and place; empty for living laureates. |
| `ageAtAward` | integer | laureates | Full years between the birth date and the announcement date — for an organization, full years since it was founded. Empty when the source knows only a birth or founding year. |
| `organizationAcronym` | string | laureates | Short form of an organization's name (`WFP`, `ICAN`); empty for people. |
| `laureatePageUrl` | string | laureates | The laureate's facts page for that award, as the source links it. |
| `wikipediaUrl`, `wikidataId` | string | laureates | English Wikipedia address and Wikidata id the source links. Filled on every laureate. |
| `requestedBirthCountry` | string | laureates | Which of your `birthCountries` values this row matched. Empty when the run asked for no country. |
| `laureateCount` | integer | prizes | How many laureates shared the prize: 1–3, and 0 for a year when it was not awarded. |
| `laureateNames`, `laureateIds`, `laureatePortions` | array | prizes | The laureates in the committee's share order, their ids and their shares — the ids join straight to a laureates-mode run. |
| `topMotivation` | string | prizes | A citation belonging to the prize as a whole. The source fills it on few prizes, and uses it to explain the years with no award. |
| `motivations` | array | prizes | The citation of each laureate, in the same order as `laureateNames`. |
| `source` | string | both | Always `api.nobelprize.org`. |

Dataset views: **Laureates and their awards** (the award plus who won it), **Who the laureates were** (the biography columns), **One row per prize** (for prizes mode).

### Use it from code / agents

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~nobel-prize-laureates/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["Physics"],"yearFrom":2020,"yearTo":2026,"maxItems":20}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/nobel-prize-laureates').call({
    categories: ['Physics'],
    yearFrom: 2020,
    yearTo: 2026,
    maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/nobel-prize-laureates").call(
    run_input={"mode": "prizes", "yearFrom": 2000, "yearTo": 2026, "maxItems": 40}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to Claude / Cursor / any MCP client and call the `yadroo/nobel-prize-laureates` tool with the same JSON input. The two modes are best used as two separate calls: `mode: "laureates"` for "who won and who were they", `mode: "prizes"` for "what was awarded in a year". Keep `maxItems` small (10–25) for a question an agent answers in one turn.

### Pricing

Pay per event: **$0.001 per run start + $0.002 per row written to the dataset**. Every run is charged the start event, including a run that finds nothing.

| Run | Rows | Cost |
|---|---|---|
| A question an agent asks (`maxItems: 10`) | 10 | $0.001 + 10 × $0.002 = **$0.021** |
| The default run (`maxItems: 50`) | 50 | $0.001 + 50 × $0.002 = **$0.101** |
| One row per prize, 2000–2026 | 159 | $0.001 + 159 × $0.002 = **$0.319** |
| The largest run the input allows | 1000 | $0.001 + 1000 × $0.002 = **$2.001** |

Every row written to the dataset is charged, and that is the only row event. This actor writes **no placeholder rows**: a filter that matches nothing, or a category of the running year that has not been announced yet, produces no row at all — such a run costs the start event only and says in its status message why it is empty.

The run stops as soon as it reaches your **Maximum cost per run** and keeps every row you already paid for; its status then reads "Stopped at your spending limit: N rows delivered." `maxItems` is the same brake set in advance: paging stops when the cap is reached.

### Limits & FAQ

**How fast is it, and what fits into one run?** Measured in the Apify cloud on 2026-10-07. A filtered laureates run (one category, 2015–2026) is **one request and 33 rows in 4 seconds**; one row per prize for 2000–2026 is one request and 40 rows in 4 seconds. The widest input the schema allows — ten birth countries over the whole history, 1 000 rows — is about fifty paced requests: in a 60-second test run it read **712 records and wrote 218 rows in 42 seconds at one request per second**, then stopped cleanly at the timeout margin with every row kept and said so ("Stopped before the run timeout: 218 rows saved"). With the actor's own 900-second timeout that input finishes comfortably, so no realistic run is cut short.

**Request pace.** The source publishes no numeric rate limit; its terms ask applications to keep the load on the API small and to prefer a local cache over many calls. This actor therefore sends **at most one request per second** through a single token bucket (retries included), and reads whole pages of 100–200 records rather than one call per year: a complete history run is under ten requests. No 429 and no temporary block appeared in any of our runs. A run is capped at 80 source requests as a safety net — more than twice what the widest input the schema allows needs; if that cap is ever reached, the status message says so.

**Freshness during prize week.** The API is updated together with the nobelprize.org website, including at the moment each prize is announced — the 2026 chemistry laureates were in the API on the day of the announcement. Announcements run over the first half of October, one category a day, so a run on 7 October finds chemistry, physics and medicine for the current year and nothing yet for literature, peace and economics. In `prizes` mode the source already carries a record for the categories still to come, with the planned announcement date but no laureates; such an empty placeholder is **not** written as a row (you would be paying for an empty line) and the status message counts them. Set `yearTo` to the current year and `onlyNew` on to collect each announcement as it lands.

**The historical country trap.** `birthCountry` holds the country as it was named when the laureate was born — `Prussia`, `Austria-Hungary`, `Russian Empire`, `USSR` — and `birthCountryNow` today's name. Counting by `birthCountry` is the most common way to get a wrong "laureates per country" figure. The `birthCountries` filter matches either column and tells you which value matched; see [Birth countries](#birth-countries).

**Years with no prize.** During the world wars several prizes were not awarded. In `prizes` mode those years keep a row with `prizeStatus: "notAwarded"`, `laureateCount: 0` and the source's own explanation in `topMotivation`. In `laureates` mode there is simply no row, because there was no laureate.

**What the source does not have.** No nomination data — nominations stay sealed for 50 years and the nomination archive is a different dataset. No nationality or citizenship field: only the birth and death place as recorded then and now, plus the affiliation at the time of the award. Two laureates declined their prize and one was prevented from accepting it; they are in the data with `prizeStatus` `declined` or `restricted`. The lectures, biographies and medal texts on the website are not part of the API and not in these rows.

**Empty results.** An empty run is never silent: the status message names the reason — a name that matched nothing, a country with no laureate in that window, a category with no award in those years. An invalid input (a year range that cannot match, an unknown country spelling, more than ten countries) fails before any request with a message saying exactly what to change.

**Licence and source.** The API's data is published under CC0, so commercial use is free and no attribution is required; we name the Nobel Prize API as the source anyway. This actor reads only `api.nobelprize.org` — no scraping of the website, no login, no proxy, no browser.

**Questions or problems:** open an issue on the Issues tab of this actor.

***

Made by **Yadroo**. Sibling actors: [openalex-works](https://apify.com/yadroo/openalex-works), [arxiv-papers](https://apify.com/yadroo/arxiv-papers), [wikipedia-search](https://apify.com/yadroo/wikipedia-search), [openlibrary-books](https://apify.com/yadroo/openlibrary-books), [world-bank-indicators](https://apify.com/yadroo/world-bank-indicators).

# Actor input Schema

## `mode` (type: `string`):

`laureates` = one row per laureate and award, with the biographical columns: a laureate who won twice gives two rows, each with its own year, category, motivation, share and affiliation. `prizes` = one row per year and category, with the laureate names and ids joined into lists, the prize amount and the shared motivation - the compact shape for tables, charts and year-by-year reports. `birthCountries`, `gender` and `laureateType` narrow `laureates` mode only.

## `categories` (type: `array`):

The six categories of the prize; several values are combined with OR, empty means every category. Each row carries the value you see here in its `category` column, so a filter and a column always use the same words. The platform refuses any value outside the six before the run starts, so write them exactly as listed - `Physiology or Medicine` is the official name of what is usually called the medicine prize, and `Economic Sciences` exists only from 1969 on.

## `yearFrom` (type: `integer`):

Earliest award year to include, counted inclusively. The first prizes were awarded in 1901, so 1901 means "from the beginning". Leave empty for no lower bound. A year range is the cheapest filter there is: it is sent to the source, so the run pays for the years you asked for and nothing else.

## `yearTo` (type: `integer`):

Latest award year to include, counted inclusively. Leave empty for no upper bound, or set both years to the same number for a single year. Note that the current year only has rows once the award has been announced - the announcements run over the first half of October, one category at a time, and a category not yet announced simply has no row yet.

## `birthCountries` (type: `array`):

Country names as the source writes them: `USA`, `Germany`, `United Kingdom`. Case, spaces and common spellings are accepted (`United States`, `us`, `UK`, `Deutschland`); an unknown value is refused with the closest names. The source records the country of the time, so the filter matches `birthCountry` (`Prussia`, `Austria-Hungary`) or `birthCountryNow`, and `requestedBirthCountry` says which. Organizations drop out of such a run. Ignored in `prizes` mode. Full list: README - Birth countries.

## `gender` (type: `string`):

The gender the source records for a person. Leave empty for all laureates. Organizations carry no gender and drop out of a run that sets this filter. Ignored in `prizes` mode.

## `laureateType` (type: `string`):

About thirty peace prizes went to institutions rather than people. They have a name, a founding year and a place, but no birth date, no gender and no affiliation, so a report that mixes them with people has empty biographical columns. Pick one kind to keep the dataset clean; every row says which it is in `laureateType`. Applied to the rows by this actor, which the source cannot do itself. Ignored in `prizes` mode.

## `nameContains` (type: `string`):

Keep only laureates whose name contains this text, matched case- and accent-insensitively against the known name, the full name and an organization's name: `curie`, `einstein`, `red cross`. Applied by this actor to the rows it fetched, not by the source, so pair it with a year range or a category - otherwise it walks the whole list of laureates, which is slower and costs more. A text that matches nothing returns no rows and the status message says so.

## `sort` (type: `string`):

Which rows you get first when `maxItems` cuts the answer. Newest first is the default, because the recent prizes are the ones people look up and it makes a repeat run during prize week predictable.

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

Remember the award rows this run writes in the actor's key-value store and, on the next run of the same actor or task, write only rows that were not written before. Made for watching the announcements: a task with `yearFrom` and `yearTo` set to the current year, scheduled through the first half of October, then holds exactly the laureates announced since the last run. The memory is kept per actor or task, so two tasks watching two categories do not interfere.

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

Hard cap on the rows this run writes, and therefore on what it costs. Paging stops as soon as the cap is reached. For scale: the whole history is roughly a thousand laureates and about six hundred and fifty prizes, so 1000 rows covers everything the source has in `prizes` mode and almost all of it in `laureates` mode.

## `fields` (type: `array`):

Keep only the named columns, in the order given - for example `name, awardYear, category, motivation`. Empty = every column. `awardYear`, `category`, `url`, `fetchedAt` and `sourceMode` are always present; name one of them here and it moves to the position you gave it. Unknown names are reported in the status message instead of being dropped in silence.

## Actor input object example

```json
{
  "mode": "laureates",
  "categories": [
    "Chemistry"
  ],
  "yearFrom": 2015,
  "yearTo": 2026,
  "laureateType": "all",
  "sort": "yearDesc",
  "onlyNew": false,
  "maxItems": 50
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "categories": [
        "Chemistry"
    ],
    "yearFrom": 2015,
    "yearTo": 2026
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/nobel-prize-laureates").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 = {
    "categories": ["Chemistry"],
    "yearFrom": 2015,
    "yearTo": 2026,
}

# Run the Actor and wait for it to finish
run = client.actor("yadroo/nobel-prize-laureates").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 '{
  "categories": [
    "Chemistry"
  ],
  "yearFrom": 2015,
  "yearTo": 2026
}' |
apify call yadroo/nobel-prize-laureates --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/nobel-prize-laureates"
        }
    }
}
```

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/ualI37gnAMdqf9jRd/builds/M9jejGUFkUqSQCNE7/openapi.json