# University of Copenhagen PhD Jobs Scraper (KU) (`nomad-agent/math-ku-phd-scraper`) Actor

From $2/1,000 jobs — no subscription, no proxies. Track every open PhD and research fellowship at the University of Copenhagen (KU), Denmark's largest university, from its HR feed. All faculties, application deadlines, apply URLs. Keyword filter + delta mode for scheduled runs.

- **URL**: https://apify.com/nomad-agent/math-ku-phd-scraper.md
- **Developed by:** [Nomad.Dev](https://apify.com/nomad-agent) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 job results

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## University of Copenhagen PhD Jobs Scraper (KU)

> **Claude / Codex skill to describe and setup this actor: [SKILL.md](https://github.com/Exdenta/OinkAIJobSearch/blob/main/skill/math-ku-phd-scraper/SKILL.md)**

Fetch all open PhD and research fellowship positions from the University of Copenhagen's HR employment feed — every faculty and department, not just one discipline.

The University of Copenhagen (KU) is Denmark's largest university and a major European research employer. Its HR feed lists PhD fellowships and research positions across every faculty — Science, Health, Humanities, Law, Social Sciences and Theology. This Actor reads that feed directly and returns each opening as structured JSON, including a parsed application deadline, so you can build alerts and dashboards without scraping the site by hand.

### What University of Copenhagen PhD data does this scraper extract?

Each result is one flat JSON record per job posting:

| Field | Meaning |
|---|---|
| `id` | Stable source-side identifier |
| `title` | Job title as posted |
| `company` | Hiring institution (always "University of Copenhagen") |
| `location` | Location / duty station |
| `url` | Direct link to the posting |
| `postedAt` | Publish date/time, ISO 8601 (`null` if the feed didn't provide one) |
| `deadline` | Application deadline parsed from the posting text — ISO `YYYY-MM-DD` when the date format is recognised, the raw matched date text otherwise, or `null` when no deadline is stated |
| `field` | KU faculty named in the posting (Science, Health and Medical Sciences, Humanities, Law, Social Sciences or Theology), or `null` if the text states none |
| `snippet` | Short plain-text description excerpt (only when `includeSnippet` is true) |
| `isNew` | `true` on delta runs (`onlyNewSinceLastRun`) for a posting not seen before; omitted on normal runs |

### How to scrape University of Copenhagen PhD with this Actor

1. Click **Try for free** / **Run** — no login to the target site, no cookies, no proxies to configure.
2. Adjust the input (`keywords`, `postedSince`, `maxItems`, `onlyNewSinceLastRun`) or keep the defaults.
3. Run it and export the dataset as JSON, CSV or Excel, or read it over the [API](https://docs.apify.com/api/v2).

Run it from your own code:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nomad-agent/math-ku-phd-scraper").call(run_input={"maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], "—", item["company"], item["url"])
```

Or a single HTTP call that runs the Actor and returns items in one response:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nomad-agent~math-ku-phd-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"maxItems": 50}'
```

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `maxItems` | integer | `25` | Maximum number of PhD openings to return (max `500`). Each result returned is billed. Set 0 for no limit (all current openings — typically 25-40 at any time). |
| `keywords` | array of strings | *(none)* | Only return postings whose title or description contains at least one of these terms (case-insensitive substring, OR match), e.g. `["quantum", "machine learning", "bioinformatics"]`. Filtered-out postings are dropped before billing. Leave empty to return every open position across all faculties. |
| `onlyNewSinceLastRun` | boolean | `false` | Delta / monitoring mode — only output postings not seen on a previous flagged run. See [Delta mode / monitoring](#delta-mode--monitoring). |
| `includeSnippet` | boolean | `true` | Include a plain-text excerpt (up to 400 characters) from the job description in each result. |
| `postedSince` | string (date) | *(none)* | Only return postings published on or after this date. Leave empty to return all currently open positions. |
| `cacheTtlSeconds` | integer | `1800` | *(Advanced)* Reuse a previously fetched listing if it is younger than this many seconds, instead of fetching it again. Set 0 to always fetch fresh. |

### Output example

```json
{
  "id": "164715",
  "title": "PhD fellowship in fault tolerant quantum algorithms",
  "company": "University of Copenhagen",
  "location": "Copenhagen, Denmark",
  "url": "https://employment.ku.dk/phd/?show=164715",
  "postedAt": "2026-06-28T00:00:00Z",
  "deadline": "2026-07-12",
  "field": "Faculty of Science",
  "snippet": "PhD fellowship in fault tolerant quantum algorithms PhD Project in state preparation, observable extraction or noise modelling Niels Bohr Institute Faculty of Science University of Copenhagen..."
}
```

`deadline` is `null` for the small minority of postings whose text doesn't state an explicit date near the word "deadline".

### Delta mode / monitoring

Set `onlyNewSinceLastRun` to `true` to turn this Actor into a "new openings only" monitor. Each flagged run records the ids it delivers in a dedicated key-value store; the next flagged run drops any posting it has already seen **before** it is pushed or billed, so you pay only for genuinely new KU openings. Records emitted in this mode carry an extra `isNew: true` field. The first flagged run has nothing to compare against, so it emits every current opening.

Pair it with Apify's built-in [**Schedule**](https://docs.apify.com/platform/schedules) feature: schedule a daily or weekly run with `onlyNewSinceLastRun` on (optionally with a `keywords` filter) and each run's dataset holds only the PhD positions that appeared since the last check — a ready-made feed for a PhD-alert bot, a Slack/email digest, or a Make/Zapier/n8n automation. Because already-seen postings are filtered before billing, an idle week costs only the actor-start fee.

### Pricing

Pay per event: **$0.005 per Actor start** and **$0.002 per job returned** (volume discounts on higher Apify plans, down to $0.0016/job).
100 jobs ≈ $0.41. No subscription, no rental, no proxy costs — you pay only for what you fetch.

### Integrations

Export the dataset as JSON, CSV or Excel from the Console, or read it programmatically over the [Apify API](https://docs.apify.com/api/v2) — including a single `run-sync-get-dataset-items` call (see below). Works with Make, Zapier and n8n via the Apify app/node, and is callable by AI agents through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

### Use cases

- PhD-alert bots for any discipline at the University of Copenhagen
- Academic job aggregation for Scandinavia
- Tracking Danish university hiring
- Research-career services

### FAQ

**Is it legal to scrape University of Copenhagen PhD?**
This Actor reads only publicly available job postings — data any visitor can see without logging in. No personal data behind authentication is touched. Review the target site's terms and your local regulations for your specific use case.

**Do I need an account on the target site?**
No. Postings are fetched from public pages/APIs — no login, cookies or session tokens.

**How fresh is the data?**
Every run fetches live listings. Results are cached for `cacheTtlSeconds` (default 30 min, set 0 to always hit the source live).

**How many jobs can I get?**
`maxItems` caps the run (set 0 where supported for no cap). Most sources paginate from newest to oldest.

**Does it cover all faculties or just one discipline?**
All of them — the scraper reads KU's university-wide employment feed, so quantum-physics, medicine, law and humanities fellowships all appear in a single run.

**Something broken or missing?**
Open an issue on the Actor's **Issues** tab — it is monitored and reliability fixes ship fast.

**Is this Actor useful to you?**
A quick review on the Store page helps other researchers find it — it takes a minute and makes a real difference for a niche tool like this.

### Related Actors

Need more than one university? This KU connector is bundled into our multi-source academic aggregator, so you can pull KU alongside EURAXESS, jobs.ac.uk, AcademicPositions and more in a single deduplicated run:

- [Research & Academic Jobs Scraper — 10 Sources](https://apify.com/nomad-agent/researcher-bundle) — KU + 9 other academic sources, one dataset
- [EURAXESS Jobs Scraper — EU Research Positions](https://apify.com/nomad-agent/euraxess-scraper)
- [jobs.ac.uk Scraper — UK Academic & Research Jobs](https://apify.com/nomad-agent/jobs-ac-uk-scraper)
- [AcademicPositions Job Scraper — EU Academic Jobs](https://apify.com/nomad-agent/academicpositions-scraper)

***

**From the maker of [Oink](https://github.com/Exdenta/OinkAIJobSearch)** — an open-source, AI-powered job-search bot for Telegram that runs on these Actors. [Try the free bot](https://t.me/job_search_everyday_bot), get a managed instance at [oinkjobsearch.com](https://oinkjobsearch.com), or browse the [full catalog of 50+ Actors](https://apify.com/nomad-agent).

# Actor input Schema

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

Maximum number of PhD openings to return. Each result returned is billed. Set 0 for no limit (all current openings — typically 25-40 at any time).

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

Only return postings whose title or description contains at least one of these terms (case-insensitive substring, OR match). E.g. <code>quantum</code>, <code>machine learning</code>, <code>bioinformatics</code>. Leave empty to return every open PhD/research position across all faculties.

## `includeSnippet` (type: `boolean`):

Include a plain-text excerpt (up to 400 characters) from the job description in each result.

## `postedSince` (type: `string`):

Only return postings published on or after this date. Leave empty to return all currently open positions.

## `onlyNewSinceLastRun` (type: `boolean`):

Delta/monitoring mode: only output postings not seen on a previous run made with this flag on. Already-seen postings are dropped before push (not billed), so this is the cheapest way to run on an Apify schedule and pay only for genuinely new KU openings. State is tracked in a dedicated key-value store keyed by posting ID; the first flagged run emits everything. See README "Delta mode / monitoring".

## `cacheTtlSeconds` (type: `integer`):

Reuse a previously fetched listing if it is younger than this many seconds, instead of fetching it again. Speeds up back-to-back runs. Set 0 to always fetch fresh.

## Actor input object example

```json
{
  "maxItems": 25,
  "keywords": [
    "quantum",
    "machine learning",
    "bioinformatics"
  ],
  "includeSnippet": true,
  "postedSince": "",
  "onlyNewSinceLastRun": false,
  "cacheTtlSeconds": 1800
}
```

# 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("nomad-agent/math-ku-phd-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("nomad-agent/math-ku-phd-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 nomad-agent/math-ku-phd-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=nomad-agent/math-ku-phd-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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