# Conference Index Scraper (`compute-edge/conferenceindex-scraper`) Actor

Extract academic conference listings from ConferenceIndex.org — the comprehensive directory of international academic conferences, seminars, workshops, and symposiums.

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

## Pricing

from $2.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

## Conference Index Academic Conference Scraper

**Extract academic conference listings from ConferenceIndex.org** — the comprehensive directory of international academic conferences, seminars, workshops, and symposiums. This Actor scrapes conference names, dates, locations, venues, organizers, websites, submission deadlines, topics, event tracks, and full descriptions from the **Conference Index** database.

Whether you are a **researcher** looking for upcoming conferences in your field, an **academic institution** tracking events across disciplines, or a **conference organizer** monitoring the competitive landscape, this scraper provides structured data from one of the largest **academic conference directories** available online. Conference Index covers thousands of events across disciplines including **computer science**, **artificial intelligence**, **machine learning**, **engineering**, **medicine**, **business**, and many more.

The scraper operates in two modes. In **quick mode**, it extracts basic conference information (name, date, location) directly from topic listing pages. In **detail mode**, it visits each conference's individual page to extract the full set of fields including JSON-LD structured data, venue information, organizer details, submission deadlines, event tracks, and the complete description. This flexibility lets you balance speed against data completeness depending on your needs.

### What data can you scrape from Conference Index?

| Field | Description |
|-------|-------------|
| **name** | Full conference name |
| **shortName** | Abbreviated conference name (e.g., ICSET) |
| **startDate** | Conference start date (ISO 8601 from JSON-LD) |
| **endDate** | Conference end date (ISO 8601 from JSON-LD) |
| **dateText** | Human-readable date range (e.g., "March 15-16, 2026") |
| **location** | City and country (e.g., "New Delhi, India") |
| **venue** | Venue name (e.g., "Hotel Suncourt Corporate") |
| **organizer** | Organizing body or institution |
| **website** | Official conference website URL |
| **contactEmail** | Contact email (decoded from Cloudflare obfuscation) |
| **submissionDeadline** | Paper submission deadline |
| **topics** | Conference tags / discipline keywords |
| **eventTracks** | Specific tracks and sub-topics |
| **description** | Full conference description text |
| **eventStatus** | Schema.org event status (Scheduled, Cancelled, etc.) |
| **attendanceMode** | Online, offline, or mixed attendance |
| **eventType** | Conference, seminar, workshop, etc. |
| **presentationMode** | Digital, in-person, or hybrid |
| **eventUrl** | Conference Index page URL |

### Why use this Conference Index scraper?

- **No login required** — all conference data is publicly accessible
- **JSON-LD extraction** — uses schema.org structured data for high-accuracy date and status parsing
- **Cloudflare email decoding** — automatically decodes obfuscated contact emails
- **Topic filtering** — search by any discipline (computer-science, medicine, engineering, etc.)
- **Fast and efficient** — uses CheerioCrawler (no browser needed), keeping compute costs very low
- **Pagination support** — automatically follows listing pages across multiple pages
- **Two modes** — quick listing data or full detail page scraping

### How to scrape Conference Index

1. Go to the [Conference Index Scraper](https://apify.com/seatsignal/conferenceindex-scraper) page on Apify Store
2. Click **Try for free**
3. Enter a **Topic** slug (e.g., `computer-science`, `artificial-intelligence`, `machine-learning`). You can find valid slugs at [conferenceindex.org/disciplines](https://conferenceindex.org/disciplines)
4. Set **Max Pages** to control how many listing pages to scrape (each page has many conferences)
5. Toggle **Scrape Detail Pages** on for full data (dates, venue, organizer, website, topics, tracks) or off for a quick list
6. Optionally set **Max Requests** as a safety limit on total HTTP requests
7. Click **Start** and wait for results
8. Download your data as JSON, CSV, or Excel from the **Dataset** tab

### Input example

```json
{
    "topic": "computer-science",
    "maxPages": 5,
    "scrapeDetails": true,
    "maxRequestsPerCrawl": 500
}
````

### Output example

Each conference returns a JSON object like this (with detail scraping enabled):

```json
{
    "eventUrl": "https://conferenceindex.org/event/international-conference-on-science-engineering-technology-icset-2026-march-new-delhi-in",
    "topic": "computer-science",
    "name": "International Conference on Science, Engineering & Technology",
    "startDate": "2026-03-15T00:00:00.000000Z",
    "endDate": "2026-03-16T00:00:00.000000Z",
    "eventStatus": "https://schema.org/EventScheduled",
    "attendanceMode": "https://schema.org/OnlineEventAttendanceMode",
    "organizer": "Researchfora",
    "description": "International Conference on Science, Engineering & Technology (ICSET - 2026) will be held in New Delhi, India during 15th-16th Mar 2026...",
    "location": "New Delhi, India",
    "venue": "Hotel Suncourt Corporate",
    "dateText": "March 15-16, 2026",
    "submissionDeadline": "March 15, 2026",
    "website": "https://researchfora.com/Conference/12725/ICSET/",
    "contactEmail": "info@researchfora.com",
    "shortName": "ICSET",
    "eventType": "Conference",
    "presentationMode": "Digital",
    "topics": ["science", "concrete engineering", "engineering", "computer science", "technology"],
    "eventTracks": ["Information Technology", "Computer Engineering", "Chemical Science and Engineering", "Civil Engineering", "Mechanical Engineering"]
}
```

Without detail scraping (quick mode):

```json
{
    "name": "International Conference on Science, Engineering & Technology (ICSET)",
    "date": "Mar 15",
    "location": "New Delhi, India",
    "eventUrl": "https://conferenceindex.org/event/international-conference-on-science-engineering-technology-icset-2026-march-new-delhi-in",
    "topic": "computer-science"
}
```

### How much does it cost to scrape Conference Index?

This Actor uses **CheerioCrawler** (no browser), so compute costs are extremely low.

| Scenario | Pages | Est. Results | Est. Compute | Est. Actor Fee |
|----------|-------|-------------|-------------|----------------|
| One topic, quick mode | 1 | ~100 | ~$0.005 | ~$0.20 |
| One topic, with details | 5 | ~500 | ~$0.05 | ~$1.00 |
| One topic, full scrape | 20 | ~2,000 | ~$0.20 | ~$4.00 |
| Multiple topics | 50 | ~5,000 | ~$0.50 | ~$10.00 |

Actor pricing: **$0.002 per result** + minimal compute costs. A typical run of 5 pages with detail scraping costs under $1.50 total.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `topic` | string | Yes | `computer-science` | Topic slug from conferenceindex.org/disciplines |
| `maxPages` | integer | No | `5` | Max listing pages to scrape (1-100) |
| `scrapeDetails` | boolean | No | `true` | Visit detail pages for full data |
| `maxRequestsPerCrawl` | integer | No | `500` | Safety limit on total HTTP requests |

### Tips for best results

- **Finding topic slugs**: Visit [conferenceindex.org/disciplines](https://conferenceindex.org/disciplines) and click on a discipline. The URL slug after `/conferences/` is what you need (e.g., `computer-science`, `artificial-intelligence`, `data-science`)
- **Quick mode**: Set `scrapeDetails` to `false` for a fast list of names, dates, locations, and URLs without visiting each detail page
- **Large scrapes**: Increase `maxPages` and `maxRequestsPerCrawl` together. With detail scraping, each conference listing enqueues one additional request
- **Email extraction**: Contact emails are often Cloudflare-obfuscated on Conference Index. This scraper automatically decodes them when possible

### Integrations

Connect Conference Index data with your workflow:

- **API** — Access results programmatically via the [Apify API](https://docs.apify.com/api/v2)
- **Webhooks** — Get notified when a scrape completes
- **Zapier / Make** — Pipe results into Google Sheets, CRMs, or databases
- **Python / Node.js** — Use the [Apify SDK](https://docs.apify.com/sdk/js) to run and retrieve data

### Legal disclaimer

This Actor extracts publicly available conference information from ConferenceIndex.org. The site publishes its content under a [Creative Commons Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/), which permits sharing and adapting the material for any purpose with appropriate attribution. This Actor does not bypass authentication, access protected content, or extract private user data. The scraped data consists of conference listings that organizers have voluntarily published on the public directory.

Users are responsible for ensuring their use of scraped data complies with applicable laws and the Creative Commons license terms. For questions about data usage, consult a legal professional.

### Support

- **Issues?** Open an issue on the Actor's Apify page
- **Custom data needs?** Contact us for enterprise solutions

# Actor input Schema

## `topic` (type: `string`):

Conference topic slug (e.g., 'computer-science', 'artificial-intelligence', 'machine-learning', 'cybersecurity', 'data-science'). Find slugs at conferenceindex.org/disciplines.

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

Maximum number of listing pages to scrape.

## `scrapeDetails` (type: `boolean`):

If true, visits each conference's detail page for full info (dates, venue, topics, organizer, website). Slower but much more complete.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum total HTTP requests. Safety limit.

## Actor input object example

```json
{
  "topic": "computer-science",
  "maxPages": 5,
  "scrapeDetails": true,
  "maxRequestsPerCrawl": 500
}
```

# 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 = {
    "topic": "computer-science"
};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/conferenceindex-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 = { "topic": "computer-science" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Conference Index Scraper",
        "description": "Extract academic conference listings from ConferenceIndex.org — the comprehensive directory of international academic conferences, seminars, workshops, and symposiums.",
        "version": "0.1",
        "x-build-id": "1vWwE27Z8EyjWeAzd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~conferenceindex-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-conferenceindex-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~conferenceindex-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-conferenceindex-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~conferenceindex-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-conferenceindex-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",
                "required": [
                    "topic"
                ],
                "properties": {
                    "topic": {
                        "title": "Topic / Discipline",
                        "type": "string",
                        "description": "Conference topic slug (e.g., 'computer-science', 'artificial-intelligence', 'machine-learning', 'cybersecurity', 'data-science'). Find slugs at conferenceindex.org/disciplines."
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of listing pages to scrape.",
                        "default": 5
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "If true, visits each conference's detail page for full info (dates, venue, topics, organizer, website). Slower but much more complete.",
                        "default": true
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max Requests",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total HTTP requests. Safety limit.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
