Quickstart guide

This guide walks through the order in which to create resources for a complete Prequel Import pipeline. Each step links to the corresponding API reference page and includes an expandable curl example.

Select your onboarding experience

Get started with the Prequel agent skill, the Prequel MCP server, a Postman collection, or curl commands.

Agent skill
MCP server
Postman
curl commands

Skills are an open standard for packaging reusable agent capabilities. Claude Code, Cursor, and other skill-aware agents can all load the Prequel Import skill.

Save the skill to your agent's skills directory

Open the raw skill file, copy the contents, and save the file to your agent’s skills directory. For Claude Code use ~/.claude/skills/prequel-import-quickstart/SKILL.md. For Cursor use .cursor/skills/prequel-import-quickstart/SKILL.md in your project root and reload the workspace.

Prompt your agent

Begin an agentic Prequel Import configuration using this prompt.

Mintlify auto-hosts an MCP server for this documentation site, exposing search and filesystem tools your agent can call to look up the right operations and schemas.

Connect your AI tool to the Prequel Import MCP server

Add https://docs.prequel.co/mcp to your tool’s MCP configuration. Most clients accept the URL directly through their MCP settings.

Prompt your agent

Begin an agentic Prequel Import configuration using this prompt.

Import the OpenAPI spec into Postman

In Postman, click Import, paste the Prequel Import OpenAPI spec URL, and confirm. Postman generates a complete collection from the spec with one request per operation.

Set your API key as a collection variable

Add a PREQUEL_API_KEY variable to the imported collection and reference it from each request’s X-API-Key header.

Open the API reference

Browse the API reference and select the operation for the resource you want to create.

Copy the sample request body to your clipboard

Use the Copy button on each operation’s example request body, paste it into your shell as the -d payload, and substitute your variables and resource IDs as you go.

Prerequisites

Access your Prequel API key

You will need a Prequel API key. If you do not have one, contact your Prequel representative to get access. The API key used in the X-API-Key header will route your request to either production or staging based on the key.

Set your API key

export PREQUEL_API_KEY="<your-key>"

Stand up a delivery target

Stand up a spec-compliant API endpoint to receive delivered records.

Verify Prequel API access

Confirm your key works against the API. A 200 response means your environment is ready. Select the tab that matches your deployment: US, EU, or a dedicated or self-hosted deployment on your own host.

US
EU
Dedicated or self-hosted

Verify API access

curl -H "X-API-Key: $PREQUEL_API_KEY" https://api.prequel.co/

Verify API access

curl -H "X-API-Key: $PREQUEL_API_KEY" https://eu-api.prequel.co/

Verify API access

curl -H "X-API-Key: $PREQUEL_API_KEY" https://<your_prequel_api_host>/

Setup overview

Prequel Import should follow a three phase setup to prevent errors from missing dependencies:

Prepare your environment by creating a Datalake. The Datalake is a one-time setup shared across all Providers.
Configure and validate a data source by creating a Provider, Source, and Dataset, then triggering and verifying an Extract to confirm the Source, Dataset, and Datalake are configured correctly before adding delivery.
Connect and deliver by standing up a delivery endpoint, creating a Destination (and optionally a custom Product), creating a Stream, testing the transform and the load, then triggering and verifying a Load.

Set up your pipeline

Each call returns a resource ID in the response body. Record the IDs as you go, since later steps reference them with placeholders such as <DATALAKE_ID> and <DESTINATION_ID>.

Phase 1: prepare your environment

Create a Datalake

Provision a bucket on S3, GCS, Azure Blob Storage, or an S3-compatible store to back the Datalake, then create the Datalake referencing that bucket. Typically, a single multi-tenant Datalake is created and reused across Providers, since Prequel automatically partitions the bucket internally by Provider. You may create and assign additional Datalakes if you prefer bucket-level isolation for Providers. See Datalake for configuration steps and open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Create datalake

curl -X POST https://api.prequel.co/import/datalakes \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "datalake": {
      "name": "primary-datalake",
      "storage": "s3",
      "s3": {
        "bucket_name": "<your-bucket>",
        "bucket_region": "us-east-1",
        "prefix": "prequel-import",
        "auth_method": "aws_iam_role",
        "aws_iam_role": {
          "aws_iam_role_arn": "<your-role-arn>"
        }
      }
    }
  }'

Create datalake

curl -X POST https://eu-api.prequel.co/import/datalakes \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "datalake": {
      "name": "primary-datalake",
      "storage": "s3",
      "s3": {
        "bucket_name": "<your-bucket>",
        "bucket_region": "us-east-1",
        "prefix": "prequel-import",
        "auth_method": "aws_iam_role",
        "aws_iam_role": {
          "aws_iam_role_arn": "<your-role-arn>"
        }
      }
    }
  }'

Create datalake

curl -X POST https://<your_prequel_api_host>/import/datalakes \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "datalake": {
      "name": "primary-datalake",
      "storage": "s3",
      "s3": {
        "bucket_name": "<your-bucket>",
        "bucket_region": "us-east-1",
        "prefix": "prequel-import",
        "auth_method": "aws_iam_role",
        "aws_iam_role": {
          "aws_iam_role_arn": "<your-role-arn>"
        }
      }
    }
  }'

Phase 2: configure and validate a data source

Repeat this phase for each Provider you onboard. Each Provider can have multiple Sources and multiple Datasets.

Create a Provider

A Provider represents a customer or tenant of your platform. The Provider references the Datalake by ID and the assigned Products. Pass the special ["all"] Product to grant access to every Destination when customers share all Destinations. If a customer should only have access to a subset of Destinations, use Products to restrict Destinations by Provider. See Providers, or open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Create provider

curl -X POST https://api.prequel.co/import/providers \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": {
      "name": "Acme Corp",
      "id": "acme",
      "datalake_id": "<DATALAKE_ID>",
      "products": ["all"]
    }
  }'

Create provider

curl -X POST https://eu-api.prequel.co/import/providers \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": {
      "name": "Acme Corp",
      "id": "acme",
      "datalake_id": "<DATALAKE_ID>",
      "products": ["all"]
    }
  }'

Create provider

curl -X POST https://<your_prequel_api_host>/import/providers \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": {
      "name": "Acme Corp",
      "id": "acme",
      "datalake_id": "<DATALAKE_ID>",
      "products": ["all"]
    }
  }'

Create a Source

A Source is the Provider’s database Prequel will read from. See Sources for the supported vendors and per-vendor fields and open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Create source

curl -X POST https://api.prequel.co/import/sources \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {
      "name": "acme-postgres",
      "vendor": "postgres",
      "provider_id": "<PROVIDER_ID>",
      "postgres": {
        "host": "db.acme.example.com",
        "port": 5432,
        "database": "production",
        "auth_method": "password_auth",
        "password_auth": {
          "username": "prequel",
          "password": "<password>"
        }
      }
    }
  }'

Create source

curl -X POST https://eu-api.prequel.co/import/sources \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {
      "name": "acme-postgres",
      "vendor": "postgres",
      "provider_id": "<PROVIDER_ID>",
      "postgres": {
        "host": "db.acme.example.com",
        "port": 5432,
        "database": "production",
        "auth_method": "password_auth",
        "password_auth": {
          "username": "prequel",
          "password": "<password>"
        }
      }
    }
  }'

Create source

curl -X POST https://<your_prequel_api_host>/import/sources \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "source": {
      "name": "acme-postgres",
      "vendor": "postgres",
      "provider_id": "<PROVIDER_ID>",
      "postgres": {
        "host": "db.acme.example.com",
        "port": 5432,
        "database": "production",
        "auth_method": "password_auth",
        "password_auth": {
          "username": "prequel",
          "password": "<password>"
        }
      }
    }
  }'

Preview the Source table (optional)

Confirm the Source connection and read access to the table you plan to import. To check connectivity without naming a table, use test source instead. Open the API reference for the full request schema.

Preview source

curl -X POST https://api.prequel.co/import/sources/<SOURCE_ID>/preview \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "method": "table",
    "table": {
      "source_table_namespace": "public",
      "source_table_name": "users"
    }
  }'

Create a Dataset

A Dataset represents a structured table of data that Prequel will replicate from the Source. The Dataset declares its extraction method (table for a single table, sql for a custom query, glob for object-storage paths) and certain special columns and configuration options. This step is repeated for each Provider’s table to be imported. See Datasets and Change Detection for incremental sync configuration, or open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Create dataset

curl -X POST https://api.prequel.co/import/datasets \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "dataset": {
      "source_id": "<SOURCE_ID>",
      "method": "table",
      "table": {
        "source_table_namespace": "public",
        "source_table_name": "users"
      },
      "type": "dimension",
      "dimension": {
        "primary_key_column": "id",
        "last_modified_column": "updated_at"
      },
      "frequency_minutes": 60
    }
  }'

Create dataset

curl -X POST https://eu-api.prequel.co/import/datasets \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "dataset": {
      "source_id": "<SOURCE_ID>",
      "method": "table",
      "table": {
        "source_table_namespace": "public",
        "source_table_name": "users"
      },
      "type": "dimension",
      "dimension": {
        "primary_key_column": "id",
        "last_modified_column": "updated_at"
      },
      "frequency_minutes": 60
    }
  }'

Create dataset

curl -X POST https://<your_prequel_api_host>/import/datasets \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "dataset": {
      "source_id": "<SOURCE_ID>",
      "method": "table",
      "table": {
        "source_table_namespace": "public",
        "source_table_name": "users"
      },
      "type": "dimension",
      "dimension": {
        "primary_key_column": "id",
        "last_modified_column": "updated_at"
      },
      "frequency_minutes": 60
    }
  }'

Trigger an Extract to validate

The Extract pulls Dataset rows into the Datalake. Trigger one now to confirm the Source, Dataset, and Datalake are configured correctly before moving on to delivery. A successful Extract verifies authentication to the Source, read access to the Dataset’s table, and write access to the Datalake. Open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Initialize extract

curl -X POST https://api.prequel.co/import/datasets/<DATASET_ID>/extract \
  -H "X-API-Key: $PREQUEL_API_KEY"

Initialize extract

curl -X POST https://eu-api.prequel.co/import/datasets/<DATASET_ID>/extract \
  -H "X-API-Key: $PREQUEL_API_KEY"

Initialize extract

curl -X POST https://<your_prequel_api_host>/import/datasets/<DATASET_ID>/extract \
  -H "X-API-Key: $PREQUEL_API_KEY"

Verify the Extract

Poll the Extract to confirm completion without error. If records_errored is non-zero, call extract debug with has_error=true to retrieve row-level errors. Open the API reference for the full response schema.

Get extract

curl https://api.prequel.co/import/extracts/<EXTRACT_ID> \
  -H "X-API-Key: $PREQUEL_API_KEY"

Sample the extracted records and copy one record_id, the Dataset’s primary key value, for the next phase. Open the API reference for the full request schema.

Sample extracted records

curl -X POST https://api.prequel.co/import/datasets/<DATASET_ID>/random-sample \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "sample_size": 5 }'

Phase 3: connect and deliver

Repeat for each Dataset/Destination pair.

Create a Destination

A Destination is one of your delivery endpoints. Each Destination is configured with a record_schema that describes the records your endpoint expects and a request_template that defines the URL and auth headers. See Destinations and the Batch API specification, or open the API reference for the full request schema.Repeat this step for each Destination you need.

Confirm your delivery endpoint from the prerequisites is reachable. Prequel validates connectivity during creation.

US
EU
Dedicated or self-hosted

Create destination

curl -X POST https://api.prequel.co/import/destinations \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": {
      "name": "primary-destination",
      "type": "webhook_record",
      "record_schema": { "type": "object", "required": ["id"], "properties": { "id": { "type": "string" } } },
      "webhook_record": {
        "request_template": {
          "uri": "https://your-app.example.com/prequel/records",
          "method": "POST"
        }
      }
    }
  }'

Create destination

curl -X POST https://eu-api.prequel.co/import/destinations \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": {
      "name": "primary-destination",
      "type": "webhook_record",
      "record_schema": { "type": "object", "required": ["id"], "properties": { "id": { "type": "string" } } },
      "webhook_record": {
        "request_template": {
          "uri": "https://your-app.example.com/prequel/records",
          "method": "POST"
        }
      }
    }
  }'

Create destination

curl -X POST https://<your_prequel_api_host>/import/destinations \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": {
      "name": "primary-destination",
      "type": "webhook_record",
      "record_schema": { "type": "object", "required": ["id"], "properties": { "id": { "type": "string" } } },
      "webhook_record": {
        "request_template": {
          "uri": "https://your-app.example.com/prequel/records",
          "method": "POST"
        }
      }
    }
  }'

Create a custom Product (optional)

By default, every Destination you create is included in a built-in all Product. Skip this step and reference all when you create a Provider, unless you want to group Destinations differently. To define a custom group, create a Product and include the Destination IDs you want it to cover. Open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Create product

curl -X POST https://api.prequel.co/import/products \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "product": {
      "name": "primary-product",
      "destinations": ["<DESTINATION_ID>"]
    }
  }'

Create product

curl -X POST https://eu-api.prequel.co/import/products \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "product": {
      "name": "primary-product",
      "destinations": ["<DESTINATION_ID>"]
    }
  }'

Create product

curl -X POST https://<your_prequel_api_host>/import/products \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "product": {
      "name": "primary-product",
      "destinations": ["<DESTINATION_ID>"]
    }
  }'

Create a Stream

A Stream maps one Dataset to one Destination through field-level mappings. Before authoring the mappings, fetch the Destination’s record_schema so you know which fields your mappings need to cover. See Streams and Advanced Table Mapping, or open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Create stream

curl -X POST https://api.prequel.co/import/streams \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "stream": {
      "name": "users-stream",
      "dataset_id": "<DATASET_ID>",
      "destination_id": "<DESTINATION_ID>",
      "mappings": [
        { "target_field": "id", "field_type": "field", "column": { "name": "id" } }
      ]
    }
  }'

Create stream

curl -X POST https://eu-api.prequel.co/import/streams \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "stream": {
      "name": "users-stream",
      "dataset_id": "<DATASET_ID>",
      "destination_id": "<DESTINATION_ID>",
      "mappings": [
        { "target_field": "id", "field_type": "field", "column": { "name": "id" } }
      ]
    }
  }'

Create stream

curl -X POST https://<your_prequel_api_host>/import/streams \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "stream": {
      "name": "users-stream",
      "dataset_id": "<DATASET_ID>",
      "destination_id": "<DESTINATION_ID>",
      "mappings": [
        { "target_field": "id", "field_type": "field", "column": { "name": "id" } }
      ]
    }
  }'

Test the transform

Apply the Stream’s mappings to specific extracted records and confirm the output covers every required field in the Destination’s record_schema with the correct type. Pass one or more record_id values from the Extract sample. Open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Test transform

curl -X POST https://api.prequel.co/import/streams/<STREAM_ID>/test-transform \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "record_ids": ["<RECORD_ID>"] }'

Test transform

curl -X POST https://eu-api.prequel.co/import/streams/<STREAM_ID>/test-transform \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "record_ids": ["<RECORD_ID>"] }'

Test transform

curl -X POST https://<your_prequel_api_host>/import/streams/<STREAM_ID>/test-transform \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "record_ids": ["<RECORD_ID>"] }'

Test the load (optional)

Deliver the same records to your endpoint with the X-Prequel-Is-Test: true header, without recording a Load. Open the API reference for the full request schema.

Test load

curl -X POST https://api.prequel.co/import/streams/<STREAM_ID>/test-load \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "record_ids": ["<RECORD_ID>"] }'

Trigger a Load

The Load applies the Stream’s mappings and delivers records to the Destination. Open the API reference for the full request schema.

US
EU
Dedicated or self-hosted

Initialize load

curl -X POST https://api.prequel.co/import/streams/<STREAM_ID>/load \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Initialize load

curl -X POST https://eu-api.prequel.co/import/streams/<STREAM_ID>/load \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Initialize load

curl -X POST https://<your_prequel_api_host>/import/streams/<STREAM_ID>/load \
  -H "X-API-Key: $PREQUEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

Verify the Load

Poll the Load until ended_at is set and confirm error is empty. If records_errored is non-zero, call load debug with has_error=true. Then confirm the records reached your endpoint. Open the API reference for the full response schema.

Get load

curl https://api.prequel.co/import/loads/<LOAD_ID> \
  -H "X-API-Key: $PREQUEL_API_KEY"

That’s it. Your Prequel Import pipeline is now configured to automatically extract data from the Source and load to the Destination.

To onboard each additional Provider, repeat Phase 2: Configure and validate a data source and Phase 3: Connect and deliver.

Next steps

Building Your Customer Experience

Wrap the API in an embedded setup and monitoring UX for your customers.

Webhooks and Monitoring

Get notified on transfer failures and track sync health.

Change Detection

Tune incremental sync behavior for dimension Datasets.

Advanced Table Mapping

Use expressions and complex mappings to reshape source data.

Getting started

Core concepts

Features

Logging, Monitoring, and Observability

Sources

Security & compliance

Developer SDKs

Quickstart guide

Select your onboarding experience

Prerequisites

Setup overview

Set up your pipeline

Phase 1: prepare your environment

Phase 2: configure and validate a data source

Phase 3: connect and deliver

Next steps

Building Your Customer Experience

Webhooks and Monitoring

Change Detection

Advanced Table Mapping

​Select your onboarding experience

​Prerequisites

​Setup overview

​Set up your pipeline

​Phase 1: prepare your environment

​Phase 2: configure and validate a data source

​Phase 3: connect and deliver

​Next steps

Building Your Customer Experience

Webhooks and Monitoring

Change Detection

Advanced Table Mapping

Select your onboarding experience

Prerequisites

Setup overview

Set up your pipeline

Phase 1: prepare your environment

Phase 2: configure and validate a data source

Phase 3: connect and deliver

Next steps