# Luma Attendee Profile Exporter (`trovevault/luma-attendee-profile-exporter`) Actor

Exports enriched Luma event attendee rows with registration answers, social profile links, company, job title, and follow-up segments.

- **URL**: https://apify.com/trovevault/luma-attendee-profile-exporter.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Jobs, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 leads

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/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

## Luma Attendee Profile Exporter

Export enriched attendee data from events you manage on Luma. The actor uses the official Luma API to turn guest registrations into a clean follow-up table with contact details, social profile links, company, job title, registration answers, and a practical follow-up segment.

Luma's native exports are useful when you only need names and emails. This actor is for event organizers, community teams, founder-network operators, and sponsors who need the extra profile context guests submitted in registration forms.

### Requirements

You need:

- a Luma API key for a calendar or organization that can manage the event
- the Luma event ID
- permission to export and process the attendee data for that event

Luma currently lists API access as a paid-plan feature. If your Luma account cannot create or use API keys, this actor cannot access private attendee fields on your behalf. It does not scrape Luma pages, automate login, or bypass Luma account permissions.

### Why Use It

Use this actor when you want to:

- prioritize post-event outreach by profile completeness
- find attendees with LinkedIn, X/Twitter, Instagram, GitHub, Telegram, or YouTube links
- identify founders, executives, community operators, marketers, and other high-value attendee segments
- preserve custom registration answers in a structured dataset
- append event attendee rows into a larger Apify workflow using `datasetId` or `runId`
- export several guest statuses in one run, such as approved attendees plus waitlist or pending approval guests

### What You Get

Each attendee row can include:

- attendee name, email, guest status, registration time, invite time, and check-in time
- company and job title when collected by the event form
- social profile links when guests provided them
- long-text registration answers normalized into `bioOrDescription`
- all registration answers preserved in `registrationAnswers`
- ticket type names when available in the guest record
- `followUpSegment`, such as `Founder or executive`, `Community or marketing`, or `Social follow-up`
- `profileCompletenessScore` so richer profiles can be prioritized first

### How To Use

1. Create or copy a Luma API key from an account with access to the target event.
2. Copy the Luma event ID.
3. Choose the guest statuses to export.
4. Run the actor and download the default dataset as JSON, CSV, Excel, or through the Apify API.

### Input

```json
{
  "lumaApiKey": "YOUR_LUMA_API_KEY",
  "eventId": "evt-abc123",
  "guestStatuses": ["approved", "waitlist"],
  "maxGuests": 500
}
````

#### Input Fields

- `lumaApiKey` - Your Luma API key. This is stored as a secret input in Apify.
- `eventId` - The Luma event ID to export.
- `guestStatuses` - One or more guest statuses to export. The default is `approved`.
- `maxGuests` - Maximum number of guests to export across the selected statuses.
- `datasetId` - Optional Apify dataset ID to append the same rows into another dataset.
- `runId` - Optional pipeline identifier copied into each output row.

If `lumaApiKey` or `eventId` is empty, the actor returns one `setup_required` row explaining what to add. This keeps Apify's automated checks stable without exposing a confusing demo-mode toggle.

### Output Example

```json
{
  "rowType": "attendee",
  "guestId": "gst-001",
  "userId": "usr-001",
  "guestName": "Maya Chen",
  "firstName": "Maya",
  "lastName": "Chen",
  "email": "maya@example.com",
  "approvalStatus": "approved",
  "registeredAt": "2026-06-20T16:15:00.000Z",
  "company": "Northstar Labs",
  "jobTitle": "Founder",
  "linkedinUrl": "https://www.linkedin.com/in/maya-chen-growth",
  "twitterUrl": null,
  "instagramUrl": null,
  "githubUrl": null,
  "bioOrDescription": "Building analytics tools for event-led communities.",
  "ticketTypes": ["Founder Pass"],
  "socialProfiles": {
    "linkedin": "https://www.linkedin.com/in/maya-chen-growth"
  },
  "registrationAnswers": {
    "Company": {
      "company": "Northstar Labs",
      "jobTitle": "Founder"
    },
    "LinkedIn": "maya-chen-growth",
    "What are you working on?": "Building analytics tools for event-led communities."
  },
  "followUpSegment": "Founder or executive",
  "profileCompletenessScore": 67
}
```

### API Example

```bash
curl "https://api.apify.com/v2/acts/trovevault~luma-attendee-profile-exporter/runs?waitForFinish=120" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "lumaApiKey": "YOUR_LUMA_API_KEY",
    "eventId": "evt-abc123",
    "guestStatuses": ["approved"],
    "maxGuests": 500
  }'
```

After the run finishes, download rows from the default dataset URL in the run output.

### Notes And Limits

- The actor only works for events your Luma API key can access.
- It requires Luma API access, which may require a paid Luma plan.
- It does not scrape public attendee pages, automate Luma login, or bypass Luma access controls.
- Social links, company, job title, and bios appear only when they are included in the event's Luma guest registration data.
- If a guest did not provide a social link or description, the corresponding output field is `null`.
- Selecting multiple statuses may make multiple Luma API list requests, but results are deduplicated by guest ID where possible.
- Luma's documented rate limits are 200 requests per minute for calendar API keys/OAuth tokens and 500 requests per minute for organization API keys.

### Troubleshooting

**I get a setup-required row.** Add both `lumaApiKey` and `eventId`. The default example intentionally leaves them empty so scheduled platform checks can run without private credentials.

**The run fails with a Luma API authorization error.** Confirm the API key belongs to a Luma account that can manage the event and that the account has API access.

**Social links or bios are missing.** The actor can only export fields present in the Luma guest registration data returned by the API. Add social/profile questions to future event registration forms if you need richer rows.

**I selected several statuses and got fewer rows than expected.** `maxGuests` applies to the total export across all selected statuses.

### FAQ

**Does this work without Luma Plus or API access?** No. The actor uses the official Luma API. A CSV-only workflow would not recover profile fields that Luma does not include in the export.

**Can it export attendees from events I do not manage?** No. Your API key must have access to the event.

**Can I use this in automations?** Yes. Use Apify schedules, webhooks, API calls, or downstream dataset processing. For repeat exports, keep `maxGuests` aligned with your expected event size.

### Daily Test Strategy

The actor's prefilled input intentionally leaves private Luma credentials empty. That produces one `setup_required` row in seconds, proving the output schema, dataset view, and Apify run lifecycle without storing or requiring real attendee data. Buyer runs add their own Luma API key and event ID to export attendee rows.

### Changelog

- `0.1` - Initial release with official Luma API export, multi-status filtering, social/profile normalization, setup-required daily-test path, and Apify dataset output.

# Actor input Schema

## `lumaApiKey` (type: `string`):

Your Luma API key for a calendar or organization that can manage the target event. Luma API access may require a paid Luma plan. If this is empty, the actor returns a setup-required row explaining what to add.

## `eventId` (type: `string`):

The Luma event ID to export. It usually starts with evt-. If this is empty, the actor returns a setup-required row explaining what to add.

## `guestStatuses` (type: `array`):

Select one or more guest statuses to export. Use Approved for the usual attendee follow-up list, or add Pending approval, Waitlist, Invited, or Session when you want a wider event pipeline.

## `maxGuests` (type: `integer`):

Maximum guests to export. Lower this for quick tests; raise it for full event exports.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append results into in addition to the default dataset.

## `runId` (type: `string`):

Pipeline run identifier to copy into each output row when chaining this actor with other workflows.

## Actor input object example

```json
{
  "eventId": "evt-abc123",
  "guestStatuses": [
    "approved"
  ],
  "maxGuests": 500
}
```

# Actor output Schema

## `datasetUrl` (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("trovevault/luma-attendee-profile-exporter").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("trovevault/luma-attendee-profile-exporter").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 '{}' |
apify call trovevault/luma-attendee-profile-exporter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/luma-attendee-profile-exporter",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Attendee Profile Exporter",
        "description": "Exports enriched Luma event attendee rows with registration answers, social profile links, company, job title, and follow-up segments.",
        "version": "0.1",
        "x-build-id": "ejdWYvlRCAwZJuZnV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~luma-attendee-profile-exporter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-luma-attendee-profile-exporter",
                "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/trovevault~luma-attendee-profile-exporter/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-luma-attendee-profile-exporter",
                "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/trovevault~luma-attendee-profile-exporter/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-luma-attendee-profile-exporter",
                "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",
                "properties": {
                    "lumaApiKey": {
                        "title": "Luma API key",
                        "type": "string",
                        "description": "Your Luma API key for a calendar or organization that can manage the target event. Luma API access may require a paid Luma plan. If this is empty, the actor returns a setup-required row explaining what to add."
                    },
                    "eventId": {
                        "title": "Luma event ID",
                        "type": "string",
                        "description": "The Luma event ID to export. It usually starts with evt-. If this is empty, the actor returns a setup-required row explaining what to add."
                    },
                    "guestStatuses": {
                        "title": "Guest statuses",
                        "type": "array",
                        "description": "Select one or more guest statuses to export. Use Approved for the usual attendee follow-up list, or add Pending approval, Waitlist, Invited, or Session when you want a wider event pipeline.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "approved",
                                "pending_approval",
                                "invited",
                                "declined",
                                "waitlist",
                                "session"
                            ],
                            "enumTitles": [
                                "Approved",
                                "Pending approval",
                                "Invited",
                                "Declined",
                                "Waitlist",
                                "Session"
                            ]
                        },
                        "default": [
                            "approved"
                        ]
                    },
                    "maxGuests": {
                        "title": "Max guests",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum guests to export. Lower this for quick tests; raise it for full event exports.",
                        "default": 500
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results into in addition to the default dataset."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "Pipeline run identifier to copy into each output row when chaining this actor with other workflows."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```