# Academic Conference CFP & Registration Monitor (`trovevault/academic-conference-cfp-monitor`) Actor

Monitors conference names, CFP deadlines, registration dates, fees, and attendance mode from academic conference pages. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/trovevault/academic-conference-cfp-monitor.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Jobs, News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.28 / 1,000 conferences

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

## Academic Conference CFP & Registration Monitor

Monitor academic conference deadlines, registration pages, event dates, venue details, attendance format, and public fee signals from maintained public conference sources and official event pages.

This actor is designed for recurring monitoring, not one-off scraping. It discovers conferences automatically, follows official event pages when useful, and returns normalized rows that are easier to diff over time.

---

### Why use this actor?

- Track upcoming CFP and registration activity without checking conference directories manually.
- Discover conferences automatically instead of asking you to supply conference links.
- Enrich track pages with parent-event context while clearly labeling shared registration or fee data.
- Keep production datasets clean by storing operational errors in the run report and logs by default.
- Feed normalized conference rows into alerts, dashboards, internal tools, or downstream actors.

---

### What data does it extract?

| Field | Description |
|---|---|
| `conferenceName`, `series` | Event name and detected acronym or series |
| `entityType`, `trackName` | Whether the row is a conference or a track such as Workshops or Industry Showcase |
| `parentConferenceName`, `parentConferenceUrl` | Parent event identity for track rows |
| `country`, `city`, `venue` | Extracted location details |
| `conferenceStartDate`, `conferenceEndDate` | Event date range when detected |
| `abstractDeadline`, `submissionDeadline`, `notificationDate`, `cameraReadyDate` | Primary normalized conference deadlines |
| `deadlineRounds` | All detected labeled deadline rounds when the page exposes multiple dates |
| `registrationPageAvailable` | Whether a registration page or registration endpoint was found |
| `registrationOpen` | Explicit open or closed registration signal only |
| `earlyBirdDeadline`, `registrationDeadline` | Registration date signals |
| `earlyBirdFee`, `regularFee`, `lateFee`, `studentFee`, `virtualFee`, `currency` | Public fee signals normalized from registration pages or tables |
| `attendanceMode`, `soldOut`, `waitlist` | Public attendance and pressure signals |
| `registrationScope`, `feeScope`, `inheritedFromUrl` | Whether registration or fee fields are direct or inherited from shared event context |
| `cfpUrl`, `registrationUrl`, `officialUrl` | Key conference links |
| `sourceConfidence`, `validationWarnings` | Confidence and warning fields for auditability |

---

### Product semantics that matter

- `registrationPageAvailable` is not the same as `registrationOpen`.
- `registrationOpen` is only set when the page explicitly says registration is open or closed.
- Track rows can inherit registration or fee information from shared event pages. When that happens, the actor labels it with `registrationScope`, `feeScope`, and `inheritedFromUrl`.
- `deadlineRounds` helps preserve early, late, first-round, and second-round signals instead of pretending every event has only one submission date.

---

### How it works

1. Start from the actor’s maintained public conference discovery sources.
2. Detect whether each page is a listing page or a conference detail page.
3. Extract normalized conference fields from the page itself.
4. Follow related home, venue, or registration pages on the same event site when that improves coverage.
5. Normalize the result, add warnings when semantics are ambiguous, and write one row per conference or track.
6. Store operational failures in the run report and logs by default instead of polluting the public dataset.

---

### Input

| Input | Type | Default | Description |
|---|---|---|---|
| `keywords` | array | empty | Keep only conferences matching these terms |
| `countries` | array | empty | Keep only conferences matching these country or region terms |
| `dateFrom` | string | empty | Keep conferences with at least one relevant date on or after this `YYYY-MM-DD` value |
| `dateTo` | string | empty | Keep conferences with at least one relevant date on or before this `YYYY-MM-DD` value |
| `datasetId` | string | empty | Optional dataset to append to |
| `runId` | string | empty | Optional pipeline run ID |

```json
{
  "keywords": ["software engineering", "systems"],
  "countries": ["Germany", "Belgium"],
  "dateFrom": "2026-04-01",
  "dateTo": "2026-12-31"
}
````

***

### Output

The dataset contains normalized conference or track rows only. Operational errors stay in the run report by default.

```json
{
  "entityType": "track",
  "conferenceName": "ECOOP 2026",
  "trackName": "Student Research Competition",
  "parentConferenceName": "ECOOP 2026",
  "country": "Belgium",
  "city": "Brussels",
  "venue": "Vrije Universiteit Brussel",
  "notificationDate": "2026-04-24",
  "deadlineRounds": [
    {
      "type": "submission",
      "label": "Early Submission Deadline",
      "date": "2026-04-21",
      "source": "detail"
    },
    {
      "type": "submission",
      "label": "Late Submission Deadline",
      "date": "2026-06-15",
      "source": "detail"
    }
  ],
  "registrationPageAvailable": true,
  "registrationOpen": null,
  "earlyBirdDeadline": "2026-07-03",
  "regularFee": 160,
  "currency": "EUR",
  "attendanceMode": "in-person",
  "registrationScope": "shared-event",
  "feeScope": "shared-event",
  "inheritedFromUrl": "https://2026.ecoop.org/attending/registration",
  "registrationUrl": "https://2026.ecoop.org/attending/registration",
  "officialUrl": "https://2026.ecoop.org/",
  "sourceConfidence": "medium",
  "validationWarnings": [
    "registration_inherited_from_shared_event_context",
    "fees_inherited_from_shared_event_context"
  ],
  "error": false
}
```

The run report is stored at the default key-value store record `OUTPUT`. When operational failures happen, the actor also writes a separate `ERRORS` record with structured failure details.

***

### API

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~academic-conference-cfp-monitor/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["formal methods"],
    "countries": ["Portugal"],
    "dateFrom": "2026-05-01",
    "dateTo": "2026-12-31"
  }'
```

***

### Limitations

- Academic conference sites are inconsistent and often incomplete.
- Pricing and registration data are best treated as public signals, not guaranteed commercial truth.
- Some conference series publish multiple rounds or updated deadlines; use `deadlineRounds` and `validationWarnings` when precise deadline semantics matter.
- Shared event registration pages can apply to multiple tracks. Review `registrationScope`, `feeScope`, and `inheritedFromUrl` before treating fees as track-specific.

***

### FAQ

**Can I run it without supplying links?**\
Yes. That is the intended default.

**Why do some rows have a registration page but no `registrationOpen` value?**\
Because a visible registration page does not prove that registration is open. The actor only sets `registrationOpen` when the page says so explicitly.

**Why are some fees marked as shared event context?**\
Because some workshops and sub-tracks reuse parent conference registration pages. The actor labels that inheritance instead of pretending the fee is track-specific.

**Where do errors go?**\
By default, into logs plus the run report records `OUTPUT` and `ERRORS`.

**Does it work best as a monitor or as a one-time scraper?**\
As a monitor. It is designed for recurring runs and dataset diffs.

***

### Changelog

#### v0.1

- Initial release with built-in conference-source bundles, Researchr, OpenResearch, WikiCFP, official-page enrichment, shared-event inheritance labeling, structured deadline rounds, and cleaner default output semantics.

# Actor input Schema

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

Optional topic keywords used to keep only matching conferences. The actor checks the conference name, series, track name, topics, location, and related text fields. Use terms such as `software engineering`, `machine learning`, `cybersecurity`, `systems`, or `formal methods`.

## `countries` (type: `array`):

Optional country or region names used to keep only matching conferences. The actor matches against extracted country, city, and venue text. Use values such as `Portugal`, `Germany`, `Belgium`, `Europe`, or `Asia-Pacific`.

## `dateFrom` (type: `string`):

Optional lower bound in `YYYY-MM-DD` format. The actor keeps conferences that have at least one relevant date on or after this value, including submission deadlines, notification dates, registration dates, or conference dates.

## `dateTo` (type: `string`):

Optional upper bound in `YYYY-MM-DD` format. The actor keeps conferences that have at least one relevant date on or before this value.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append results to, in addition to the default run dataset. Leave blank to use only the default run dataset.

## `runId` (type: `string`):

ID of an existing Apify actor run to associate results with for downstream workflows or pipeline tracing. Leave blank for standalone runs.

## Actor input object example

```json
{}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `report` (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("trovevault/academic-conference-cfp-monitor").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("trovevault/academic-conference-cfp-monitor").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 trovevault/academic-conference-cfp-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/academic-conference-cfp-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Academic Conference CFP & Registration Monitor",
        "description": "Monitors conference names, CFP deadlines, registration dates, fees, and attendance mode from academic conference pages. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "9SSHPWgyDcO6MxLuV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~academic-conference-cfp-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-academic-conference-cfp-monitor",
                "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/trovevault~academic-conference-cfp-monitor/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-academic-conference-cfp-monitor",
                "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/trovevault~academic-conference-cfp-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-academic-conference-cfp-monitor",
                "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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional topic keywords used to keep only matching conferences. The actor checks the conference name, series, track name, topics, location, and related text fields. Use terms such as `software engineering`, `machine learning`, `cybersecurity`, `systems`, or `formal methods`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Optional country or region names used to keep only matching conferences. The actor matches against extracted country, city, and venue text. Use values such as `Portugal`, `Germany`, `Belgium`, `Europe`, or `Asia-Pacific`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Optional lower bound in `YYYY-MM-DD` format. The actor keeps conferences that have at least one relevant date on or after this value, including submission deadlines, notification dates, registration dates, or conference dates."
                    },
                    "dateTo": {
                        "title": "Date To",
                        "type": "string",
                        "description": "Optional upper bound in `YYYY-MM-DD` format. The actor keeps conferences that have at least one relevant date on or before this value."
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results to, in addition to the default run dataset. Leave blank to use only the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify actor run to associate results with for downstream workflows or pipeline tracing. Leave blank for standalone runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
