# Humanitix Turbo (`discerning_kickstand/humanitix-turbo-scraper`) Actor

Fast, complete Humanitix event scraper for calendars, tourism feeds, and organiser lists. Reads listings and event pages worldwide and returns ISO start/end times, venue, coordinates, organiser, and ticket prices. Same schema as Eventbrite Turbo. Pay per event from $4 / 1,000. x402 / Skyfire ready.

- **URL**: https://apify.com/discerning\_kickstand/humanitix-turbo-scraper.md
- **Developed by:** [Spielraum](https://apify.com/discerning_kickstand) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 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.
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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

**Humanitix Turbo** is a fast, complete [Humanitix](https://humanitix.com) event scraper for the Apify platform. It turns listing pages and individual event URLs into clean, analysis-ready rows: title, ISO start and end times, venue, coordinates when published, organiser, ticket price, and description.

Use it from the Apify Console, via API, or from an agent with x402 / Skyfire. The first 25 events on a Console try-it cost about **$0.13** on the Free plan. Apify’s new-account credit (about $5) covers a 1,000-event job at Free-plan rates.

Sister actor: [Eventbrite Turbo](https://apify.com/discerning_kickstand/eventbrite-turbo-scraper) — same output fields, same pricing.

### What does Humanitix Turbo do?

Humanitix Turbo reads Humanitix **recommended and search listings** and individual **event pages**, then returns the full description, location, host, and ticket prices.

It works **worldwide**. There is no Australian-only or city-only gate. Optional `city` and `country` filters apply if you want a subset.

Output uses the same schema as Eventbrite Turbo: ISO 8601 timestamps, ISO-2 country codes, and `latitude` / `longitude` when the event page publishes them.

### Why use Humanitix Turbo?

- **Complete extractor** — event page fields, not just listing cards. Category and topics are filled when Humanitix publishes them.
- **Predictable cost** — pay per event, from **$4.00 / 1,000 results** on Gold. No rental fee, no per-page surcharge.
- **Agent-ready** — pay-per-event, limited permissions, no Standby, so agents can pay with x402 / Skyfire.
- **Same schema as Eventbrite Turbo** — join Humanitix and Eventbrite inventories without remapping columns.
- **Apify platform** — schedules, datasets (JSON, CSV, Excel), webhooks, and proxy rotation without running your own infrastructure.

Typical uses: event calendars, local discovery products, competitor monitoring, tourism feeds, and lead lists of organisers.

### How to scrape Humanitix events

1. Open **Humanitix Turbo** in Apify Console and click **Start**.
2. Leave the prefilled Melbourne and Sydney listings, or paste your own Humanitix URLs (`humanitix.com/...` listings or `events.humanitix.com/...` event pages).
3. Optionally set **Location** / **Keyword** instead of Start URLs, and cap **Max events** (default 25).
4. Run. Download the dataset as JSON, CSV, or Excel.

API example:

```json
{
  "startUrls": [{ "url": "https://humanitix.com/au/events/au--vic--melbourne/recommended" }],
  "maxItems": 25
}
```

### Input

The Input tab is the source of truth. The important fields:

- **Start URLs** — listings, search, host pages, or event URLs. When set, they win over location helpers.
- **Location / keyword** — beginner mode: build a discovery URL when Start URLs are empty.
- **City / country** — optional filters on the extracted rows (ISO-2 or a name such as `Australia`).
- **Max events** — hard cap on pushed rows (default 25).
- **Max requests / concurrency** — defaults are conservative so a try-it stays cheap.
- **Proxy** — Apify datacentre proxy is enough for Humanitix.

### Output

You can download the dataset in JSON, HTML, CSV, or Excel. One row is one occurrence (a multi-date event becomes several rows with `isSeries` and `occurrenceIndex`).

```json
{
  "source": "Humanitix",
  "sourceEventId": "night-market",
  "title": "Night market",
  "eventUrl": "https://events.humanitix.com/night-market",
  "startAt": "2026-09-01T18:00:00.000+10:00",
  "endAt": "2026-09-01T21:00:00.000+10:00",
  "timezone": "Australia/Melbourne",
  "venueName": "Fed Square",
  "city": "Melbourne",
  "country": "AU",
  "latitude": -37.818,
  "longitude": 144.969,
  "isOnline": false,
  "priceDisplay": "Free",
  "isFree": true,
  "organiserName": "City host"
}
```

#### Data fields

| Field | Meaning |
| --- | --- |
| `source` | Always `Humanitix` |
| `title`, `eventUrl`, `ticketUrl`, `imageUrl` | Identity |
| `startAt`, `endAt`, `timezone` | When (ISO 8601 with offset) |
| `venueName`, `streetAddress`, `city`, `state`, `postalCode`, `country` | Where |
| `latitude`, `longitude` | Coordinates when published |
| `isOnline`, `attendanceMode` | Online vs in-person |
| `organiserName`, `organiserUrl` | Host |
| `currency`, `priceMin`, `priceMax`, `priceDisplay`, `isFree` | Tickets |
| `description`, `category`, `tags` | Content (`category` is always a shared topic such as Music or Community) |
| `listedFromUrl`, `extractedAt` | Provenance |

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

Pricing is **pay per event** only. The Store card reads **from $4.00 / 1,000 results** (Gold). Free-plan users pay **$5.00 / 1,000**. Actor start uses Apify’s default **$0.00005 per GB**. Platform usage is included in the event price — users are not billed compute or proxy on top.

| Events (Free plan) | Approx. cost |
| --- | --- |
| 25 (default try-it) | $0.13 |
| 100 | $0.50 |
| 1,000 | $5.00 |

There is no extra charge per listing page. Set `maxTotalChargeUsd` (default $5) if you want a hard run cap. The minimum max cost per run is **$0.05**.

### Tips

- Keep **Max events** at 25 while you validate the schema, then raise it.
- Pair with [Eventbrite Turbo](https://apify.com/discerning_kickstand/eventbrite-turbo-scraper) when you need both platforms in one warehouse.

### FAQ

**Is this a Humanitix API?** No. It is a scraper that reads public Humanitix pages. Use it only on content you are allowed to collect.

**Does it work outside Australia?** Yes. Optional country/city filters are the only geographic limits.

**Can agents pay with x402 / Skyfire?** Yes. Limited permissions and no Standby, so agents can pay with x402 or Skyfire.

**Where do I report a broken listing?** Use the actor **Issues** tab on Apify.

This actor extracts publicly visible event information. Follow Humanitix terms, robots.txt, and the laws that apply to you. You are responsible for how you use the dataset.

# Actor input Schema

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

Humanitix listing, search, host, or individual event URLs. When set, this list wins over location / keyword helpers.

## `location` (type: `string`):

City or place used to build a discovery URL when Start URLs are empty (for example Melbourne or Sydney).

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

Optional. Keep only rows whose city matches this value (case-insensitive substring).

## `country` (type: `string`):

Optional ISO-2 or name (AU, GB, United Kingdom). Keeps only matching rows.

## `keyword` (type: `string`):

Optional search term used when Start URLs are empty.

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

Hard cap on dataset rows. Default 25 keeps a Console try-it around $0.13 on the Free plan.

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

Maximum total page requests (0 = unlimited).

## `maxConcurrency` (type: `integer`):

How many listing pages to process in parallel.

## `httpMaxConcurrency` (type: `integer`):

How many event pages to process in parallel.

## `includePastEvents` (type: `boolean`):

When true, events whose end time has already passed are included.

## `defaultDurationHours` (type: `number`):

Assumed duration when no end time can be found.

## `defaultTimeZone` (type: `string`):

IANA time zone when the event does not publish one.

## `scrollListPages` (type: `boolean`):

Scroll listing pages to load more events.

## `listPageScrolls` (type: `integer`):

How many times to scroll each listing page.

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

Proxy settings. Datacentre Apify Proxy is enough for Humanitix.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://humanitix.com/au/events/au--vic--melbourne/recommended"
    },
    {
      "url": "https://humanitix.com/au/events/au--nsw--sydney/recommended"
    }
  ],
  "maxItems": 25,
  "maxRequestsPerCrawl": 80,
  "maxConcurrency": 4,
  "httpMaxConcurrency": 20,
  "includePastEvents": false,
  "defaultDurationHours": 2,
  "defaultTimeZone": "Australia/Melbourne",
  "scrollListPages": true,
  "listPageScrolls": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset of scraped event rows (one row per occurrence).

# 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://humanitix.com/au/events/au--vic--melbourne/recommended"
        },
        {
            "url": "https://humanitix.com/au/events/au--nsw--sydney/recommended"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("discerning_kickstand/humanitix-turbo-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://humanitix.com/au/events/au--vic--melbourne/recommended" },
        { "url": "https://humanitix.com/au/events/au--nsw--sydney/recommended" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("discerning_kickstand/humanitix-turbo-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://humanitix.com/au/events/au--vic--melbourne/recommended"
    },
    {
      "url": "https://humanitix.com/au/events/au--nsw--sydney/recommended"
    }
  ]
}' |
apify call discerning_kickstand/humanitix-turbo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,discerning_kickstand/humanitix-turbo-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/fCSOhK15CNOTsWdon/builds/gkg11uCI4yfAEBKlf/openapi.json