# Nobel Prize Laureates Scraper — Winners, Years & Motivations (`compute-edge/nobel-prize-laureates-scraper`) Actor

Extract Nobel Prize laureates from the official Nobel Prize API. Get winner names, prize year, category, motivation, prize amount, birth country, and affiliations. Filter by category, year, and gender. Clean structured JSON for research and reference.

- **URL**: https://apify.com/compute-edge/nobel-prize-laureates-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

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

## Nobel Prize Laureates Scraper — Winners, Years & Motivations

Extract complete **Nobel Prize** winner data from the official Nobel Prize API. This scraper gives you structured, ready-to-use data on every laureate since 1901 — including award year, category, prize motivation, prize amount, birth country, institutional affiliation, and Wikipedia link.

### Features

- **Full coverage**: All ~1,000 Nobel Prize laureates from Physics to Literature to Peace
- **Flexible filtering**: Filter by **category**, **award year**, **gender**, or **name**
- **Flattened output**: One record per laureate-prize pair — ideal for data analysis and spreadsheets
- **Enriched fields**: Prize amounts, inflation-adjusted amounts, affiliations, and Wikipedia URLs included
- **Official source**: Pulls directly from the [official Nobel Prize API](https://api.nobelprize.org/) — no scraping of HTML, no fragile selectors
- **LLM-ready output**: Clean, structured JSON suitable for RAG pipelines and AI research tools

#### Data Fields

| Field | Description |
|---|---|
| `laureateId` | Official Nobel Prize laureate ID |
| `fullName` | Full name of the laureate |
| `gender` | Gender of the laureate (male/female) |
| `birthDate` | Date of birth (YYYY-MM-DD) |
| `birthCountry` | Country of birth |
| `deathDate` | Date of death (if applicable) |
| `awardYear` | Year the Nobel Prize was awarded |
| `category` | Full prize category name (e.g., "Physics", "Peace") |
| `motivation` | Official Nobel Committee prize motivation |
| `prizeAmount` | Prize amount in Swedish kronor (SEK) |
| `prizeAmountAdjusted` | Inflation-adjusted prize amount (SEK) |
| `affiliation` | Primary institutional affiliation at time of award |
| `affiliationCountry` | Country of primary affiliation |
| `wikipediaUrl` | Link to English Wikipedia article |

---

### How to Scrape Nobel Prize Data

Follow these steps to extract Nobel Prize laureate data using this Actor:

1. **Go to the Actor page** on Apify Store and click **Try for free**
2. **Set your filters** in the input form:
   - Leave all fields empty to fetch all ~1,000 laureates
   - Select a **Prize Category** (e.g., Physics, Chemistry, Peace) to narrow results
   - Enter an **Award Year** (e.g., `2024`) to get only that year's laureates
   - Use the **Gender** filter to analyze gender representation over time
   - Enter a **Name Filter** to look up a specific laureate (e.g., `Einstein`)
3. **Set Max Results** — default is 500 laureates. Set to 0 for all available records
4. **Click Start** — the Actor runs in seconds (no browser, no proxy needed)
5. **Download your data** in JSON, CSV, or Excel from the **Dataset** tab

#### Input Example

```json
{
  "category": "phy",
  "year": "",
  "gender": "",
  "nameFilter": "",
  "maxResults": 500
}
````

#### Output Example

```json
{
  "laureateId": "941",
  "fullName": "Donna Strickland",
  "gender": "female",
  "birthDate": "1959-00-00",
  "birthCountry": "Canada",
  "deathDate": "",
  "awardYear": 2018,
  "category": "Physics",
  "motivation": "for their method of generating high-intensity, ultra-short optical pulses",
  "prizeAmount": 9000000,
  "prizeAmountAdjusted": 9000000,
  "affiliation": "University of Waterloo",
  "affiliationCountry": "Canada",
  "wikipediaUrl": "https://en.wikipedia.org/wiki/Donna_Strickland"
}
```

***

### Pricing

This Actor uses **pay-per-result** pricing at **$0.003 per result**. A full run fetching all ~1,000+ laureate-prize records costs approximately **$0.003–$0.005 total**.

There are no proxy costs — this Actor calls the official Nobel Prize REST API directly, so compute costs are minimal.

***

### Other Scrapers

Looking for more research-grade data scrapers? Check out these other Actors by the same author:

- **CISA Known Exploited Vulnerabilities (KEV) Scraper** — CVE threat intelligence feed with filtering
- **Hotfrog Scraper** — Business directory data with addresses, phones, and categories

***

### FAQ

**Q: Does this Actor require an API key or login?**
A: No. The Nobel Prize API is fully open and requires no authentication.

**Q: How current is the data?**
A: The Nobel Prize API is maintained by the Nobel Prize organization and is updated annually after each October announcement.

**Q: Why does a laureate appear multiple times?**
A: Records are flattened by prize. Marie Curie, for example, won both Physics (1903) and Chemistry (1911), so she appears as two separate records.

**Q: Can I filter by multiple categories at once?**
A: Currently the API supports one category filter per run. Run the Actor multiple times with different category codes and merge the outputs.

**Q: What does `prizeAmountAdjusted` mean?**
A: It is the prize amount adjusted for inflation to a consistent base year, as provided by the Nobel Prize API.

**Q: What category codes should I use?**
A: `phy` (Physics), `che` (Chemistry), `med` (Medicine/Physiology), `lit` (Literature), `pea` (Peace), `eco` (Economics).

***

### Legal Disclaimer

This Actor retrieves data from the official Nobel Prize API (`api.nobelprize.org`), which is publicly accessible and intended for programmatic use. No authentication bypass is performed. The data is provided by the Nobel Prize Outreach AB for educational and research purposes. Always review the [Nobel Prize API terms](https://www.nobelprize.org/) before using this data commercially. For support, contact the Actor author via the Apify platform.

# Actor input Schema

## `category` (type: `string`):

Filter by Nobel Prize category code. Options: 'che' (Chemistry), 'eco' (Economics), 'lit' (Literature), 'pea' (Peace), 'phy' (Physics), 'med' (Medicine/Physiology). Leave empty to fetch all categories.

## `year` (type: `string`):

Filter by Nobel Prize award year (e.g. '2024', '2020'). Leave empty to fetch all years.

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

Filter by gender of laureate. Options: 'male', 'female'. Leave empty for all.

## `nameFilter` (type: `string`):

Filter by laureate name (partial match). Example: 'Einstein', 'Marie Curie'.

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

Maximum number of laureate records to return. Set to 0 for unlimited. Default fetches up to 500 laureates (~1000+ records when flattened by prize).

## Actor input object example

```json
{
  "category": "",
  "year": "",
  "gender": "",
  "nameFilter": "",
  "maxResults": 500
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/nobel-prize-laureates-scraper").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/nobel-prize-laureates-scraper").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 '{}' |
apify call compute-edge/nobel-prize-laureates-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=compute-edge/nobel-prize-laureates-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nobel Prize Laureates Scraper — Winners, Years & Motivations",
        "description": "Extract Nobel Prize laureates from the official Nobel Prize API. Get winner names, prize year, category, motivation, prize amount, birth country, and affiliations. Filter by category, year, and gender. Clean structured JSON for research and reference.",
        "version": "0.1",
        "x-build-id": "bVencghMfNSxdawtH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~nobel-prize-laureates-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-nobel-prize-laureates-scraper",
                "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/compute-edge~nobel-prize-laureates-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-nobel-prize-laureates-scraper",
                "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/compute-edge~nobel-prize-laureates-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-nobel-prize-laureates-scraper",
                "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": {
                    "category": {
                        "title": "Prize Category",
                        "enum": [
                            "",
                            "che",
                            "eco",
                            "lit",
                            "pea",
                            "phy",
                            "med"
                        ],
                        "type": "string",
                        "description": "Filter by Nobel Prize category code. Options: 'che' (Chemistry), 'eco' (Economics), 'lit' (Literature), 'pea' (Peace), 'phy' (Physics), 'med' (Medicine/Physiology). Leave empty to fetch all categories.",
                        "default": ""
                    },
                    "year": {
                        "title": "Award Year",
                        "type": "string",
                        "description": "Filter by Nobel Prize award year (e.g. '2024', '2020'). Leave empty to fetch all years.",
                        "default": ""
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "",
                            "male",
                            "female"
                        ],
                        "type": "string",
                        "description": "Filter by gender of laureate. Options: 'male', 'female'. Leave empty for all.",
                        "default": ""
                    },
                    "nameFilter": {
                        "title": "Name Filter",
                        "type": "string",
                        "description": "Filter by laureate name (partial match). Example: 'Einstein', 'Marie Curie'.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of laureate records to return. Set to 0 for unlimited. Default fetches up to 500 laureates (~1000+ records when flattened by prize).",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
