# AXS Scraper - Events, Venues and Ticketing Status (`lentic_clockss/axs-scraper`) Actor

Extract AXS events, venues, performers, series and promotions across nine regional catalogs (US, UK, AU, SE, CA, NZ, DE, FR, JP). Get dates, venue addresses and public ticketing status; inventory requires an invitation. Pay per delivered row plus a start fee.

- **URL**: https://apify.com/lentic_clockss/axs-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Travel, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 15 total users, 5 monthly users, 95.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.20 / 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

**Extract AXS events, venues and ticketing status as structured rows for calendars, research and alerts — across US, UK, AU, SE, CA, NZ, DE, FR and JP catalogs.**

- Event titles, dates, venues, addresses and public sale status.
- Performers, series, promotions, genres and catalog URLs.
- On-sale configuration and invitation-only inventory snapshots, when available.
- Pay $3.00 per 1,000 delivered rows on the Free plan, plus a start fee.

### What does AXS Scraper do?

AXS Scraper collects public information from AXS.com. It does not buy or reserve tickets and is not affiliated with AXS or AEG.

- **Find events:** `home`, `search`, `category`, `detail` and `venue`.
- **Find entities:** `performer`, `series`, `offers`, `genres`, `catalog` and `discovery`.
- **Check ticketing:** `onsale`, `inventory` and `watch`.
- **Optional ticket-offer rows:** `includeOffers` is off by default. Each additional row is billed at the same rate and counts toward the input's row limit.

### What data can you extract from AXS?

Every row has `rowType` and a string `id`. Tables show selected fields; not every source supplies all of them. Catalog event entries use rowType `event_link`; other catalog entries use their entity's row type. All catalog rows have `recordType: "catalog"` and hold IDs and URLs only.

#### Events (`event`)

| Field | Description | Example |
| --- | --- | --- |
| `eventId` | AXS event ID | `1445907` |
| `title` | Event name | `Example concert` |
| `url` | Event page | `https://www.axs.com/events/1445907` |
| `eventDateTimeUTC` | Start time in UTC | `2026-12-12T02:00:00Z` |
| `statusLabel` | Public sale label | `On Sale` |
| `priceBasis` | How to interpret prices | `unavailable` |

#### Venues (`venue`)

| Field | Description | Example |
| --- | --- | --- |
| `venueName` | Venue name | `Example Hall` |
| `address` | Venue address fields | `{"locality":"Denver","country":"US"}` |
| `phones` | Public contact numbers, if shown | `[]` |
| `emails` | Public email addresses, if shown | `[]` |
| `leadAbsences` | Reasons contact fields are empty | `{"emails":"not_exposed_by_source"}` |

#### Performers (`performer`)

| Field | Description | Example |
| --- | --- | --- |
| `performerId` | Artist ID | `9` |
| `name` | Public artist name | `Example Band` |

#### Series (`series`)

| Field | Description | Example |
| --- | --- | --- |
| `seriesId` | Series ID | `12` |

#### Promotions (`offer`)

| Field | Description | Example |
| --- | --- | --- |
| `offerId` | Promotion ID, not a seat ID | `1` |

#### Genres (`genre`)

| Field | Description | Example |
| --- | --- | --- |
| `title` | Genre label | `Rock` |

#### Tours (`tour`)

| Field | Description | Example |
| --- | --- | --- |
| `tourId` | Tour ID from `discovery` | `123` |

#### Sale-status checks (`watch`)

| Field | Description | Example |
| --- | --- | --- |
| `availabilityStatus` | Public availability label | `on_sale` |
| `changedFields` | Changes since the previous available check | `["availabilityStatus"]` |
| `becameAvailable` | Transition back to sale | `true` |
| `resaleShell` | Primary sold out, AXS Official Resale still lists tickets | `false` |
| `recommendedIntervalSec` | Suggested time before another check | `180` |

#### On-sale configuration (`onsale`)

| Field | Description | Example |
| --- | --- | --- |
| `ticketUrlKind` | Ticket page category | `primary` |
| `onsale` | Available delivery methods, restrictions and configuration | `{}` |

#### Inventory snapshots (`inventory`)

| Field | Description | Example |
| --- | --- | --- |
| `inventoryObserved` | Whether inventory was observed | `true` |
| `inventoryGranularity` | Detail level of the observation | `price_level` |

#### Ticket offers (`ticket_offer`)

| Field | Description | Example |
| --- | --- | --- |
| `parentId` | Parent event-level row ID | `1445907` |
| `offerGranularity` | Offer, product or price-level detail | `price_level` |
| `availableQuantity` | Observed quantity, when supplied | `8` |

### How to scrape AXS

1. Open [AXS Scraper](https://apify.com/lentic_clockss/axs-scraper) in Apify Console.
2. Fill one target field, such as `searchQuery` with `concert`.
3. Set `maxResults` to `3` for a small first run.
4. Click **Start** and wait for completion.
5. Download the dataset or read it through the API.

An empty input runs a `concert` search with the form's example values, capped at 3 rows, billed normally. With `mode: "auto"`, a target field selects the mode. Clear the prefilled keyword when switching to another target.

#### Home

Use `home` for upcoming events in the scanned pages, not a complete calendar.

#### Search

Use `searchQuery` for a keyword. Put locations in `city`, not the keyword.

#### Category

Choose `music`, `sports`, `theatre`, `festival` or `comedy`. A supported city or AXS city listing URL also selects a listing.

#### Detail

Supply `eventIds` or event URLs in `startUrls`.

#### Venue

Supply `venueIds` or venue URLs.

#### Catalog

Enumerate event, venue, performer or series URLs. Continue with `RUN_SUMMARY.diagnostics.nextCursor` as `cursor`, keeping the same `entityTypes`.

Catalog event entries are `event_link` rows. An `event_link` row has `rowType`, `id`, `eventId`, `entityType`, `url`, `title`, `lastModified`, `images`, `source`, `engine`, `coverageBasis`, `recordType` and `scrapedAt`. The `id` is the numeric event ID.

The `title` is built from the URL slug. It is not the real event name. An `event_link` row has no event name, date, venue or prices. For full event rows, run `detail` mode with `eventIds`.

#### Performer

Supply `performerIds` for specific artists, or leave them empty to list performers.

#### Series

Supply `seriesIds`, found via `catalog`.

#### Offers

List promotions, optionally by `offerIds`; they are not ticket-seat offers.

#### Genres

Use `genres` without a target for genre labels.

#### Discovery

Export `events`, `venues`, `performers` or `tours`. Keyword, city, category and date filters are unsupported here.

#### Onsale

Use `onsale` with event IDs or purchase links for configuration, not guaranteed inventory; no invitation key is needed. Supply at most 20 targets per run.

#### Inventory

Supply up to 10 targets and a developer-issued `inventoryKey`. Without valid access, no inventory rows return and warnings include `inventory_locked`; queues, expired links or rate limits can also block access.

#### Watch

Check up to 50 event IDs once per run. The suggested interval is 180 seconds, or 60 near the show; `null` means the show is over. `inventoryOnChange` optionally captures inventory after a return to sale, requires an invitation key and is limited to two events per run.

### What to fill in

| Field | What to enter | Default |
| --- | --- | --- |
| `mode` | A mode above, or automatic selection | `auto` |
| `searchQuery`, `q` | Keyword; `q` is an alias | Empty; prefill `concert` |
| `startUrls`, `eventIds` | AXS URLs or event IDs | Empty |
| `venueIds`, `performerIds`, `seriesIds`, `offerIds` | IDs for that entity | Empty |
| `ticketUrls` | AXS purchase links for `onsale` or `inventory` | Empty |
| `category` | One of the five categories above | Empty |
| `city`, `cityId`, `citySlug` | City name, or ID and slug from an AXS city URL | Empty |
| `market` | Regional catalog: `us`, `uk`, `au`, `se`, `ca`, `nz`, `de`, `fr`, `jp` | `us` |
| `maxResults` | Rows per input, 1–5,000 | `70`; prefill `3` |
| `maxPages` | Listing pages to scan, 1–5 | `1` |
| `page`, `pageOffset` | Continuation page and position within it | `1`, `0` |
| `cursor` | Catalog continuation string | Empty |
| `entityTypes` | Entity names supported by the selected mode | `["events"]` |
| `siteIds` | Optional numeric AXS catalog partitions; at most 8 | Market's main catalog |
| `startDate`, `endDate` | Inclusive event-date bounds; ISO date or datetime | Empty |
| `enrichDetails`, `enrichVenue` | Add event details and venue addresses | `true` |
| `memberLinks` | Series mode: add each member event's purchase page (`promoId`, `promoPageUrl`, `ticketUrl` when missing) via a headless browser, once per series; region-blocked pages leave no links | `true` |
| `includeOffers` | Separate ticket-offer rows in `onsale` or `inventory` | `false` |
| `includeSeats` | Keep observed seat labels on ticket-offer rows | `true` |
| `inventoryKey` | Invitation key; keep it private | Empty |
| `nearShowHours` | Watch's near-show window, 1–168 hours | `24` |
| `inventoryOnChange` | Capture inventory after a return to sale | `false` |
| `watchState` | Watch baseline `{eventId: snapshot}`: feed back the last run's watch row fields so a scheduled run detects changes | `{}` |
| `includeRaw`, `fields` | Public source fields or selected output fields | `false`, empty |
| `availabilityStatus` | Keep only listing-mode event rows with these statuses: `on_sale`, `presale`, `sold_out`, `resale_only`, `coming_soon`, `unavailable`, `cancelled`, `postponed`, `unknown` | Empty (all) |
| `officialOnly` | In `inventory`, skip resale-marketplace targets; primary rows only | `false` |

Examples by mode:

**Home**

```json
{"mode":"home","maxResults":3}
```

**Search**

```json
{"mode":"search","searchQuery":"concert","maxResults":3}
```

**Category**

```json
{"mode":"category","category":"music","city":"Denver, CO","maxResults":3}
```

**Detail**

```json
{"mode":"detail","eventIds":["1445907"],"maxResults":1}
```

**Venue**

```json
{"mode":"venue","venueIds":["124944"],"maxResults":3}
```

**Catalog**

```json
{"mode":"catalog","entityTypes":["series"],"maxResults":3}
```

**Performer**

```json
{"mode":"performer","maxResults":3}
```

**Series**

```json
{"mode":"series","seriesIds":["12"],"maxResults":3}
```

**Offers**

```json
{"mode":"offers","maxResults":3}
```

**Genres**

```json
{"mode":"genres","maxResults":3}
```

**Discovery**

```json
{"mode":"discovery","entityTypes":["tours"],"maxResults":3}
```

**Onsale**

```json
{"mode":"onsale","eventIds":["1445907"],"includeOffers":true,"maxResults":3}
```

**Inventory**

```json
{"mode":"inventory","eventIds":["1445907"],"inventoryKey":"YOUR_INVITATION_KEY","maxResults":1}
```

**Watch**

```json
{"mode":"watch","eventIds":["1445907"],"maxResults":1}
```

`maxItems` and `limit` are accepted as `maxResults`. Close field-name misspellings are corrected; other unknown fields are ignored with a note. Unusable input stops before row delivery with an `INVALID_INPUT:` message naming the problem and expected form. No rows are charged for that failure; the start fee still applies. A missing required target can instead select another filled target or the example run.

### Output example

Illustrative event row (example title and date):

```json
{
  "rowType": "event",
  "id": "1445907",
  "eventId": "1445907",
  "title": "Example concert",
  "url": "https://www.axs.com/events/1445907",
  "eventDateTimeUTC": "2026-12-12T02:00:00Z",
  "venueName": "Example Hall",
  "market": "us",
  "statusLabel": "On Sale",
  "priceLow": null,
  "priceHigh": null,
  "priceBasis": "unavailable",
  "phones": [],
  "emails": [],
  "source": "axs.com"
}
```

Export the dataset as JSON, CSV, Excel, XML, RSS or an HTML table. The key-value store also contains `INPUT_ECHO`, `RUN_SUMMARY` and, for terminal failures, `ERROR_SUMMARY`.

### Why use this AXS scraper?

- **Pay for delivered rows:** unsuccessful requests are not separate billable rows.
- **Understand missing data:** unavailable prices stay `null` and absent contacts stay empty.
- **Batch targets:** send several IDs or URLs in one run.
- **No proxy setup:** you do not need to set up proxies.

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

Pricing is pay-per-event: a $0.005 start event plus a price per delivered row. The start charge is one event per GB of memory, with a minimum of one event. At the default 512 MB, the start charge is $0.005. Platform usage is included in these prices.

| Apify plan | Price per row | Price per 1,000 rows |
| --- | --- | --- |
| Free | $0.003 | $3.00 |
| Starter | $0.003 | $3.00 |
| Scale | $0.0026 | $2.60 |
| Business | $0.0022 | $2.20 |
| Platinum | $0.002 | $2.00 |
| Diamond | $0.0016 | $1.60 |

`maxResults` applies to each input, defaults to 70 and allows up to 5,000. Larger requests are collected in parts of 70. All row types share that input's limit. Free-plan runs stop at 200 rows, and the developer allows 10 runs of this Actor on that plan. The whole run stops at **Maximum cost per run** (`maxTotalChargeUsd` in the API).

Example: one search delivering 3 rows on the Free plan at 512 MB costs `3 × $0.003 + $0.005 = $0.014`.

- The Apify Free plan includes **$5.00** in monthly usage credit (about **1,666 rows** at `$0.003` per row across Free-plan runs capped at 200 rows per run).

### What happens when the run timeout is too short

A run that needs longer can pause automatically. Its status message says "Queued on the collection backend; this run will resume automatically when results are ready (about N s)." It temporarily appears as `ABORTED`, rather than a collection failure.

When results are ready, the same run resumes, reports "Resumed: delivering N rows.", writes to the same dataset and finishes as `SUCCEEDED` if collection succeeds. Already delivered rows are not delivered or charged twice.

Automatic pauses are limited to 3 per run. Keep the default 600-second timeout to reduce interruptions.

Rows reach the dataset as they are collected, not only at the end of the run. A run stopped by its own timeout, by `maxTotalChargeUsd` or by a cancelled run keeps every row delivered up to that point, and those rows are the ones charged.

Synchronous endpoints (`run-sync`, `run-sync-get-dataset-items`) wait at most 300 seconds and may return an empty dataset while the run is paused. For longer jobs, start asynchronously and read the dataset after `SUCCEEDED`, or use a succeeded-event webhook.

### Use with AI agents and the API

#### Apify MCP server (Claude, ChatGPT, Cursor, VS Code)

Add this remote server to your MCP client:

```text
https://mcp.apify.com?tools=lentic_clockss/axs-scraper
```

Sign in with Apify using OAuth, or send `Authorization: Bearer <YOUR_APIFY_TOKEN>`. The tool starts a run and returns run and dataset IDs; read rows with `get-dataset-items`. Clients without remote support can use `npx @apify/actors-mcp-server --tools lentic_clockss/axs-scraper` with `APIFY_TOKEN` set.

Example prompt: "Search AXS for concert and return at most 3 events with dates and venue names."

- **Agent execution note:** Set `maxResults` between `5` and `20` on exploratory tool calls to keep responses compact, and read `RUN_SUMMARY` and `INPUT_REPORT` from the default key-value store to inspect normalized inputs and delivered row counts. When a long run briefly reports `ABORTED` with the automatic-resume status message, wait for the same run ID to finish as `SUCCEEDED` instead of starting a duplicate run.

#### Apify API

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lentic_clockss/axs-scraper").call(
    run_input={"searchQuery": "concert", "maxResults": 3}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('lentic_clockss/axs-scraper').call({
  searchQuery: 'concert', maxResults: 3
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

For asynchronous HTTP use, send input JSON to `POST https://api.apify.com/v2/acts/lentic_clockss~axs-scraper/runs` with an `Authorization: Bearer <YOUR_APIFY_TOKEN>` header. After completion, read `GET https://api.apify.com/v2/datasets/<datasetId>/items?format=json`.

#### Integrations

Use the **Integrations** tab to connect results to Google Sheets, Make, Zapier, n8n, Slack, Airtable or a webhook.

### FAQ

#### Is it legal to scrape AXS?

The Actor collects public data. You are responsible for complying with applicable terms and data-protection law. Processing personal data requires a lawful basis; public availability alone does not establish one.

#### Why did my run end as ABORTED?

Check its status message. An automatic pause resumes without intervention; a manual abort is different. See the timeout section above.

#### What does "New runs are paused until the live proxy configuration is confirmed." mean?

The Actor is temporarily not accepting new runs, so the run collects no rows; start it again later. Until 13 November 2026 the message was Chinese, beginning with `"\u5b9e\u65f6\u4ee3\u7406\u914d\u7f6e\u5c1a\u672a\u5b8c\u6210\u5bf9\u8d26"` (JSON-escaped).

#### How many results can I get?

Up to `maxResults` per input, subject to available matches, scanned pages, the run's cost cap and free-plan limits. It is a ceiling, not a guaranteed count. Since 2026-11-13 10:46 UTC, in home, detail, venue and category modes, and searches for events only without city, category or date filters, an event AXS returns without a required field no longer counts toward `maxResults`; the Actor moves to the next event. A run left with no rows because every event was skipped fails, with the skip warning as its status message.

#### Why are some fields empty?

AXS may not expose them. Metadata prices are not final quotes, and a zero placeholder is not a free ticket.

#### Why are event fields gone from `leadAbsences`?

`leadAbsences` explains empty contact fields only. Until 13 November 2026, it also listed missing event fields in Chinese, such as `"\u672c\u7ad9\u65e0\uff1asource=api_detail record has no boxOffice key"` (JSON-escaped). `quality.missingFields` now marks them `unavailable_in_surface` instead of `not_present`, with no `quality.evidence`.

#### Are inventory quantities individual seats?

Not necessarily. `inventoryGranularity` can be `price_level`.

#### Does the Actor buy tickets?

No. Purchase links are observation inputs.

#### How do I continue a listing?

Read `RUN_SUMMARY.diagnostics`. Where present, use `nextPage` and `nextPageOffset` as `page` and `pageOffset`, keeping the same filters. Catalog uses `nextCursor`.

#### Which cities work?

Use a city name within the selected market or an AXS city URL. For an unknown city ID, supply its `citySlug`; never put the city in `searchQuery`.

### Limitations

- Nine regional catalogs are supported (`us`, `uk`, `au`, `se`, `ca`, `nz`, `de`, `fr`, `jp`). `inventory` and `onsale` route by the event's region, not `market`; other storefronts are not covered.
- City, category and date filters apply within scanned pages. Check `coverageTruncated`; a short page does not prove complete coverage.
- Inventory access and seat detail are not guaranteed.
- `includeOffers` works only in `onsale` and `inventory`. A target without offers may still return an event-level row.
- Attribute lists are capped at 50 entries, with counts when truncated.
- Watch comparisons need a previous observation (in-memory, or passed in `watchState`); not a permanent history.

### Related scrapers

More event and ticketing scrapers from the same publisher:

- [Ticketmaster Scraper](https://apify.com/lentic_clockss/ticketmaster-scraper)
- [SeatGeek Scraper](https://apify.com/lentic_clockss/seatgeek-scraper)
- [StubHub Scraper](https://apify.com/lentic_clockss/stubhub-scraper)
- [Eventim Scraper](https://apify.com/lentic_clockss/eventim-scraper)
- [Eventbrite Scraper](https://apify.com/lentic_clockss/eventbrite-scraper)
- [Stealth Web Scraper](https://apify.com/lentic_clockss/stealth-web-scraper)
- [Email Validator](https://apify.com/lentic_clockss/email-risk-validator)

Browse all of our scrapers at [apify.com/lentic_clockss](https://apify.com/lentic_clockss).

### Support

Found a problem or need another field? Open an issue in the **Issues** tab of this Actor's page and include the run ID and the input you used. Remove invitation keys and tokens before sharing input.

# Actor input Schema

## `mode` (type: `string`):

Auto selects a mode from the target fields you fill; empty input starts a small example search. Choose inventory for invitation-only snapshots, onsale for ticket configuration, watch for one status check, or discovery for an unfiltered export.

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

AXS event, venue or category URLs. In inventory or onsale mode, AXS purchase links and shop.axs.com redirect links are also accepted; no ticket purchase or reservation is made.

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

Numeric AXS IDs from event URLs such as /events/1445907. Each ID is a separate input for maxResults; all targets share the run timeout and maximum cost.

## `ticketUrls` (type: `array`):

AXS purchase links for inventory or onsale, such as https://tix.axs.com/<token> or https://tickets-{cc}.axs.com/<token>. Used only to observe ticket information, never to buy or reserve.

## `venueIds` (type: `array`):

Numeric AXS IDs from venue URLs such as /venues/124944.

## `performerIds` (type: `array`):

Numeric artist IDs from AXS performer URLs or catalog rows. Leave empty in performer mode to list performers.

## `seriesIds` (type: `array`):

AXS series IDs for series mode. Find IDs with catalog mode first.

## `offerIds` (type: `array`):

Promotion IDs for offers mode. These identify promotions, not ticket seats.

## `searchQuery` (type: `string`):

Keyword for search mode, such as concert. Enter a location in city or cityId instead.

## `q` (type: `string`):

Alternative name for searchQuery.

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

Filter events by music, sports, theatre, festival or comedy within the scanned pages. A limited scan does not guarantee complete coverage.

## `city` (type: `string`):

Supported US city name, such as Denver, CO. Results are matched against the venue city and state.

## `cityId` (type: `string`):

City ID from an AXS URL with the form /category/cities/{id}/{slug}. For an unknown ID, also provide citySlug.

## `citySlug` (type: `string`):

City slug from an AXS city URL, such as denver-co. Required when the cityId is not already recognized.

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

Most Dataset rows for each search query, URL, or ID input (or for the selected browse mode when no list is supplied). Default 70; larger numbers are collected in parts of 70. All row types count together for that input. The run stops at your maximum total charge. Free Apify plan: 200 rows per run and 10 runs of this Actor.

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

Maximum listing pages to scan, from 1 to 5, starting at page. This does not guarantee that the entire catalog has been scanned.

## `market` (type: `string`):

Regional AXS catalog: us, uk, au, se, ca, nz, de, fr or jp. us/uk use their siteId partitions; other markets filter the discovery feed by country. Inventory and onsale modes route by the event's region automatically.

## `enrichDetails` (type: `boolean`):

Add event details to listing rows when available. Enabled by default.

## `enrichVenue` (type: `boolean`):

Add information from the venue page when an event lacks a full address. Enabled by default.

## `memberLinks` (type: `boolean`):

Series mode only: add each member event's promotion purchase page (promoId, promoPageUrl, and ticketUrl when missing). Uses the headless page lane once per series and may fail gracefully behind region blocks, in which case rows are still returned without links. Enabled by default.

## `entityTypes` (type: `array`):

Catalog supports events, venues, performers and series; search supports events, venues and performers. Discovery supports events, venues, performers and tours.

## `siteIds` (type: `array`):

Optional numeric AXS catalog partition IDs for event listings, up to 8. The default is the selected market's main catalog partition; search, discovery, catalog and entity modes ignore this field.

## `includeSeats` (type: `boolean`):

Keep observed seat labels on ticket-offer rows when includeOffers is enabled. Attribute lists are limited to 50 entries, with a count when shortened.

## `includeOffers` (type: `boolean`):

Return separate ticket-offer rows in inventory or onsale mode, with parent event fields copied onto each row. All row types share the input limit; disabled by default.

## `nearShowHours` (type: `integer`):

For watch mode, the suggested check interval drops from 180 to 60 seconds inside this many hours before the show.

## `inventoryOnChange` (type: `boolean`):

In watch mode, also capture inventory when tickets return to sale, for at most two events per run. Requires an inventoryKey and is disabled by default.

## `watchState` (type: `object`):

Optional baseline map eventId -> previous watch snapshot (fields availabilityStatus/statusLabel/onsaleUrlLookupId/priceLow/priceHigh/onsaleDateTimeUTC/presaleDateTimeUTC/ticketEntry/checkedAt). Pass the prior run's row fields back so transition detection works across separate scheduled runs.

## `inventoryKey` (type: `string`):

Developer-issued invitation key required for inventory mode and watch inventoryOnChange. Without valid access, inventory is not collected and warnings include inventory_locked; onsale and status-only watch need no key.

## `includeRaw` (type: `boolean`):

Include additional public source fields after removing credential-like keys. Disabled by default.

## `availabilityStatus` (type: `array`):

Only emit event rows whose availabilityStatus is one of the selected values (listing modes only).

## `officialOnly` (type: `boolean`):

Skip resale-marketplace targets in inventory mode; emit primary/official rows only.

## `fields` (type: `array`):

Optional list of output fields to retain. Identity and contact fields are kept even when not listed.

## `page` (type: `integer`):

Starting page for listing or entity results. Use the previous run's nextPage value to continue with the same filters.

## `pageOffset` (type: `integer`):

Rows to skip within the starting page, from 0 to 49. Use the previous run's nextPageOffset value.

## `cursor` (type: `string`):

Catalog continuation string from RUN_SUMMARY.diagnostics.nextCursor. Keep the same entityTypes when continuing.

## `startDate` (type: `string`):

Inclusive lower bound for event time, as an ISO date or datetime in UTC. Applies within the scanned results and does not move forward automatically.

## `endDate` (type: `string`):

Inclusive upper bound for event time, as an ISO date or datetime in UTC. Applies within the scanned results and does not move forward automatically.

## `workerBaseUrl` (type: `string`):

Leave empty. Used only by the developer for testing.

## Actor input object example

```json
{
  "mode": "auto",
  "searchQuery": "concert",
  "maxResults": 3,
  "maxPages": 1,
  "market": "us",
  "enrichDetails": true,
  "enrichVenue": true,
  "memberLinks": true,
  "entityTypes": [
    "events"
  ],
  "includeSeats": true,
  "includeOffers": false,
  "nearShowHours": 24,
  "inventoryOnChange": false,
  "watchState": {},
  "includeRaw": false,
  "availabilityStatus": [],
  "officialOnly": false,
  "page": 1,
  "pageOffset": 0
}
```

# Actor output Schema

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

Delivered AXS entity, status, configuration and optional ticket-offer rows.

## `runSummary` (type: `string`):

Run outcome, row count, warnings and available continuation values.

## `inputEcho` (type: `string`):

Input settings used for the run, with secret values omitted.

## `errorSummary` (type: `string`):

Error details saved when collection ends with a terminal failure.

# 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 = {
    "mode": "auto",
    "searchQuery": "concert",
    "maxResults": 3,
    "maxPages": 1,
    "market": "us",
    "enrichDetails": true,
    "enrichVenue": true,
    "memberLinks": true,
    "entityTypes": [
        "events"
    ],
    "includeSeats": true,
    "includeOffers": false,
    "inventoryOnChange": false,
    "includeRaw": false,
    "officialOnly": false,
    "page": 1,
    "pageOffset": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/axs-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 = {
    "mode": "auto",
    "searchQuery": "concert",
    "maxResults": 3,
    "maxPages": 1,
    "market": "us",
    "enrichDetails": True,
    "enrichVenue": True,
    "memberLinks": True,
    "entityTypes": ["events"],
    "includeSeats": True,
    "includeOffers": False,
    "inventoryOnChange": False,
    "includeRaw": False,
    "officialOnly": False,
    "page": 1,
    "pageOffset": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/axs-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 '{
  "mode": "auto",
  "searchQuery": "concert",
  "maxResults": 3,
  "maxPages": 1,
  "market": "us",
  "enrichDetails": true,
  "enrichVenue": true,
  "memberLinks": true,
  "entityTypes": [
    "events"
  ],
  "includeSeats": true,
  "includeOffers": false,
  "inventoryOnChange": false,
  "includeRaw": false,
  "officialOnly": false,
  "page": 1,
  "pageOffset": 0
}' |
apify call lentic_clockss/axs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lentic_clockss/axs-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/mjjQSG1zj1bE61HYH/builds/QQTtfQd6Cl5IcpD7o/openapi.json