> ## Documentation Index
> Fetch the complete documentation index at: https://deepline.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Luma: Get V1 Calendars Events List

> Every event and API key on Luma is managed by a [Luma Calendar](https://help.luma.com/p/luma-calendar-overview). Includes SDK V2 examples, schemas, and cost.

Every event and API key on Luma is managed by a [Luma Calendar](https://help.luma.com/p/luma-calendar-overview).

<Info>
  Tool ID: `luma_get_v1_calendars_events_list`
</Info>

## Run this action

Use the TypeScript SDK for a single call. Put `ctx.tools.execute(...)` inside a Play when the call should be durable, scheduled, or run across a CSV.

```ts theme={null}
import { Deepline } from 'deepline';

const deepline = await Deepline.connect();
const result = await deepline.tools.execute(
  'luma_get_v1_calendars_events_list',
  {
    "before": "2026-01-15T12:00:00Z",
    "after": "2026-01-15T12:00:00Z",
    "pagination_cursor": "cursor_123"
  },
);

console.log(result.toolResponse.raw);
```

### CLI

```bash theme={null}
deepline tools execute luma_get_v1_calendars_events_list --input '{
  "before": "2026-01-15T12:00:00Z",
  "after": "2026-01-15T12:00:00Z",
  "pagination_cursor": "cursor_123"
}' --json
```

## Example response

The static output schema is not detailed enough to generate a reliable example. Use `deepline tools get luma_get_v1_calendars_events_list --json` for the complete live contract.

## Input reference

Every event and API key on Luma is managed by a [Luma Calendar](https://help.luma.com/p/luma-calendar-overview). By default this lists the events your Calendar manages. Each event includes an `access` field. Pass `access=manage&access=view` to also return events that are listed on the Calendar but managed elsewhere — those come back with `access: "view"`, their location obfuscated to city level, and host-only fields like `meeting_url`, `registration_questions`, and `feedback_email` omitted. Private events the Calendar doesn't manage are never returned.

| Name                        | Type                                                       | Required | Default | Details                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| --------------------------- | ---------------------------------------------------------- | -------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payload.before`            | `string`                                                   | No       | —       | ISO 8601 Datetime. For example, 2022-10-19T03:27:13.673Z Format: `date-time`.                                                                                                                                                                                                                                                                                                                                                                                                |
| `payload.after`             | `string`                                                   | No       | —       | ISO 8601 Datetime. For example, 2022-10-19T03:27:13.673Z Format: `date-time`.                                                                                                                                                                                                                                                                                                                                                                                                |
| `payload.pagination_cursor` | `string`                                                   | No       | —       | Value of `next_cursor` from a previous request.                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `payload.pagination_limit`  | `number`                                                   | No       | —       | The number of items to return. The server will enforce a maximum number.                                                                                                                                                                                                                                                                                                                                                                                                     |
| `payload.platforms`         | `array`                                                    | No       | —       | Which event platforms to include. Defaults to `luma` for backwards compatibility. Pass as repeated query params, e.g. `?platforms=luma&platforms=external`.                                                                                                                                                                                                                                                                                                                  |
| `payload.sort_column`       | `"start_at"`                                               | No       | —       | Allowed: `start_at`.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `payload.sort_direction`    | `"asc" \| "desc" \| "asc nulls last" \| "desc nulls last"` | No       | —       | Allowed: `asc`, `desc`, `asc nulls last`, `desc nulls last`.                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `payload.status`            | `"approved" \| "pending"`                                  | No       | —       | Filter by calendar submission status. Defaults to `approved`. Allowed: `approved`, `pending`.                                                                                                                                                                                                                                                                                                                                                                                |
| `payload.access`            | `array`                                                    | No       | —       | Which access values to include (`manage`, `view`). Defaults to `manage`, returning only events the Calendar manages. Pass as repeated query params, e.g. `?access=manage&access=view`. Include `view` to also return events that are listed on the Calendar but managed elsewhere — those entries come back with `access: "view"`, their location obfuscated to city level, and host-only fields like `meeting_url`, `registration_questions`, and `feedback_email` omitted. |

<details>
  <summary>Show raw input schema</summary>

  ### Input JSON Schema

  ```json theme={null}
  {
    "type": "object",
    "description": "Every event and API key on Luma is managed by a [Luma Calendar](https://help.luma.com/p/luma-calendar-overview). By default this lists the events your Calendar manages. Each event includes an `access` field. Pass `access=manage&access=view` to also return events that are listed on the Calendar but managed elsewhere — those come back with `access: \"view\"`, their location obfuscated to city level, and host-only fields like `meeting_url`, `registration_questions`, and `feedback_email` omitted. Private events the Calendar doesn't manage are never returned.",
    "properties": {
      "before": {
        "type": "string",
        "description": "ISO 8601 Datetime. For example, 2022-10-19T03:27:13.673Z",
        "format": "date-time"
      },
      "after": {
        "type": "string",
        "description": "ISO 8601 Datetime. For example, 2022-10-19T03:27:13.673Z",
        "format": "date-time"
      },
      "pagination_cursor": {
        "type": "string",
        "description": "Value of `next_cursor` from a previous request."
      },
      "pagination_limit": {
        "type": "number",
        "description": "The number of items to return. The server will enforce a maximum number."
      },
      "platforms": {
        "type": "array",
        "description": "Which event platforms to include. Defaults to `luma` for backwards compatibility. Pass as repeated query params, e.g. `?platforms=luma&platforms=external`.",
        "items": {
          "type": "string",
          "enum": [
            "luma",
            "external"
          ]
        }
      },
      "sort_column": {
        "type": "string",
        "enum": [
          "start_at"
        ]
      },
      "sort_direction": {
        "type": "string",
        "enum": [
          "asc",
          "desc",
          "asc nulls last",
          "desc nulls last"
        ]
      },
      "status": {
        "type": "string",
        "description": "Filter by calendar submission status. Defaults to `approved`.",
        "enum": [
          "approved",
          "pending"
        ]
      },
      "access": {
        "type": "array",
        "description": "Which access values to include (`manage`, `view`). Defaults to `manage`, returning only events the Calendar manages. Pass as repeated query params, e.g. `?access=manage&access=view`. Include `view` to also return events that are listed on the Calendar but managed elsewhere — those entries come back with `access: \"view\"`, their location obfuscated to city level, and host-only fields like `meeting_url`, `registration_questions`, and `feedback_email` omitted.",
        "items": {
          "type": "string",
          "enum": [
            "manage",
            "view"
          ]
        }
      }
    },
    "required": [],
    "additionalProperties": false
  }
  ```
</details>

## Output reference

Standard tool result payload.

| Name                                                          | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Required | Default | Details                                                                                                                                                                                                                                                         |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `result.data`                                                 | `object`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | Provider response payload.                                                                                                                                                                                                                                      |
| `result.data.entries`                                         | `array`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].platform`                              | `"luma"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].id`                                    | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].user_id`                               | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].calendar_id`                           | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].start_at`                              | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | ISO 8601 Datetime. For example, 2022-10-19T03:27:13.673Z                                                                                                                                                                                                        |
| `result.data.entries[].duration_interval`                     | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | ISO 8601 Duration. For example, PT2H                                                                                                                                                                                                                            |
| `result.data.entries[].end_at`                                | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | ISO 8601 Datetime. For example, 2022-10-19T03:27:13.673Z                                                                                                                                                                                                        |
| `result.data.entries[].created_at`                            | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | ISO 8601 Datetime. For example, 2022-10-19T03:27:13.673Z                                                                                                                                                                                                        |
| `result.data.entries[].timezone`                              | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | IANA Timezone, e.g. America/New\_York. [https://en.wikipedia.org/wiki/List\_of\_tz\_database\_time\_zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)                                                                                        |
| `result.data.entries[].name`                                  | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].cover_url`                             | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].url`                                   | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].visibility`                            | `"public" \| "members-only" \| "private"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].location_type`                         | `"discord" \| "meet" \| "twitch" \| "twitter" \| "youtube" \| "zoom" \| "offline" \| "missing" \| "unknown"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Yes      | —       | `offline` for in-person events. Online events have the meeting platform (`zoom`, `meet`, etc.), or `unknown` if we don't recognize the meeting link. `missing` if the event has no location set.                                                                |
| `result.data.entries[].location_visibility`                   | `"public" \| "guests-only"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | Yes      | —       | Whether the event's address is shown to everyone or only to approved guests. Events you manage always return the full address.                                                                                                                                  |
| `result.data.entries[].waitlist_status`                       | `"disabled" \| "enabled"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Yes      | —       | `enabled` if the event has a waitlist. New registrations join the waitlist once the event reaches capacity.                                                                                                                                                     |
| `result.data.entries[].registration_open`                     | `boolean`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Yes      | —       | Whether the host is accepting registrations. When `false`, registration is closed and new guests can't sign up. Independent of capacity — a sold-out event with `waitlist_status` disabled still reports `true`.                                                |
| `result.data.entries[].require_approval`                      | `boolean`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Yes      | —       | `true` if registering requires host approval — i.e. any currently available ticket has approval turned on.                                                                                                                                                      |
| `result.data.entries[].spots_remaining`                       | `number \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | Spots left before the event hits its max capacity. Null when the event has no capacity limit (even if individual ticket types are capped). Refreshed by a background job, so this can lag a few seconds behind registrations.                                   |
| `result.data.entries[].display_price`                         | `object \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | The starting ticket price shown on the event card. Null when registration is free — or, rarely, when nothing is currently purchasable (e.g. all paid tickets have expired). Refreshed by a background job, so this can lag a few seconds behind ticket changes. |
| `result.data.entries[].display_price.amount`                  | `number`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | Starting (lowest) ticket price in the currency's minor unit (e.g. cents for USD), tax included.                                                                                                                                                                 |
| `result.data.entries[].display_price.currency`                | `"solana_sol" \| "solana_usdc" \| "aed" \| "afn" \| "all" \| "amd" \| "ang" \| "aoa" \| "ars" \| "aud" \| "awg" \| "azn" \| "bam" \| "bbd" \| "bdt" \| "bgn" \| "bhd" \| "bif" \| "bmd" \| "bnd" \| "bob" \| "brl" \| "bsd" \| "bwp" \| "byn" \| "bzd" \| "cad" \| "cdf" \| "chf" \| "clp" \| "cny" \| "cop" \| "crc" \| "cve" \| "czk" \| "djf" \| "dkk" \| "dop" \| "dzd" \| "egp" \| "etb" \| "eur" \| "fjd" \| "fkp" \| "gbp" \| "gel" \| "ghs" \| "gip" \| "gmd" \| "gnf" \| "gtq" \| "gyd" \| "hkd" \| "hnl" \| "htg" \| "huf" \| "idr" \| "ils" \| "inr" \| "isk" \| "jmd" \| "jod" \| "jpy" \| "kes" \| "kgs" \| "khr" \| "kmf" \| "krw" \| "kwd" \| "kyd" \| "kzt" \| "lak" \| "lbp" \| "lkr" \| "lrd" \| "lsl" \| "mad" \| "mdl" \| "mga" \| "mkd" \| "mmk" \| "mnt" \| "mop" \| "mur" \| "mvr" \| "mwk" \| "mxn" \| "myr" \| "mzn" \| "nad" \| "ngn" \| "nio" \| "nok" \| "npr" \| "nzd" \| "omr" \| "pab" \| "pen" \| "pgk" \| "php" \| "pkr" \| "pln" \| "pyg" \| "qar" \| "ron" \| "rsd" \| "rub" \| "rwf" \| "sar" \| "sbd" \| "scr" \| "sek" \| "sgd" \| "shp" \| "sle" \| "sos" \| "srd" \| "std" \| "szl" \| "thb" \| "tjs" \| "tnd" \| "top" \| "try" \| "ttd" \| "twd" \| "tzs" \| "uah" \| "ugx" \| "usd" \| "uyu" \| "uzs" \| "vnd" \| "vuv" \| "wst" \| "xaf" \| "xcd" \| "xof" \| "xpf" \| "yer" \| "zar" \| "zmw"` | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].display_price.is_flexible`             | `boolean`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Yes      | —       | `true` for pay-what-you-want pricing — `amount` is the suggested price and guests can pay more.                                                                                                                                                                 |
| `result.data.entries[].access`                                | `"view"`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json`                      | `object \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | Address info for events you don't manage. When the host has set the address to be visible only to guests, only city-level fields (city, region, country, city\_state) are populated.                                                                            |
| `result.data.entries[].geo_address_json.address`              | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.city`                 | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.region`               | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.country`              | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.city_state`           | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.full_address`         | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.google_maps_place_id` | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.apple_maps_place_id`  | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].geo_address_json.description`          | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].coordinate`                            | `object \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | Latitude and longitude of the event. Obfuscated to a coarse area when the host has set the address to be visible only to guests. Null for online events or when no coordinate is set.                                                                           |
| `result.data.entries[].coordinate.longitude`                  | `number`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].coordinate.latitude`                   | `number`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].tags`                                  | `array`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].tags[].id`                             | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].tags[].name`                           | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].submitted_by`                          | `object \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | The user who submitted or added this event to the calendar. Null when the submitter's account no longer exists or is blocked.                                                                                                                                   |
| `result.data.entries[].submitted_by.id`                       | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].submitted_by.name`                     | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].submitted_by.avatar_url`               | `string`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].submitted_by.email`                    | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | The submitter's account email. Null when not returned.                                                                                                                                                                                                          |
| `result.data.entries[].submitted_by.first_name`               | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].submitted_by.last_name`                | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |
| `result.data.entries[].meeting_url`                           | `string \| null`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Yes      | —       | —                                                                                                                                                                                                                                                               |

The table shows the first 50 fields. Use the live contract below for every field.

<Info>
  This output schema is too large to embed without slowing the page. Get the complete live contract with `deepline tools get luma_get_v1_calendars_events_list --json`.
</Info>

## Deepline cost

* Pricing model: `fixed` (per call).
* Estimated Deepline credits: `0` per pricing unit.
* Provider-native pricing may still exist outside Deepline credit billing.

## Related documentation

* [Luma provider guide](/docs/providers/luma/guide)
* [SDK V2 quickstart](/docs/sdk-v2/quickstart)
* [SDK reference](/docs/sdk-v2/sdk-reference)
* [Run tools across a CSV](/docs/sdk-v2/batch-csv)
