> ## 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.

# Lemlist: List Enrichment Waterfalls

> List your team's default and custom Lemlist enrichment waterfalls. Includes SDK V2 guidance, input constraints, response fields, and Deepline credit cost.

List your team's default and custom Lemlist enrichment waterfalls.

> [!NOTE]
>
> Tool ID: `lemlist_list_enrichment_waterfalls`

## Run this action

Use the TypeScript SDK for one call. Use `ctx.tools.execute(...)` inside a Play for durable calls, scheduled calls, or CSV processing.

```ts theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
import { Deepline } from 'deepline';

const deepline = await Deepline.connect();
const result = await deepline.tools.execute(
  'lemlist_list_enrichment_waterfalls',
  {
    "type": "email"
  },
);

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

### CLI

```bash theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
deepline tools execute lemlist_list_enrichment_waterfalls --input '{
  "type": "email"
}' --json
```

## Example response

The static output schema lacks the details for a reliable example. Use `deepline describe lemlist_list_enrichment_waterfalls --json` for the complete live contract.

## Input reference

Lists the waterfalls of your team: the default waterfall of each type, plus every custom waterfall. Default waterfalls come first, then custom waterfalls by creation date, most recent first. Waterfalls are team-shared: every member sees the same list.

| Name | Type | Required | Default | Details |
| - | - | - | - | - |
| `payload.type` | `"email" \| "phone"` | No | — | Restrict the list to one enrichment type. Omit to return both. Allowed: `email`, `phone`. |

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

  ### Input JSON Schema

  ```json theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
  {
    "type": "object",
    "description": "Lists the waterfalls of your team: the default waterfall of each type, plus every custom waterfall. Default waterfalls come first, then custom waterfalls by creation date, most recent first. Waterfalls are team-shared: every member sees the same list.",
    "properties": {
      "type": {
        "type": "string",
        "description": "Restrict the list to one enrichment type. Omit to return both.",
        "enum": [
          "email",
          "phone"
        ]
      }
    },
    "required": [],
    "additionalProperties": false
  }
  ```
</details>

## Output reference

Standard tool result payload.

| Name | Type | Required | Default | Details |
| - | - | - | - | - |
| `result.data` | `object` | Yes | — | Provider response payload. |
| `result.data.data` | `array` | No | — | Default waterfalls first, then custom waterfalls most recently created first |
| `result.data.data[].id` | `string` | Yes | — | Waterfall id. Always `default_email` or `default_phone` for a default waterfall, even after it was edited. custom waterfalls get an id prefixed with `ecw_`. |
| `result.data.data[].type` | `"email" \| "phone"` | Yes | — | Kind of data the waterfall looks for. Allowed: `email`, `phone`. |
| `result.data.data[].name` | `string` | Yes | — | Display name, 1 to 100 characters. |
| `result.data.data[].isDefault` | `boolean` | Yes | — | `true` for the team's default waterfall of this type (one per type, cannot be created or deleted). `false` for a custom waterfall. |
| `result.data.data[].editor` | `string` | Yes | — | Who defined the provider order. `lemlist` on a default waterfall nobody edited: connected external providers first, then internal providers in a random order (tier by tier for phone, see `providers[].tier`). `providers` then shows a reference order. Otherwise the id of the team member who last edited the waterfall (`usr_` prefix): `providers` is then followed as is. Custom waterfalls always have a user editor. |
| `result.data.data[].conditions` | `object` | No | — | Conditions on the contact being enriched, keyed by contact property. Every key present must match for the waterfall to run. New keys will be added over time. unknown keys are rejected. |
| `result.data.data[].conditions.country` | `object` | No | — | The contact's resolved country (from its `location`, `country` or company data), as ISO 3166-1 alpha-2 codes. |
| `result.data.data[].conditions.country.in` | `array` | No | — | Countries that match. Unique. |
| `result.data.data[].conditions.country.out` | `array` | No | — | Countries that exclude the contact. Unique, disjoint from `in`. At least one of `in` or `out` must be non-empty. |
| `result.data.data[].providers` | `array` | Yes | — | Execution order. Always contains every provider of the catalog for this `type` exactly once, disabled ones included. External providers appear only while connected. A newly connected one is appended disabled on custom waterfalls. |
| `result.data.data[].providers[].order` | `integer` | No | — | Execution rank, starting at 1, matching the position in the array. Returned only. Minimum: 1. |
| `result.data.data[].providers[].id` | `string` | Yes | — | Provider id, from `GET /enrichments/providers`. |
| `result.data.data[].providers[].enabled` | `boolean` | Yes | — | Disabled providers keep their position but are skipped at enrichment time. |
| `result.data.data[].providers[].image` | `string` | No | — | Path of the provider logo shown in the lemlist app, relative to the app origin. Read-only. |
| `result.data.data[].providers[].source` | `"internal" \| "external"` | No | — | `internal`: paid with lemlist credits. `external`: called with your own API key. Read-only. Allowed: `internal`, `external`. |
| `result.data.data[].providers[].shuffled` | `boolean` | No | — | Only on a default waterfall while its `editor` is `lemlist`. `true`: tried in a random position among the other shuffled providers. `false`: always tried first, at its position (providers you connected with your own API key). Read-only. |
| `result.data.data[].providers[].tier` | `integer` | No | — | Only on the default phone waterfall while its `editor` is `lemlist`. Phone providers are tried tier by tier, in a random order inside each tier. Read-only. Minimum: 1. |
| `result.data.data[].createdAt` | `string \| null` | Yes | — | `null` on a default waterfall that was never edited. Format: `date-time`. |
| `result.data.data[].updatedAt` | `string \| null` | Yes | — | `null` on a default waterfall that was never edited. Format: `date-time`. |
| `result.meta` | `object` | No | — | Additional response metadata (status, paging). |

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

  ### Output JSON Schema

  ```json theme={"languages":{"custom":["/languages/deepline-prompt.json"]}}
  {
    "type": "object",
    "description": "Standard tool result payload.",
    "properties": {
      "data": {
        "type": "object",
        "description": "Provider response payload.",
        "properties": {
          "data": {
            "type": "array",
            "description": "Default waterfalls first, then custom waterfalls most recently created first",
            "items": {
              "type": "object",
              "description": "An ordered list of providers for one enrichment type.",
              "properties": {
                "id": {
                  "type": "string",
                  "description": "Waterfall id. Always `default_email` or `default_phone` for a default waterfall, even after it was edited; custom waterfalls get an id prefixed with `ecw_`."
                },
                "type": {
                  "type": "string",
                  "description": "Kind of data the waterfall looks for.",
                  "enum": [
                    "email",
                    "phone"
                  ]
                },
                "name": {
                  "type": "string",
                  "description": "Display name, 1 to 100 characters."
                },
                "isDefault": {
                  "type": "boolean",
                  "description": "`true` for the team's default waterfall of this type (one per type, cannot be created or deleted). `false` for a custom waterfall."
                },
                "editor": {
                  "type": "string",
                  "description": "Who defined the provider order. `lemlist` on a default waterfall nobody edited: connected external providers first, then internal providers in a random order (tier by tier for phone, see `providers[].tier`); `providers` then shows a reference order. Otherwise the id of the team member who last edited the waterfall (`usr_` prefix): `providers` is then followed as is. Custom waterfalls always have a user editor."
                },
                "conditions": {
                  "type": "object",
                  "description": "Conditions on the contact being enriched, keyed by contact property. Every key present must match for the waterfall to run. New keys will be added over time; unknown keys are rejected.",
                  "properties": {
                    "country": {
                      "type": "object",
                      "description": "The contact's resolved country (from its `location`, `country` or company data), as ISO 3166-1 alpha-2 codes.",
                      "properties": {
                        "in": {
                          "type": "array",
                          "description": "Countries that match. Unique.",
                          "items": {
                            "type": "string",
                            "pattern": "^[A-Z]{2}$"
                          }
                        },
                        "out": {
                          "type": "array",
                          "description": "Countries that exclude the contact. Unique, disjoint from `in`. At least one of `in` or `out` must be non-empty.",
                          "items": {
                            "type": "string",
                            "pattern": "^[A-Z]{2}$"
                          }
                        }
                      },
                      "additionalProperties": false
                    }
                  },
                  "additionalProperties": false
                },
                "providers": {
                  "type": "array",
                  "description": "Execution order. Always contains every provider of the catalog for this `type` exactly once, disabled ones included. External providers appear only while connected; a newly connected one is appended disabled on custom waterfalls.",
                  "items": {
                    "type": "object",
                    "description": "One step of a waterfall. In requests, the position in the `providers` array is the execution order and `order` is ignored. In responses, `order` is always present.",
                    "properties": {
                      "order": {
                        "type": "integer",
                        "description": "Execution rank, starting at 1, matching the position in the array. Returned only.",
                        "minimum": 1
                      },
                      "id": {
                        "type": "string",
                        "description": "Provider id, from `GET /enrichments/providers`."
                      },
                      "enabled": {
                        "type": "boolean",
                        "description": "Disabled providers keep their position but are skipped at enrichment time."
                      },
                      "image": {
                        "type": "string",
                        "description": "Path of the provider logo shown in the lemlist app, relative to the app origin. Read-only."
                      },
                      "source": {
                        "type": "string",
                        "description": "`internal`: paid with lemlist credits. `external`: called with your own API key. Read-only.",
                        "enum": [
                          "internal",
                          "external"
                        ]
                      },
                      "shuffled": {
                        "type": "boolean",
                        "description": "Only on a default waterfall while its `editor` is `lemlist`. `true`: tried in a random position among the other shuffled providers; `false`: always tried first, at its position (providers you connected with your own API key). Read-only."
                      },
                      "tier": {
                        "type": "integer",
                        "description": "Only on the default phone waterfall while its `editor` is `lemlist`. Phone providers are tried tier by tier, in a random order inside each tier. Read-only.",
                        "minimum": 1
                      }
                    },
                    "required": [
                      "id",
                      "enabled"
                    ],
                    "additionalProperties": false
                  }
                },
                "createdAt": {
                  "type": [
                    "string",
                    "null"
                  ],
                  "description": "`null` on a default waterfall that was never edited.",
                  "format": "date-time"
                },
                "updatedAt": {
                  "type": [
                    "string",
                    "null"
                  ],
                  "description": "`null` on a default waterfall that was never edited.",
                  "format": "date-time"
                }
              },
              "required": [
                "id",
                "type",
                "name",
                "isDefault",
                "editor",
                "providers",
                "createdAt",
                "updatedAt"
              ],
              "additionalProperties": false
            }
          }
        },
        "additionalProperties": false
      },
      "meta": {
        "type": "object",
        "description": "Additional response metadata (status, paging).",
        "additionalProperties": true
      }
    },
    "required": [
      "data"
    ],
    "additionalProperties": false
  }
  ```
</details>

## Deepline cost

* Pricing model: `fixed` (per call).
* Waterfall orchestration is free. Individual provider lookups within the waterfall are charged at their listed rates (see provider pricing above).
* Typical cost: 0.3-1.0 credits for email waterfalls, 1-5 credits for phone waterfalls.

## Related documentation

* [Lemlist provider guide](https://deepline.com/docs/providers/lemlist/guide.md)
* [SDK V2 quickstart](https://deepline.com/docs/sdk-v2/quickstart.md)
* [SDK reference](https://deepline.com/docs/sdk-v2/sdk-reference.md)
* [Run tools across a CSV](https://deepline.com/docs/sdk-v2/batch-csv.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.