# B2B Event & Conference Schema.org Lead Extractor (`afkdigital/newapi06-event-schema-leads`) Actor

Extract conference and event records from explicit Schema.org Event JSON-LD in your URL list. JSON/CSV datasets, organizers, and directly declared sponsor or performer domains. No browser.

- **URL**: https://apify.com/afkdigital/newapi06-event-schema-leads.md
- **Developed by:** [AFK Digital](https://apify.com/afkdigital) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$6.00 / 1,000 unique event 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## B2B Event & Conference Schema.org Lead Extractor

Turn public conference pages into structured event and organization records for Clay, n8n, and other workflows. This Actor reads **Schema.org Event JSON-LD already present in the HTTP response**. It does not render JavaScript, browse the web for you, or infer business relationships from prose or logos.

### Quick start

Supply 1–30 permitted public event-page URLs, an optional inclusive start-date range, and a maximum of 1–100 unique results.

The small default example contains two genuine conference homepages:

```json
{
  "urls": [
    "https://2026.pycon.ie/",
    "https://2026.pycon.org.au/"
  ],
  "maxResults": 5
}
```

Dates are unrestricted by default, so this example includes both a past conference and a forthcoming conference as observed in October 2026. To select only events starting in the fourth quarter of 2026, add:

```json
{
  "fromDate": "2026-10-01",
  "toDate": "2026-12-31"
}
```

The range compares the calendar date in the source's normalized start value. Blank date inputs mean unrestricted. Invalid calendar dates are rejected. A record with no valid start date is excluded when a date filter is active.

The default run targets **well under five minutes**. Network work stops after two minutes, with the standard Actor timeout set to three minutes.

### Exact output

Each Dataset item contains these 12 properties. Missing values are JSON null.

| Property | Meaning |
|---|---|
| event_name | Explicit Event name, or null |
| start_date | ISO calendar date or datetime, or null |
| end_date | Explicit end date or datetime; never copied from the start |
| timezone | Valid explicit IANA zone or the start datetime's explicit UTC offset; null for an unzoned source |
| location_venue | First explicit Event location's name |
| location_address | Its structured postal address, formatted as text |
| organizer_name | Explicit Event organizer names, joined with a semicolon if multiple |
| organizer_url | Valid HTTP(S) website of the first explicit organizer |
| performer_domains | Unique website hostnames from the direct Event performer property; otherwise null |
| sponsor_domains | Unique website hostnames from the direct Event sponsor property; otherwise null |
| source_url | Page actually fetched after validated redirects |
| observed_at | UTC extraction timestamp |

A real PyCon AU homepage result observed during validation:

```json
{
  "event_name": "PyCon AU 2026",
  "start_date": "2026-08-26",
  "end_date": "2026-08-30",
  "timezone": null,
  "location_venue": "Sofitel Brisbane Central",
  "location_address": "249 Turbot Street, Brisbane City, QLD, 4000, AU",
  "organizer_name": "PyCon AU",
  "organizer_url": "https://pycon.org.au/",
  "performer_domains": null,
  "sponsor_domains": null,
  "source_url": "https://2026.pycon.org.au/",
  "observed_at": "2026-10-19T08:22:04.329Z"
}
```

The homepage may visibly list sponsors elsewhere. This result has null sponsor and performer fields because its Event JSON-LD does not declare those properties. A speaker is not automatically a performer, organizer, or sponsor. Named organizations without explicit website URLs do not produce invented domains. Only domain hostnames are emitted; no contact details are collected.

### Structured data and deduplication

Supported forms include Event subtypes, full Schema.org type URLs, multiple JSON-LD script blocks, root arrays, @graph, structured item lists, mainEntity, subEvent, and same-page @id organization references. Malformed JSON-LD blocks are skipped; JSON-LD remote contexts and linked organization pages are never fetched.

Date-only values stay dates. Datetimes with an explicit offset retain that source offset. Datetimes with a valid explicit IANA zone are normalized only when the local instant is unambiguous. Ambiguous autumn clock changes and nonexistent spring clock-change times become null. An unzoned local datetime stays unzoned; a city never supplies an invented timezone. Supported datetime precision is through milliseconds.

Deduplication is **within a run and its recovery**, using normalized event name, full start instant/date, venue, and address. Equivalent instants expressed with different offsets share one identity; distinct seconds and different addresses remain distinct. Incomplete identities also use source_url to avoid collapsing unrelated pages.

When one page declares several objects for the same event, the most complete explicit object is considered first. It is kept as one coherent object; conflicting organizer claims are not combined. Across different input pages, the first accepted copy wins. Duplicate URL inputs are fetched once. A new independent run is a new extraction and is priced for its delivered unique records.

### Price and spending limits

**$0.006 per unique emitted event — $6 per 1,000 results.**

The Apify pay-per-event configuration contains one primary custom charge, event-record. There is no configured startup charge or additional synthetic Dataset-item charge. A saved unique record triggers one event charge. Duplicate objects, duplicate URLs, failed retrievals, missing JSON-LD, and HTTP retries do not add result charges.

Set Apify's **maximum total charge** to cap a run. The Actor also enforces maxResults, with an absolute ceiling of 100 results ($0.60 in result charges). Exactly $0.006 permits one result; a smaller budget permits none. The 1,000-record price is a unit-price comparison, not the single-run output limit.

Output and charging use a persistent checkpoint. If a storage or billing response has an uncertain outcome, the run fails and refuses to replay that pending record on resurrection. This prioritizes preventing duplicate charges; partial output may remain. Consult SUMMARY and CHECKPOINT before retrying such a failed run. No distributed exactly-once transaction is claimed.

### HTTP and access controls

Requests are sequential and identify this Actor. Limits include:

- Public HTTP/HTTPS hostnames on standard ports; no embedded credentials or literal IP destinations.
- DNS answers must all be publicly routable. Connections use those checked addresses, including after redirects.
- At most three redirects, with destination robots rules checked before each HTML request.
- Eight seconds total per network request including DNS, at most two attempts, and bounded 429/5xx backoff.
- Retry-After is respected. If its wait exceeds the run's budget or ten seconds, the host is skipped instead of retried early.
- At least one second between requests to a host; a larger robots crawl-delay is honored without shortening it.
- 1.5 MB per HTML response, 256 KB per robots file, 10 MB aggregate response bodies, and 90 HTTP requests per run.
- Unexpected content compression, unavailable robots policy, disallowed paths, access denials, and non-HTML event responses are skipped.

Only provide URLs whose access conditions permit your intended retrieval and use. The known-source block list includes Eventbrite, Localist domains, and the reviewed MIT calendar. That list is not a universal terms checker. The default PyCon pages' linked participation policies were reviewed and their robots policies checked during validation. Site content and policies can change.

There are no proxies, login flows, CAPTCHA handling, browser automation, or access-control workarounds. Content rendered only after JavaScript execution yields no records. Zero results is a valid outcome for unsupported, restricted, or empty sources; see the SUMMARY record for skipped-page reasons.

### Clay and n8n exports

Use the Actor output links for the Dataset, JSON, CSV, and run summary. Standard endpoints:

```text
JSON: https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json&clean=true
CSV:  https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&clean=true
```

In **Clay**, import the CSV file or Dataset CSV URL and map each column to the same property name.

In **n8n**, run the Actor with the Apify node or HTTP Request node, wait for a successful terminal status, then retrieve the Dataset's JSON items. Each object is one event row. Store API credentials in n8n's credential manager and use an Authorization header for protected exports. Keep credentials out of source URLs and shared workflow text.

JSON preserves nulls and domain arrays. CSV displays nulls as empty cells and serializes array values; consumers can split those values when needed.

### Development and validation

```sh
npm ci
npm test
node test/real-live.js
npm start
```

The opt-in real-page test uses the two configured public defaults and records response hashes, field assertions, and deduplication evidence under reports/. Runtime code lives in src/; the image uses Node 22 and lockfile dependencies.

Synthetic tests cover explicit role separation, graph references, missing fields, date/DST handling, equivalent instants, SSRF and redirect defenses, size/time limits, robots delays, Retry-After, budget boundaries, and uncertain billing recovery. Synthetic sponsor fixtures are test-only and are not presented as real extracted leads.

Application version: **1.1.0**. Independent software; not affiliated with Schema.org, Apify, Python Ireland, PyCon AU, or other event organizers.

# Actor input Schema

## `urls` (type: `array`):

1–30 HTTP/HTTPS public pages. Protected/private hosts rejected.

## `fromDate` (type: `string`):

YYYY-MM-DD inclusive, blank means unrestricted.

## `toDate` (type: `string`):

YYYY-MM-DD inclusive, blank means unrestricted.

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

No more than this number of unique JSON-LD event records. No charge for retries or duplicate events.

## Actor input object example

```json
{
  "urls": [
    "https://2026.pycon.ie/",
    "https://2026.pycon.org.au/"
  ],
  "maxResults": 5
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `json` (type: `string`):

No description

## `csv` (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("afkdigital/newapi06-event-schema-leads").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("afkdigital/newapi06-event-schema-leads").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call afkdigital/newapi06-event-schema-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,afkdigital/newapi06-event-schema-leads"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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