# LUX Event Listings Scraper (`axiomworks/lux-events-scraper`) Actor

Collect LUX event listings and return event titles, types, start and end dates, times, venues, booking links, images and descriptions. Choose a year, event type, keyword or event URL; the WordPress API can retrieve events back to 2011, beyond the latest listing page.

- **URL**: https://apify.com/axiomworks/lux-events-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.95 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

**Returns:** one row per LUX event with `title`, `startDate`, `endDate`, `timeText`, `venue`, `eventTypes`, `bookingUrl` and `url`.
**Input:** `{"startUrls": [{"url": "https://lux.org.uk/whats-on/"}], "maxItems": 10}`
**Best for:** London art and film event listings, cultural programme monitoring, archive research on artists' moving image events back to 2011.

```json
{
    "title": "Palestine Cinema Days Around the World: Blessed Blessed Oblivion & With Hasan in Gaza",
    "startDate": "2026-11-02",
    "endDate": "2026-11-02",
    "timeText": "16:00",
    "venue": "Mosaic Rooms",
    "eventTypes": ["Screening/Talk"],
    "bookingUrl": "https://tzkrti.com/en/events/4873",
    "url": "https://lux.org.uk/event/palestine-cinema-days-around-the-world-blessed-blessed-oblivion-with-hasan-in-gaza/"
}
```

### What does LUX Events Scraper do?

LUX Events Scraper collects the events published on lux.org.uk, the website of LUX, the London agency for artists' moving image. That means screenings, artist talks, exhibitions, workshops, symposia, performances, reading groups and the online lecture series, from the newest listing back to the first events of 2011. It reads public pages only, with no login.

You can point it at the What's On listing, an event type archive, a year archive, a site search or single event pages, or skip URLs and filter by event type, year or keyword directly. Unlike the What's On page, which shows nine events per screen in publish order, this LUX scraper enumerates every event through the site's WordPress REST API, so a run with a large enough `maxItems` returns the complete programme.

### What data can you get from LUX?

| Field | Description | Example |
|---|---|---|
| `id` | WordPress post id of the event, as a string. Unique within a run. | `"109550"` |
| `url` | The event page on lux.org.uk. | `https://lux.org.uk/event/showing-up/` |
| `slug` | The event's URL slug. | `showing-up` |
| `title` | Event title as shown on the site, entities decoded, line breaks as spaces. | `Showing Up` |
| `eventTypes` | Names of the event's types. Empty for a few early events. | `["Education", "Lecture"]` |
| `eventTypeSlugs` | Slugs of the same types, usable as the `eventType` input. | `["education", "lecture"]` |
| `yearTag` | Programme year the site files the event under, 2017 onwards. | `2026` |
| `excerpt` | Short summary of the event. | `'Showing Up' brings together films, performances and works ...` |
| `description` | Full event description as plain text. | `To launch our new series of monthly exhibitions ...` |
| `contentHtml` | Full event description as HTML. Omitted when `includeContentHtml` is false. | `<p>To launch our new series ...</p>` |
| `imageUrl` | URL of the featured image. | `https://lux.org.uk/wp-content/uploads/2026/08/IMG_6231-copy-scaled.jpg` |
| `publishedAt` | When the event was published, ISO 8601 UTC. | `2026-08-20T13:40:06Z` |
| `modifiedAt` | When the event page was last modified, ISO 8601 UTC. | `2026-08-20T13:41:47Z` |
| `startDateText` | Start date exactly as the page shows it. | `13 September, 2026` |
| `startDate` | Start date as `YYYY-MM-DD`. | `2026-09-13` |
| `endDateText` | End date as shown; the start date for single-day events. | `10 February, 2018` |
| `endDate` | End date as `YYYY-MM-DD`. | `2018-02-10` |
| `timeText` | Time or opening hours exactly as shown. Missing for some early events. | `Wed-Sat, 12pm – 4pm` |
| `venue` | Venue or address lines from the event header, joined with commas. | `LUX, Waterlow Park Centre, Dartmouth Park Hill, London, N19 5JF, UK` |
| `bookingUrl` | Link behind the booking button; null when the page has none (usual for exhibitions and past events). | `https://www.eventbrite.co.uk/e/showing-up-tickets-1998482105776` |
| `bookingLabel` | Text of the booking button. | `BOOK` |
| `isUpcoming` | True when the end date (or start date) is today or later, UTC; null when no date is shown. | `true` |
| `scrapedAt` | When the row was collected, ISO 8601 UTC. | `2026-10-13T13:21:31.075Z` |
| `sourceUrl` | Page or API endpoint the row came from. | `https://lux.org.uk/event/showing-up/` |

### How to use LUX Events Scraper

1. Open the Actor in Apify Console and leave the prefilled What's On URL in **LUX URLs** to get the newest events, or paste another lux.org.uk URL: an event type archive such as `https://lux.org.uk/event_catogories/exhibition/`, a year archive such as `https://lux.org.uk/years/2017/`, a search such as `https://lux.org.uk/?s=workshop`, or single event pages.
2. Or leave the URLs empty and use the **Filters** section: pick an **Event type**, type a **Year** or a **Search keyword**, or tick **Upcoming events only** to get just the programme still to come.
3. Set **Maximum events**. The run stops as soon as that many events are saved. Use `0` to get every matching event (about 750 for the whole programme, which takes roughly ten minutes).
4. Click **Start**. Events appear in the dataset as they are collected, newest first.
5. Export from the **Storage** tab as JSON, CSV, Excel, XML or RSS, or read the dataset through the API.

The default Apify Proxy (datacenter) is enough: lux.org.uk answers it normally. If a run ends with 0 events and the log shows HTTP 403 or a block page, the site has started challenging that proxy group; retry later or switch the proxy configuration to a residential group.

Scheduling a daily run with `upcomingOnly: true` keeps a current list of what is on at LUX; a monthly run with the full listing and a higher `maxItems` keeps an archive up to date (events are added a few times a month and changes are reflected in `modifiedAt`).

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | array of `{url}` | No | lux.org.uk URLs to collect events from: What's On, an event type archive, a year archive, a site search or an event page. Empty means all events. |
| `eventUrls` | array of strings | No | Same as `startUrls`, as plain strings, for pasting lists of event pages. |
| `eventIds` | array of strings | No | Positive WordPress IDs from previous results; processed after URLs with the same shared limit and deduplication. |
| `eventType` | string | No | Event type slug such as `screening-talk`, `exhibition`, `workshop`, `education`, `performance`, `online-exhibition`, `in-dialogue` or `lux-salon`. Empty means every type. |
| `category` | string | No | Alias of `eventType`; also accepts a type name such as `Screening/Talk`. |
| `year` | string | No | Programme year, 2017 to the current year, e.g. `2017`. |
| `search` | string | No | Keyword searched in titles and descriptions, e.g. `workshop`. |
| `dateFrom`, `dateTo` | strings | No | Inclusive event interval overlap with YYYY-MM-DD bounds; empty means no bound. Undated events are excluded. |
| `dateScanLimit` | integer | No | Newest events examined per target for date windows, 1-1000, default 100. With upcomingOnly, the smaller scan limit applies. |
| `upcomingOnly` | boolean | No | Keep only events whose end date is today or later. Default `false`. |
| `upcomingScanLimit` | integer | No | How many of the newest events to examine when `upcomingOnly` is on, 1-1000, default 100. |
| `maxItems` | integer | No | Maximum events across all inputs, 0-10000, default 50; `0` means every matching event. |
| `includeContentHtml` | boolean | No | Include the `contentHtml` field. Default `true`. |
| `proxyConfiguration` | object | No | Proxy settings. Default: Apify Proxy, datacenter group. |

Filters combine: `eventType` plus `year` plus `search` narrows the list down to events matching all three. Type, year and keyword filters apply to listings; date windows and upcomingOnly also apply to individual URLs and IDs. Several URLs run in order and share `maxItems`; an event that appears under two inputs is returned once.

```json
{
    "startUrls": [{ "url": "https://lux.org.uk/whats-on/" }],
    "eventType": "",
    "year": "",
    "search": "",
    "upcomingOnly": false,
    "upcomingScanLimit": 100,
    "maxItems": 50,
    "includeContentHtml": true,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

A search for the next exhibitions, as an agent or an API caller would send it:

```json
{ "eventType": "exhibition", "upcomingOnly": true, "maxItems": 10 }
```

Date windows use event dates rather than publication dates. An exhibition starting before `dateFrom` remains eligible if it ends during the window. Narrow older scans with `year`; raise `dateScanLimit` if necessary. Events are examined in publication order. For example, `{"year":"2026","dateFrom":"2026-10-01","dateTo":"2026-12-31","maxItems":10}` selects autumn programme events. To refresh a known event, send its dataset `id` in `eventIds`; unknown IDs produce warnings without error rows.

### Output

Three real rows from a run on 13 October 2026, with long text shortened:

```json
[
    {
        "id": "109219",
        "url": "https://lux.org.uk/event/showing-up/",
        "slug": "showing-up",
        "title": "Showing Up",
        "eventTypes": ["Festival"],
        "eventTypeSlugs": ["festival"],
        "yearTag": "2026",
        "excerpt": "'Showing Up' brings together films, performances and works by artists and filmmakers from the LUX London Critical Forum 25/26. ...",
        "description": "'Showing Up' brings together films, performances and works by artists and filmmakers from the LUX London Critical Forum 25/26. To show up is a simple thing. ...",
        "contentHtml": "<p dir=\"ltr\">&#8216;Showing Up&#8217; brings together films, performances and works by artists and filmmakers from the LUX London Critical Forum 25/26.</p> ...",
        "imageUrl": "https://lux.org.uk/wp-content/uploads/2026/08/IMG_6231-copy-scaled.jpg",
        "publishedAt": "2026-08-20T13:40:06Z",
        "modifiedAt": "2026-08-20T13:41:47Z",
        "startDateText": "13 September, 2026",
        "startDate": "2026-09-13",
        "endDateText": "13 September, 2026",
        "endDate": "2026-09-13",
        "timeText": "2pm – 6pm",
        "venue": "LUX, Waterlow Park Centre, Dartmouth Park Hill, London, N19 5JF, UK",
        "bookingUrl": "https://www.eventbrite.co.uk/e/showing-up-tickets-1998482105776?aff=oddtdtcreator",
        "bookingLabel": "BOOK",
        "isUpcoming": false,
        "scrapedAt": "2026-10-13T13:21:31.075Z",
        "sourceUrl": "https://lux.org.uk/event/showing-up/"
    },
    {
        "id": "109458",
        "url": "https://lux.org.uk/event/late-night-conversations-stuart-marshall-tamara-krikorian/",
        "slug": "late-night-conversations-stuart-marshall-tamara-krikorian",
        "eventTypes": ["Exhibition"],
        "eventTypeSlugs": ["exhibition"],
        "yearTag": "2026",
        "startDateText": "9 October, 2026",
        "startDate": "2026-10-09",
        "endDateText": "12 December, 2026",
        "endDate": "2026-12-12",
        "timeText": "Thursday – Saturday / 12pm – 4pm",
        "venue": "LUX, Waterlow Park Centre, Dartmouth Park Hill, London, N19 5JF, UK",
        "bookingUrl": null,
        "bookingLabel": null,
        "isUpcoming": true
    },
    {
        "id": "23034",
        "url": "https://lux.org.uk/event/bl-ck-b-x-alia-sye/",
        "slug": "bl-ck-b-x-alia-sye",
        "title": "BL CK B X: Alia Syed Wallpaper",
        "eventTypes": ["Exhibition"],
        "eventTypeSlugs": ["exhibition"],
        "yearTag": "2017",
        "excerpt": "To launch our new series of monthly exhibitions of artists' moving image, BL CK B X, we are delighted to present Alia Syed's Wallpaper ...",
        "imageUrl": "https://lux.org.uk/wp-content/uploads/2017/11/HUMGcropsmall-copy-e1513704723672.jpg",
        "publishedAt": "2017-11-30T15:12:07Z",
        "modifiedAt": "2022-12-09T12:04:48Z",
        "startDateText": "10 January, 2018",
        "startDate": "2018-01-10",
        "endDateText": "10 February, 2018",
        "endDate": "2018-02-10",
        "timeText": "Wed-Sat, 12pm – 4pm",
        "venue": "LUX, Waterlow Park Centre",
        "bookingUrl": null,
        "bookingLabel": null,
        "isUpcoming": false,
        "scrapedAt": "2026-10-13T13:21:37.518Z",
        "sourceUrl": "https://lux.org.uk/event/bl-ck-b-x-alia-sye/"
    }
]
```

The dataset view **Overview** shows the title, dates, time, venue, types, the upcoming flag and the booking and event links. The key-value store record `OUTPUT` summarises the run: for each input the REST query used, how many events matched, how many were fetched and returned, and any warnings (a dead URL, an unknown type or year, a search with no hits).

### How much does it cost to scrape LUX?

LUX Events Scraper is charged per result. You pay only for the events returned, and `maxItems` caps how many that can be. With `upcomingOnly`, only the events kept are charged, not the ones examined and dropped. See the Pricing tab for the current price.

### Use with AI agents (MCP)

Connect LUX Events Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/lux-events-scraper"
        }
    }
}
```

Example prompts:

1. "What is on at LUX in London in the coming weeks? Give me the dates, venues and booking links."
2. "List the LUX exhibitions from 2024 with their opening hours."
3. "Find LUX online workshops about distribution or festivals and summarise what each one covers."

Every input field has a description written for agents, every field is optional, and a bad or blocked target returns 0 events with a warning instead of an error, so an agent can retry with different filters.

### Integrations and API

Run LUX Events Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/lux-events-scraper").call(run_input={"upcomingOnly": True, "maxItems": 20})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["startDate"], item["title"], item["venue"], item["bookingUrl"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/lux-events-scraper').call({ eventType: 'exhibition', year: '2024', maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~lux-events-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://lux.org.uk/whats-on/"}], "maxItems": 50}'
```

The Integrations tab connects the Actor to Make, Zapier, n8n, Google Sheets, Slack and webhooks, for example to post each new upcoming event to a channel or append it to a sheet after a scheduled run.

### FAQ

**How many events are there, and how long does a full run take?**
About 750 events from 2011 to today. The Actor makes one API request per 100 events plus one page request per event, at most two requests per second, so the whole programme takes about ten minutes. A run with the default `maxItems` of 50 finishes in under a minute.

**Why does `upcomingOnly` return only a handful of events?**
LUX publishes events shortly before they happen, so at any time only a few of the newest events are still to come. The Actor examines the newest `upcomingScanLimit` events (default 100) and keeps those with an end date on or after the run date. Raise the limit if you believe events are missing.

**Why is `bookingUrl` null for many events?**
The page has no booking button for exhibitions (free, drop-in) and for most past events, whose buttons were removed. The field is filled for roughly half of all events and for nearly every upcoming ticketed event.

**Why do some old events have no `timeText` or `yearTag`?**
Events from 2011 to 2016 were imported without a time line, and the site's year archive starts in 2017. For those years use `search` or the full listing.

**Why did my run return 0 events?**
Either the URL does not exist on lux.org.uk (HTTP 404), the event type, year or search term matches nothing, or the site blocked the requests. The run's status message and the `OUTPUT` record name the cause. For a block, retry later or switch the proxy to a residential group.

**How fresh is the data?**
Every run reads the live site. `publishedAt` and `modifiedAt` tell you when LUX created and last edited each event, and `scrapedAt` when the row was collected.

**Can I get the venue as separate address fields?**
Not yet: the page shows the venue as free text lines, which the Actor joins with commas. Open an issue if you need it split.

### Is it legal to scrape LUX?

The Actor collects only information that lux.org.uk publishes for everyone: event titles, dates, venues, descriptions and booking links. It does not log in, does not solve or bypass any challenge, and keeps its request rate low. Event listings are factual, public information; the descriptions may contain artists' names, so you are responsible for how you use and store the data under the laws that apply to you, such as the GDPR. This is not legal advice.

LUX Events Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by LUX.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `startUrls` (type: `array`):

LUX page URLs as {"url":"https://lux.org.uk/whats-on/"} objects. Accepts /event/, /event/{slug}/, /event_catogories/{slug}/, /years/{year}/ and /?s={keyword}. Empty returns newest events. Listing URLs combine with filters; single event URLs ignore type, year and keyword filters. URLs share maxItems. Dead or blocked targets return no rows with warnings; correct the URL or retry with proxyConfiguration.

## `eventUrls` (type: `array`):

LUX page URLs as strings, e.g. \["https://lux.org.uk/event/showing-up/"]. Accepts the same listing, archive, search and event URLs as startUrls. Both lists combine in order, share maxItems and skip duplicate events. Default \[] adds no URLs.

## `eventIds` (type: `array`):

Positive LUX WordPress event IDs as strings, e.g. IDs from a previous dataset. Default \[] adds none. Runs after URLs, shares maxItems and skips duplicates. Type, year and search filters do not apply; upcomingOnly and date windows do. Unknown IDs return no rows with a warning.

## `eventType` (type: `string`):

Event type to keep, as the lux.org.uk type slug, e.g. 'screening-talk' (the most common), 'exhibition', 'workshop', 'education', 'performance', 'online-exhibition', 'in-dialogue' or 'lux-salon'. Empty (default) = every type. An unknown type returns 0 events with a warning.

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

Alias of eventType for callers that prefer this name; accepts a slug ('screening-talk') or a type name ('Screening/Talk'). Ignored when eventType is set. Default: empty.

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

Programme year to keep, e.g. '2017'. The year archive covers 2017 to the current year (events before 2017 have no year tag: use search or the full listing for them). An unknown year returns 0 events with a warning. Default: every year.

## `search` (type: `string`):

Keyword to search event titles and descriptions for, e.g. 'workshop' or 'Zoom' (the site's own search). A term with no hits returns 0 events with a warning. Default: no keyword.

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

Include events ending on or after this YYYY-MM-DD date. Empty default applies no lower bound. Uses event dates, not publication dates. Combines with dateTo and other filters; undated events are excluded. Examines up to dateScanLimit per target.

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

Include events starting on or before this YYYY-MM-DD date. Empty default applies no upper bound. Inclusive overlap retains exhibitions spanning the window. Must be on or after dateFrom when both are set.

## `dateScanLimit` (type: `integer`):

Maximum newest events examined per target when dateFrom or dateTo is set. Integer 1-1000, default 100; ignored without date bounds. Combine year or search to narrow archive scans. With upcomingOnly, the smaller of this and upcomingScanLimit applies. Only returned events are charged.

## `upcomingOnly` (type: `boolean`):

Set true to keep events ending today or later in UTC, e.g. true. Default false includes past events. Checks newest publications up to upcomingScanLimit and shares maxItems across targets. If no rows match, increase upcomingScanLimit, relax other filters or set false.

## `upcomingScanLimit` (type: `integer`):

Number of newest events to examine when upcomingOnly=true, e.g. 40. Integer 1-1000, default 100; ignored when upcomingOnly=false. Each examined event requires a detail request, but only returned events are charged. Increase this if the upcoming scan returns no rows.

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

Maximum events saved across all URLs and filters, e.g. 10. Integer 0-10000, default 50; 0 collects all matching events up to 10000. Duplicate ids count once. Stops at this shared result limit or the run spending limit; only saved events are charged.

## `includeContentHtml` (type: `boolean`):

Set true to include contentHtml in each row, e.g. true (default). Set false to omit contentHtml and reduce output size; description remains as plain text.

## `proxyConfiguration` (type: `object`):

Proxy configuration object, e.g. {"useApifyProxy":true} (default: Apify datacenter proxy). Blocked requests retry with fresh sessions. If warnings show persistent HTTP 403 or a block page, retry later or select a residential group in this object.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://lux.org.uk/whats-on/"
    }
  ],
  "eventUrls": [],
  "eventIds": [],
  "eventType": "",
  "category": "",
  "year": "",
  "search": "",
  "dateFrom": "",
  "dateTo": "",
  "dateScanLimit": 100,
  "upcomingOnly": false,
  "upcomingScanLimit": 100,
  "maxItems": 10,
  "includeContentHtml": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `events` (type: `string`):

Dataset with one item per event, newest first (overview view).

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

The OUTPUT record: for each input the REST query used, how many events matched, were fetched and returned, and any warnings.

# 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 = {
    "startUrls": [
        {
            "url": "https://lux.org.uk/whats-on/"
        }
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/lux-events-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 = {
    "startUrls": [{ "url": "https://lux.org.uk/whats-on/" }],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/lux-events-scraper").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 '{
  "startUrls": [
    {
      "url": "https://lux.org.uk/whats-on/"
    }
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/lux-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/lux-events-scraper"
        }
    }
}
```

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/EIzwd0xW4yvaNF39F/builds/I8Iv2gK3EPd2wGspg/openapi.json
