Request payload

The following API operations require a request payload of type PipesRequestPayload:

• POST https://api.pipe0.com/v1/pipes/run (create an enrichment task)
• POST https://api.pipe0.com/v1/pipes/run/sync (create an enrichment task and return the result)

Both accept the same payload; see sync vs async for the trade-offs. To check a payload without running it, send it to POST /v1/pipes/validate: it returns {"valid": true} or the exact validation errors, and costs nothing.

Here's a sample payload:

{
  "config": {
    "environment": "sandbox",
    "widgets": {
      "enabled": false
    },
    "field_definitions": {
      "enabled": false
    }
  },
  "pipes": [
    {
      "pipe_id": "company:identity@3",
      "config": {
        "input_fields": {
          "company_name": {
            "alias": ""
          }
        },
        "output_fields": {
          "company_domain": {
            "enabled": true,
            "alias": ""
          }
        }
      }
    }
  ],
  "input": [
    {
      "id": 1,
      "name": "Tom Schmidt",
      "company_name": "Pipe0"
    }
  ]
}

Request payload properties

config

Request-wide configuration. Optional; omit it to use the defaults.

config.environment

Execute your request in sandbox or production mode. Sandbox returns mock data and costs nothing. Defaults to production.

config.widgets.enabled

Enable or disable widget metadata. Widgets are part of the pipes response and are often used to visualize enriched results (for example, provider logos). Defaults to false.

config.field_definitions.enabled

When true, the response's top-level field_definitions map describes every field in your pipeline. When false (the default), the response returns an empty field_definitions object.

pipes[]

An array of pipes to run, each with an optional configuration. All available pipes are listed in the pipe catalog.

You don't have to order the array yourself. pipe0 builds a dependency graph from what each pipe reads and writes and derives the execution order from it, so a pipe can read the output of any other pipe in the request. Circular or unresolvable dependencies fail validation.

pipe.pipe_id

The unique identifier of a pipe.

pipe.config

The pipe's config object. Its full shape is documented per pipe in the pipe catalog. Configuration is optional. Any keys you leave out are filled in from the pipe's default config, so a partial config only overrides what you set.

pipe.run_if

A condition that decides per record whether the pipe runs. See run_if conditions.

pipe.connector

Choose which connection the pipe authenticates with, for example your own provider API key instead of pipe0's managed one. See Connections.

pipe.config.providers

For pipes with multiple providers, choose which providers run and in which order. Learn more about waterfall pipes.

pipe.config.input_fields

Pipe configuration for the input fields of a pipe.

pipe.config.input_field.alias

Point an input field of a pipe to a custom field name.

Example: your records store the company name under custom_company_name, but the pipe reads company_name. Set "alias": "custom_company_name" on the company_name input field to point the pipe at your field.

The field you point to must have the correct type. A wrong type doesn't fail validation; it fails at processing time, per record, with a TypeMismatch reason on the affected field.

pipe.config.output_fields

Pipe configuration for the output fields of a pipe.

pipe.config.output_field.alias

Rename a pipe output field to a different field_name. Two pipes writing the same output field is an error; alias one of them to avoid the collision.

pipe.config.output_field.enabled

Enable or disable output fields. The pipe catalog lists which fields are enabled by default.

input[]

An array of input objects. This is the data you want to enrich. A request accepts at most 100 input objects; send larger workloads in chunks.

input.id

Each input object's id must be unique; duplicate ids fail validation. The id can be a string or a number, as simple as 1, 2, 3. If you omit it, pipe0 assigns a random UUID, which you'll need to correlate results, so passing your own ids is almost always better.

input[number]

Each object in the input array represents an input object.

input[fieldName]

Each property of an input object represents an input field. Input fields are used as pipe input after input sanitation.