Imports
Imports deliver data to destination systems. An import receives pages of records from upstream flow steps, applies field mappings and transformations, and writes the results to the target application, database, or file destination — handling lookups, duplicate avoidance, and per-record error reporting along the way. Each import uses one adaptorType that determines its connection compatibility and configuration object.
Import schema
Returns a list of all imports configured in the account. If no imports exist in the account, a 204 response with no body will be returned.
Filter to imports matching this exact external identifier.
Comma-separated list of fields to project into each returned record.
Triggers summary projection: the response contains a minimal identity
set (_id, name, plus resource-specific fields) with the requested
fields added on top. Supports dot notation for nested fields.
Mutually exclusive with exclude.
_integrationId,disabled,lastModifiedComma-separated list of fields to strip from the default response.
Unlike include, does not trigger summary projection — returns the
full record with the named fields removed. Protected identity fields
(e.g. name) cannot be stripped. Mutually exclusive with include.
createdAt,lastModifiedSuccessfully retrieved list of imports
No imports exist in the account
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
GET /v1/imports HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Accept: */*
[
{
"_id": "5f8d43a1b9e5a80011a35f2c",
"name": "Shopify Customer Import",
"_connectionId": "60a2c4e6f321d800129a1a3c",
"adaptorType": "HTTPImport",
"http": {
"relativeURI": [
"/customers.json"
],
"method": [
"POST"
],
"requestMediaType": "json",
"successMediaType": "json",
"sendPostMappedData": true
},
"apiIdentifier": "if0626b560",
"createdAt": "2026-06-09T17:32:41.218Z",
"lastModified": "2026-06-09T17:32:41.296Z"
}
]Creates a new import configuration that can be used to send data to applications or external destinations.
Fields that can be sent when creating or updating an import. Set the adaptor-specific
configuration object matching adaptorType (e.g. netsuite_da for NetSuiteDistributedImport).
_connectionId is required except for the connection-less flavors (ToolImport,
AiAgentImport, GuardrailImport): a ToolImport binds connections through the
referenced tool's overrides, and AI agent / guardrail imports only use a connection
for BYOK.
Connection this import uses to reach the destination system. The connection's type must
be compatible with the import's adaptorType (e.g. an HTTPImport needs an http
connection). Server-required — POST without it fails with 422 "Expected field:
_connectionId to be present" — except for the connection-less flavors (ToolImport,
AiAgentImport, GuardrailImport), which the server creates without one.
60a2c4e6f321d800129a1a3cIntegration this import belongs to.
60a2c4e6f321d800129a1a3cConnector this import was created from, set when the import is part of an installed integration app.
60a2c4e6f321d800129a1a3cSelects the adaptor technology that executes this import, which determines the compatible
connection types and which adaptor-specific configuration object must also be supplied
(e.g. set salesforce when using SalesforceImport).
HTTPImportPossible values: External identifier for correlating the import with a record in another system.
shopify-customer-importDisplay name for the import, shown in the flow builder, job history, and error logs. Descriptive, unique names indicating the destination system and purpose make large accounts easier to manage.
Shopify Customer ImportFree-text summary of what the import writes and why. Shown in the UI and available to AI agents for context; has no effect on execution.
Custom configuration values stored without encryption and returned in API responses.
Sample input record used to preview and build the import's mappings.
When true, the import uses a distributed adaptor (such as NetSuiteDistributedImport)
that executes inside the target application rather than on Celigo's servers.
Maximum number of attempts made to deliver a record before it is marked as failed.
When true, records that already exist in the destination system are silently skipped
instead of being created or updated — used for create-only operations that must avoid
duplicates. Existing records are identified by the import's lookup configuration or by
a populated ignoreExtract field on the incoming record.
When true, records that do not already exist in the destination system are silently skipped instead of producing errors — used for update-only operations.
Handlebars template that generates a lock key for each record so records resolving to the same key are not submitted concurrently, preventing duplicate or conflicting writes to the same target record.
{{record.customerId}}Handlebars template that builds a link back to each record in the destination application's UI. The resolved URL is stored with error records in job history so users can jump straight to the record.
https://admin.shopify.com/customers/{{record.id}}Controls whether the resource treats child records within parent records as the primary data units.
Important: this is not for specifying where records are in an api response
If you need to tell an export where to find the array of records in the HTTP response
body (e.g. "the records are at data.items"), use http.response.resourcePath instead.
oneToMany serves a completely different purpose — it operates on records that have
already been extracted from the response.
What oneToMany actually does
When set to true, this field fundamentally changes how record data is processed:
- The system will "unwrap" nested child records from their parent containers
- Each child record becomes a separate output record for downstream processing
- The pathToMany field must be set to indicate where these child records are located
- Parent record fields can still be accessed via a special "parent" context
This is typically used on lookup exports (isLookup: true) or imports where the incoming records contain nested arrays that need to be fanned out.
Common scenarios for enabling this option:
- Processing order line items individually from an order export
- Handling invoice line items from an invoice export
- Processing individual transaction lines from journal entries
- Extracting address records from customer exports
This setting applies for the duration of the current flow step only and does not affect how data is stored or structured in other flow steps.
If false (default), the resource processes each top-level record as a single unit.
falseExample: trueSpecifies the JSON path to child records when oneToMany mode is enabled.
This field is only used when oneToMany is set to true. It defines the exact location of child records within the parent record structure using dot notation:
- Simple path: "items" for a direct child array field
- Nested path: "lines.lineItems" for a more deeply nested array
- Multi-level: "details.items.subitems" for deeply nested structures
The system uses this path to:
- Locate the array of child records within each parent record
- Extract each array element as a separate record for processing
- Make both the child record data and parent context available to downstream steps
Important considerations:
- The path must point to an array field
- For row-based data (i.e. where Celigo models this via an array or arrays of objects), this field is not required
- If the path is invalid or doesn't exist, the resource will report success but process zero records
- Maximum path depth: 10 levels
This field must contain a valid JSON path expression using dot notation.
itemsPath in the input record that holds the blob key identifying the file content to import. At send time the platform follows this path, retrieves the referenced file from integrator.io storage, and streams its bytes into the outgoing request.
attachment.blobKeyWhen true, this import transfers raw file content (blobs) to the destination rather than structured records.
Identifier for the connector assistant used to configure this import.
When true, the source file is deleted after it is successfully imported.
Metadata associated with the connector assistant configuration.
When true, the UI presents the full technical adaptor form for this import instead of the simplified assistant form.
Internal state stored by distributed adaptors (such as the NetSuite SuiteApp) for this import.
Handlebars template that overrides how each record's unique trace key is generated, used to track records through the flow and match errors to records. Trace keys are capped at 256 characters; a longer key is stored truncated from the middle, keeping the beginning and end of the value.
{{record.orderNumber}}EDI profile this import uses to generate outbound X12 EDI documents — it supplies the envelope qualifiers, delimiters, version, and validation rules. Set it when the import produces EDI output; omit it otherwise.
Legacy parser configuration slot. The server initializes this field to an empty array and current API writes never populate it; treat it as server bookkeeping rather than a setting to configure.
Sample response payload used to preview response mappings and test downstream steps without calling the destination system.
Metadata about the destination data model captured for this import. Rarely set.
Controls the shape of the input passed to the import's processing pipeline.
Import created successfully
Import object as returned by the API.
Connection this import uses to reach the destination system. The connection's type must
be compatible with the import's adaptorType (e.g. an HTTPImport needs an http
connection). Server-required — POST without it fails with 422 "Expected field:
_connectionId to be present" — except for the connection-less flavors (ToolImport,
AiAgentImport, GuardrailImport), which the server creates without one.
60a2c4e6f321d800129a1a3cReference to the specific integration instance that contains this resource.
This field is only populated for resources that are part of an integration app installation. It contains the unique identifier (_id) of the integration resource that was installed in the account.
The integration instance represents a specific installed instance of an integration app, with its own configuration, settings, and runtime environment.
This reference enables:
- Tracing the resource back to its parent integration instance
- Permission and access control based on integration ownership
- Lifecycle management (enabling/disabling, updating, or uninstalling)
5f9a7b2c3d4e5f6a7b8c9d0eReference to the integration app that defines this resource.
This field is only populated for resources that are part of an integration app. It contains the unique identifier (_id) of the integration app (connector) that defines the structure, behavior, and templates for this resource.
The integration app is the published template that can be installed multiple times across different accounts, with each installation creating a separate integration instance (referenced by _integrationId).
This reference enables:
- Identifying the source integration app for this resource
- Determining which template version is being used
- Linking to documentation, support, and marketplace information
5e8d43a1b9e5a80011a35f1bSelects the adaptor technology that executes this import, which determines the compatible
connection types and which adaptor-specific configuration object must also be supplied
(e.g. set salesforce when using SalesforceImport).
HTTPImportPossible values: External identifier for correlating the import with a record in another system.
shopify-customer-importDisplay name for the import, shown in the flow builder, job history, and error logs. Descriptive, unique names indicating the destination system and purpose make large accounts easier to manage.
Shopify Customer ImportFree-text summary of what the import writes and why. Shown in the UI and available to AI agents for context; has no effect on execution.
Custom configuration values stored without encryption and returned in API responses.
Sample input record used to preview and build the import's mappings.
When true, the import uses a distributed adaptor (such as NetSuiteDistributedImport)
that executes inside the target application rather than on Celigo's servers.
Maximum number of attempts made to deliver a record before it is marked as failed.
When true, records that already exist in the destination system are silently skipped
instead of being created or updated — used for create-only operations that must avoid
duplicates. Existing records are identified by the import's lookup configuration or by
a populated ignoreExtract field on the incoming record.
When true, records that do not already exist in the destination system are silently skipped instead of producing errors — used for update-only operations.
Handlebars template that generates a lock key for each record so records resolving to the same key are not submitted concurrently, preventing duplicate or conflicting writes to the same target record.
{{record.customerId}}Handlebars template that builds a link back to each record in the destination application's UI. The resolved URL is stored with error records in job history so users can jump straight to the record.
https://admin.shopify.com/customers/{{record.id}}Controls whether the resource treats child records within parent records as the primary data units.
Important: this is not for specifying where records are in an api response
If you need to tell an export where to find the array of records in the HTTP response
body (e.g. "the records are at data.items"), use http.response.resourcePath instead.
oneToMany serves a completely different purpose — it operates on records that have
already been extracted from the response.
What oneToMany actually does
When set to true, this field fundamentally changes how record data is processed:
- The system will "unwrap" nested child records from their parent containers
- Each child record becomes a separate output record for downstream processing
- The pathToMany field must be set to indicate where these child records are located
- Parent record fields can still be accessed via a special "parent" context
This is typically used on lookup exports (isLookup: true) or imports where the incoming records contain nested arrays that need to be fanned out.
Common scenarios for enabling this option:
- Processing order line items individually from an order export
- Handling invoice line items from an invoice export
- Processing individual transaction lines from journal entries
- Extracting address records from customer exports
This setting applies for the duration of the current flow step only and does not affect how data is stored or structured in other flow steps.
If false (default), the resource processes each top-level record as a single unit.
falseExample: trueSpecifies the JSON path to child records when oneToMany mode is enabled.
This field is only used when oneToMany is set to true. It defines the exact location of child records within the parent record structure using dot notation:
- Simple path: "items" for a direct child array field
- Nested path: "lines.lineItems" for a more deeply nested array
- Multi-level: "details.items.subitems" for deeply nested structures
The system uses this path to:
- Locate the array of child records within each parent record
- Extract each array element as a separate record for processing
- Make both the child record data and parent context available to downstream steps
Important considerations:
- The path must point to an array field
- For row-based data (i.e. where Celigo models this via an array or arrays of objects), this field is not required
- If the path is invalid or doesn't exist, the resource will report success but process zero records
- Maximum path depth: 10 levels
This field must contain a valid JSON path expression using dot notation.
itemsPath in the input record that holds the blob key identifying the file content to import. At send time the platform follows this path, retrieves the referenced file from integrator.io storage, and streams its bytes into the outgoing request.
attachment.blobKeyWhen true, this import transfers raw file content (blobs) to the destination rather than structured records.
Identifier for the connector assistant used to configure this import.
When true, the source file is deleted after it is successfully imported.
Metadata associated with the connector assistant configuration.
When true, the UI presents the full technical adaptor form for this import instead of the simplified assistant form.
Internal state stored by distributed adaptors (such as the NetSuite SuiteApp) for this import.
Handlebars template that overrides how each record's unique trace key is generated, used to track records through the flow and match errors to records. Trace keys are capped at 256 characters; a longer key is stored truncated from the middle, keeping the beginning and end of the value.
{{record.orderNumber}}EDI profile this import uses to generate outbound X12 EDI documents — it supplies the envelope qualifiers, delimiters, version, and validation rules. Set it when the import produces EDI output; omit it otherwise.
Legacy parser configuration slot. The server initializes this field to an empty array and current API writes never populate it; treat it as server bookkeeping rather than a setting to configure.
Sample response payload used to preview response mappings and test downstream steps without calling the destination system.
Metadata about the destination data model captured for this import. Rarely set.
Controls the shape of the input passed to the import's processing pipeline.
Unique identifier for the resource. Format is a 24-character hexadecimal string.
5f8d43a1b9e5a80011a35f2cTimestamp when the resource was created. Set automatically and cannot be modified.
2023-04-01T09:15:32ZTimestamp when the resource was last updated. Changes whenever any property is modified.
2023-04-15T14:30:15ZTimestamp when the resource was soft-deleted. When null or absent, the resource is active.
2023-05-20T11:45:32ZAPI identifier assigned to this import.
Reference to the source resource this import was created from.
Template this import was created from.
When true, this import is in draft state and has not been confirmed.
Timestamp when the draft version of this import expires.
Timestamp until which debug logging is enabled for this import.
Bad request. The server could not understand the request because of malformed syntax or invalid parameters.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Unprocessable entity. The request was well-formed but was unable to be followed due to semantic errors.
POST /v1/imports HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 217
{
"name": "Shopify Customer Import",
"_connectionId": "60a2c4e6f321d800129a1a3c",
"adaptorType": "HTTPImport",
"http": {
"relativeURI": [
"/customers.json"
],
"method": [
"POST"
],
"requestMediaType": "json",
"successMediaType": "json"
}
}{
"_id": "5f8d43a1b9e5a80011a35f2c",
"name": "Shopify Customer Import",
"_connectionId": "60a2c4e6f321d800129a1a3c",
"adaptorType": "HTTPImport",
"http": {
"relativeURI": [
"/customers.json"
],
"method": [
"POST"
],
"requestMediaType": "json",
"successMediaType": "json",
"sendPostMappedData": true
},
"apiIdentifier": "if0626b560",
"createdAt": "2026-06-09T17:32:41.218Z",
"lastModified": "2026-06-09T17:32:41.296Z"
}Returns the complete configuration of a specific import.
The unique identifier of the import
5f8d43a1b9e5a80011a35f2cImport retrieved successfully
Import object as returned by the API.
Connection this import uses to reach the destination system. The connection's type must
be compatible with the import's adaptorType (e.g. an HTTPImport needs an http
connection). Server-required — POST without it fails with 422 "Expected field:
_connectionId to be present" — except for the connection-less flavors (ToolImport,
AiAgentImport, GuardrailImport), which the server creates without one.
60a2c4e6f321d800129a1a3cReference to the specific integration instance that contains this resource.
This field is only populated for resources that are part of an integration app installation. It contains the unique identifier (_id) of the integration resource that was installed in the account.
The integration instance represents a specific installed instance of an integration app, with its own configuration, settings, and runtime environment.
This reference enables:
- Tracing the resource back to its parent integration instance
- Permission and access control based on integration ownership
- Lifecycle management (enabling/disabling, updating, or uninstalling)
5f9a7b2c3d4e5f6a7b8c9d0eReference to the integration app that defines this resource.
This field is only populated for resources that are part of an integration app. It contains the unique identifier (_id) of the integration app (connector) that defines the structure, behavior, and templates for this resource.
The integration app is the published template that can be installed multiple times across different accounts, with each installation creating a separate integration instance (referenced by _integrationId).
This reference enables:
- Identifying the source integration app for this resource
- Determining which template version is being used
- Linking to documentation, support, and marketplace information
5e8d43a1b9e5a80011a35f1bSelects the adaptor technology that executes this import, which determines the compatible
connection types and which adaptor-specific configuration object must also be supplied
(e.g. set salesforce when using SalesforceImport).
HTTPImportPossible values: External identifier for correlating the import with a record in another system.
shopify-customer-importDisplay name for the import, shown in the flow builder, job history, and error logs. Descriptive, unique names indicating the destination system and purpose make large accounts easier to manage.
Shopify Customer ImportFree-text summary of what the import writes and why. Shown in the UI and available to AI agents for context; has no effect on execution.
Custom configuration values stored without encryption and returned in API responses.
Sample input record used to preview and build the import's mappings.
When true, the import uses a distributed adaptor (such as NetSuiteDistributedImport)
that executes inside the target application rather than on Celigo's servers.
Maximum number of attempts made to deliver a record before it is marked as failed.
When true, records that already exist in the destination system are silently skipped
instead of being created or updated — used for create-only operations that must avoid
duplicates. Existing records are identified by the import's lookup configuration or by
a populated ignoreExtract field on the incoming record.
When true, records that do not already exist in the destination system are silently skipped instead of producing errors — used for update-only operations.
Handlebars template that generates a lock key for each record so records resolving to the same key are not submitted concurrently, preventing duplicate or conflicting writes to the same target record.
{{record.customerId}}Handlebars template that builds a link back to each record in the destination application's UI. The resolved URL is stored with error records in job history so users can jump straight to the record.
https://admin.shopify.com/customers/{{record.id}}Controls whether the resource treats child records within parent records as the primary data units.
Important: this is not for specifying where records are in an api response
If you need to tell an export where to find the array of records in the HTTP response
body (e.g. "the records are at data.items"), use http.response.resourcePath instead.
oneToMany serves a completely different purpose — it operates on records that have
already been extracted from the response.
What oneToMany actually does
When set to true, this field fundamentally changes how record data is processed:
- The system will "unwrap" nested child records from their parent containers
- Each child record becomes a separate output record for downstream processing
- The pathToMany field must be set to indicate where these child records are located
- Parent record fields can still be accessed via a special "parent" context
This is typically used on lookup exports (isLookup: true) or imports where the incoming records contain nested arrays that need to be fanned out.
Common scenarios for enabling this option:
- Processing order line items individually from an order export
- Handling invoice line items from an invoice export
- Processing individual transaction lines from journal entries
- Extracting address records from customer exports
This setting applies for the duration of the current flow step only and does not affect how data is stored or structured in other flow steps.
If false (default), the resource processes each top-level record as a single unit.
falseExample: trueSpecifies the JSON path to child records when oneToMany mode is enabled.
This field is only used when oneToMany is set to true. It defines the exact location of child records within the parent record structure using dot notation:
- Simple path: "items" for a direct child array field
- Nested path: "lines.lineItems" for a more deeply nested array
- Multi-level: "details.items.subitems" for deeply nested structures
The system uses this path to:
- Locate the array of child records within each parent record
- Extract each array element as a separate record for processing
- Make both the child record data and parent context available to downstream steps
Important considerations:
- The path must point to an array field
- For row-based data (i.e. where Celigo models this via an array or arrays of objects), this field is not required
- If the path is invalid or doesn't exist, the resource will report success but process zero records
- Maximum path depth: 10 levels
This field must contain a valid JSON path expression using dot notation.
itemsPath in the input record that holds the blob key identifying the file content to import. At send time the platform follows this path, retrieves the referenced file from integrator.io storage, and streams its bytes into the outgoing request.
attachment.blobKeyWhen true, this import transfers raw file content (blobs) to the destination rather than structured records.
Identifier for the connector assistant used to configure this import.
When true, the source file is deleted after it is successfully imported.
Metadata associated with the connector assistant configuration.
When true, the UI presents the full technical adaptor form for this import instead of the simplified assistant form.
Internal state stored by distributed adaptors (such as the NetSuite SuiteApp) for this import.
Handlebars template that overrides how each record's unique trace key is generated, used to track records through the flow and match errors to records. Trace keys are capped at 256 characters; a longer key is stored truncated from the middle, keeping the beginning and end of the value.
{{record.orderNumber}}EDI profile this import uses to generate outbound X12 EDI documents — it supplies the envelope qualifiers, delimiters, version, and validation rules. Set it when the import produces EDI output; omit it otherwise.
Legacy parser configuration slot. The server initializes this field to an empty array and current API writes never populate it; treat it as server bookkeeping rather than a setting to configure.
Sample response payload used to preview response mappings and test downstream steps without calling the destination system.
Metadata about the destination data model captured for this import. Rarely set.
Controls the shape of the input passed to the import's processing pipeline.
Unique identifier for the resource. Format is a 24-character hexadecimal string.
5f8d43a1b9e5a80011a35f2cTimestamp when the resource was created. Set automatically and cannot be modified.
2023-04-01T09:15:32ZTimestamp when the resource was last updated. Changes whenever any property is modified.
2023-04-15T14:30:15ZTimestamp when the resource was soft-deleted. When null or absent, the resource is active.
2023-05-20T11:45:32ZAPI identifier assigned to this import.
Reference to the source resource this import was created from.
Template this import was created from.
When true, this import is in draft state and has not been confirmed.
Timestamp when the draft version of this import expires.
Timestamp until which debug logging is enabled for this import.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
GET /v1/imports/{_id} HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Accept: */*
{
"_id": "5f8d43a1b9e5a80011a35f2c",
"name": "Shopify Customer Import",
"_connectionId": "60a2c4e6f321d800129a1a3c",
"adaptorType": "HTTPImport",
"http": {
"relativeURI": [
"/customers.json"
],
"method": [
"POST"
],
"requestMediaType": "json",
"successMediaType": "json",
"sendPostMappedData": true
},
"apiIdentifier": "if0626b560",
"createdAt": "2026-06-09T17:32:41.218Z",
"lastModified": "2026-06-09T17:32:41.296Z"
}Updates an existing import with the provided configuration. This is used for major updates to an import's structure or behavior.
The unique identifier of the import
5f8d43a1b9e5a80011a35f2cFields that can be sent when creating or updating an import. Set the adaptor-specific
configuration object matching adaptorType (e.g. netsuite_da for NetSuiteDistributedImport).
_connectionId is required except for the connection-less flavors (ToolImport,
AiAgentImport, GuardrailImport): a ToolImport binds connections through the
referenced tool's overrides, and AI agent / guardrail imports only use a connection
for BYOK.
Connection this import uses to reach the destination system. The connection's type must
be compatible with the import's adaptorType (e.g. an HTTPImport needs an http
connection). Server-required — POST without it fails with 422 "Expected field:
_connectionId to be present" — except for the connection-less flavors (ToolImport,
AiAgentImport, GuardrailImport), which the server creates without one.
60a2c4e6f321d800129a1a3cIntegration this import belongs to.
60a2c4e6f321d800129a1a3cConnector this import was created from, set when the import is part of an installed integration app.
60a2c4e6f321d800129a1a3cSelects the adaptor technology that executes this import, which determines the compatible
connection types and which adaptor-specific configuration object must also be supplied
(e.g. set salesforce when using SalesforceImport).
HTTPImportPossible values: External identifier for correlating the import with a record in another system.
shopify-customer-importDisplay name for the import, shown in the flow builder, job history, and error logs. Descriptive, unique names indicating the destination system and purpose make large accounts easier to manage.
Shopify Customer ImportFree-text summary of what the import writes and why. Shown in the UI and available to AI agents for context; has no effect on execution.
Custom configuration values stored without encryption and returned in API responses.
Sample input record used to preview and build the import's mappings.
When true, the import uses a distributed adaptor (such as NetSuiteDistributedImport)
that executes inside the target application rather than on Celigo's servers.
Maximum number of attempts made to deliver a record before it is marked as failed.
When true, records that already exist in the destination system are silently skipped
instead of being created or updated — used for create-only operations that must avoid
duplicates. Existing records are identified by the import's lookup configuration or by
a populated ignoreExtract field on the incoming record.
When true, records that do not already exist in the destination system are silently skipped instead of producing errors — used for update-only operations.
Handlebars template that generates a lock key for each record so records resolving to the same key are not submitted concurrently, preventing duplicate or conflicting writes to the same target record.
{{record.customerId}}Handlebars template that builds a link back to each record in the destination application's UI. The resolved URL is stored with error records in job history so users can jump straight to the record.
https://admin.shopify.com/customers/{{record.id}}Controls whether the resource treats child records within parent records as the primary data units.
Important: this is not for specifying where records are in an api response
If you need to tell an export where to find the array of records in the HTTP response
body (e.g. "the records are at data.items"), use http.response.resourcePath instead.
oneToMany serves a completely different purpose — it operates on records that have
already been extracted from the response.
What oneToMany actually does
When set to true, this field fundamentally changes how record data is processed:
- The system will "unwrap" nested child records from their parent containers
- Each child record becomes a separate output record for downstream processing
- The pathToMany field must be set to indicate where these child records are located
- Parent record fields can still be accessed via a special "parent" context
This is typically used on lookup exports (isLookup: true) or imports where the incoming records contain nested arrays that need to be fanned out.
Common scenarios for enabling this option:
- Processing order line items individually from an order export
- Handling invoice line items from an invoice export
- Processing individual transaction lines from journal entries
- Extracting address records from customer exports
This setting applies for the duration of the current flow step only and does not affect how data is stored or structured in other flow steps.
If false (default), the resource processes each top-level record as a single unit.
falseExample: trueSpecifies the JSON path to child records when oneToMany mode is enabled.
This field is only used when oneToMany is set to true. It defines the exact location of child records within the parent record structure using dot notation:
- Simple path: "items" for a direct child array field
- Nested path: "lines.lineItems" for a more deeply nested array
- Multi-level: "details.items.subitems" for deeply nested structures
The system uses this path to:
- Locate the array of child records within each parent record
- Extract each array element as a separate record for processing
- Make both the child record data and parent context available to downstream steps
Important considerations:
- The path must point to an array field
- For row-based data (i.e. where Celigo models this via an array or arrays of objects), this field is not required
- If the path is invalid or doesn't exist, the resource will report success but process zero records
- Maximum path depth: 10 levels
This field must contain a valid JSON path expression using dot notation.
itemsPath in the input record that holds the blob key identifying the file content to import. At send time the platform follows this path, retrieves the referenced file from integrator.io storage, and streams its bytes into the outgoing request.
attachment.blobKeyWhen true, this import transfers raw file content (blobs) to the destination rather than structured records.
Identifier for the connector assistant used to configure this import.
When true, the source file is deleted after it is successfully imported.
Metadata associated with the connector assistant configuration.
When true, the UI presents the full technical adaptor form for this import instead of the simplified assistant form.
Internal state stored by distributed adaptors (such as the NetSuite SuiteApp) for this import.
Handlebars template that overrides how each record's unique trace key is generated, used to track records through the flow and match errors to records. Trace keys are capped at 256 characters; a longer key is stored truncated from the middle, keeping the beginning and end of the value.
{{record.orderNumber}}EDI profile this import uses to generate outbound X12 EDI documents — it supplies the envelope qualifiers, delimiters, version, and validation rules. Set it when the import produces EDI output; omit it otherwise.
Legacy parser configuration slot. The server initializes this field to an empty array and current API writes never populate it; treat it as server bookkeeping rather than a setting to configure.
Sample response payload used to preview response mappings and test downstream steps without calling the destination system.
Metadata about the destination data model captured for this import. Rarely set.
Controls the shape of the input passed to the import's processing pipeline.
Import updated successfully
Import object as returned by the API.
Connection this import uses to reach the destination system. The connection's type must
be compatible with the import's adaptorType (e.g. an HTTPImport needs an http
connection). Server-required — POST without it fails with 422 "Expected field:
_connectionId to be present" — except for the connection-less flavors (ToolImport,
AiAgentImport, GuardrailImport), which the server creates without one.
60a2c4e6f321d800129a1a3cReference to the specific integration instance that contains this resource.
This field is only populated for resources that are part of an integration app installation. It contains the unique identifier (_id) of the integration resource that was installed in the account.
The integration instance represents a specific installed instance of an integration app, with its own configuration, settings, and runtime environment.
This reference enables:
- Tracing the resource back to its parent integration instance
- Permission and access control based on integration ownership
- Lifecycle management (enabling/disabling, updating, or uninstalling)
5f9a7b2c3d4e5f6a7b8c9d0eReference to the integration app that defines this resource.
This field is only populated for resources that are part of an integration app. It contains the unique identifier (_id) of the integration app (connector) that defines the structure, behavior, and templates for this resource.
The integration app is the published template that can be installed multiple times across different accounts, with each installation creating a separate integration instance (referenced by _integrationId).
This reference enables:
- Identifying the source integration app for this resource
- Determining which template version is being used
- Linking to documentation, support, and marketplace information
5e8d43a1b9e5a80011a35f1bSelects the adaptor technology that executes this import, which determines the compatible
connection types and which adaptor-specific configuration object must also be supplied
(e.g. set salesforce when using SalesforceImport).
HTTPImportPossible values: External identifier for correlating the import with a record in another system.
shopify-customer-importDisplay name for the import, shown in the flow builder, job history, and error logs. Descriptive, unique names indicating the destination system and purpose make large accounts easier to manage.
Shopify Customer ImportFree-text summary of what the import writes and why. Shown in the UI and available to AI agents for context; has no effect on execution.
Custom configuration values stored without encryption and returned in API responses.
Sample input record used to preview and build the import's mappings.
When true, the import uses a distributed adaptor (such as NetSuiteDistributedImport)
that executes inside the target application rather than on Celigo's servers.
Maximum number of attempts made to deliver a record before it is marked as failed.
When true, records that already exist in the destination system are silently skipped
instead of being created or updated — used for create-only operations that must avoid
duplicates. Existing records are identified by the import's lookup configuration or by
a populated ignoreExtract field on the incoming record.
When true, records that do not already exist in the destination system are silently skipped instead of producing errors — used for update-only operations.
Handlebars template that generates a lock key for each record so records resolving to the same key are not submitted concurrently, preventing duplicate or conflicting writes to the same target record.
{{record.customerId}}Handlebars template that builds a link back to each record in the destination application's UI. The resolved URL is stored with error records in job history so users can jump straight to the record.
https://admin.shopify.com/customers/{{record.id}}Controls whether the resource treats child records within parent records as the primary data units.
Important: this is not for specifying where records are in an api response
If you need to tell an export where to find the array of records in the HTTP response
body (e.g. "the records are at data.items"), use http.response.resourcePath instead.
oneToMany serves a completely different purpose — it operates on records that have
already been extracted from the response.
What oneToMany actually does
When set to true, this field fundamentally changes how record data is processed:
- The system will "unwrap" nested child records from their parent containers
- Each child record becomes a separate output record for downstream processing
- The pathToMany field must be set to indicate where these child records are located
- Parent record fields can still be accessed via a special "parent" context
This is typically used on lookup exports (isLookup: true) or imports where the incoming records contain nested arrays that need to be fanned out.
Common scenarios for enabling this option:
- Processing order line items individually from an order export
- Handling invoice line items from an invoice export
- Processing individual transaction lines from journal entries
- Extracting address records from customer exports
This setting applies for the duration of the current flow step only and does not affect how data is stored or structured in other flow steps.
If false (default), the resource processes each top-level record as a single unit.
falseExample: trueSpecifies the JSON path to child records when oneToMany mode is enabled.
This field is only used when oneToMany is set to true. It defines the exact location of child records within the parent record structure using dot notation:
- Simple path: "items" for a direct child array field
- Nested path: "lines.lineItems" for a more deeply nested array
- Multi-level: "details.items.subitems" for deeply nested structures
The system uses this path to:
- Locate the array of child records within each parent record
- Extract each array element as a separate record for processing
- Make both the child record data and parent context available to downstream steps
Important considerations:
- The path must point to an array field
- For row-based data (i.e. where Celigo models this via an array or arrays of objects), this field is not required
- If the path is invalid or doesn't exist, the resource will report success but process zero records
- Maximum path depth: 10 levels
This field must contain a valid JSON path expression using dot notation.
itemsPath in the input record that holds the blob key identifying the file content to import. At send time the platform follows this path, retrieves the referenced file from integrator.io storage, and streams its bytes into the outgoing request.
attachment.blobKeyWhen true, this import transfers raw file content (blobs) to the destination rather than structured records.
Identifier for the connector assistant used to configure this import.
When true, the source file is deleted after it is successfully imported.
Metadata associated with the connector assistant configuration.
When true, the UI presents the full technical adaptor form for this import instead of the simplified assistant form.
Internal state stored by distributed adaptors (such as the NetSuite SuiteApp) for this import.
Handlebars template that overrides how each record's unique trace key is generated, used to track records through the flow and match errors to records. Trace keys are capped at 256 characters; a longer key is stored truncated from the middle, keeping the beginning and end of the value.
{{record.orderNumber}}EDI profile this import uses to generate outbound X12 EDI documents — it supplies the envelope qualifiers, delimiters, version, and validation rules. Set it when the import produces EDI output; omit it otherwise.
Legacy parser configuration slot. The server initializes this field to an empty array and current API writes never populate it; treat it as server bookkeeping rather than a setting to configure.
Sample response payload used to preview response mappings and test downstream steps without calling the destination system.
Metadata about the destination data model captured for this import. Rarely set.
Controls the shape of the input passed to the import's processing pipeline.
Unique identifier for the resource. Format is a 24-character hexadecimal string.
5f8d43a1b9e5a80011a35f2cTimestamp when the resource was created. Set automatically and cannot be modified.
2023-04-01T09:15:32ZTimestamp when the resource was last updated. Changes whenever any property is modified.
2023-04-15T14:30:15ZTimestamp when the resource was soft-deleted. When null or absent, the resource is active.
2023-05-20T11:45:32ZAPI identifier assigned to this import.
Reference to the source resource this import was created from.
Template this import was created from.
When true, this import is in draft state and has not been confirmed.
Timestamp when the draft version of this import expires.
Timestamp until which debug logging is enabled for this import.
Bad request. The server could not understand the request because of malformed syntax or invalid parameters.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
PUT /v1/imports/{_id} HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 289
{
"name": "Shopify Customer Import",
"description": "Creates customers in Shopify from upstream ERP records.",
"_connectionId": "60a2c4e6f321d800129a1a3c",
"adaptorType": "HTTPImport",
"http": {
"relativeURI": [
"/customers.json"
],
"method": [
"POST"
],
"requestMediaType": "json",
"successMediaType": "json"
}
}{
"_id": "5f8d43a1b9e5a80011a35f2c",
"name": "Shopify Customer Import",
"description": "Creates customers in Shopify from upstream ERP records.",
"_connectionId": "60a2c4e6f321d800129a1a3c",
"adaptorType": "HTTPImport",
"http": {
"relativeURI": [
"/customers.json"
],
"method": [
"POST"
],
"requestMediaType": "json",
"successMediaType": "json",
"sendPostMappedData": true
},
"apiIdentifier": "if0626b560",
"createdAt": "2026-06-09T17:32:41.218Z",
"lastModified": "2026-06-09T18:11:02.633Z"
}Deletes an import. The import is soft-deleted and retained in the recycle bin for 30 days before permanent removal. If the import is currently in use by any flows, those flows may fail until reconfigured.
The unique identifier of the import
5f8d43a1b9e5a80011a35f2cImport deleted successfully
No content
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
The resource has dependents that must be deleted first. Each entry
in the errors array names one blocking resource.
DELETE /v1/imports/{_id} HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Accept: */*
No content
Partially updates an import using a JSON Patch document (RFC 6902). Only the replace operation is supported, and only on the following whitelisted path:
/debugUntil
Debug logging expiry (ISO-8601, max 1 hour from now)
All other paths are rejected with 422.
The unique identifier of the import
5f8d43a1b9e5a80011a35f2cA JSON Patch document (RFC 6902). Send an array of patch operations on whitelisted fields — all other paths are rejected with 422.
The operation to perform.
JSON Pointer (RFC 6901) to the field to patch. Only
whitelisted paths are accepted — unlisted paths return
422 with "<path> is not a whitelisted property".
The new value to set. Required for replace and add, omit for remove.
Import patched successfully
No content
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
Unprocessable entity. The request was well-formed but was unable to be followed due to semantic errors.
PATCH /v1/imports/{_id} HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 74
[
{
"op": "replace",
"path": "/debugUntil",
"value": "2026-05-02T16:00:00.000Z"
}
]No content
Creates a copy of an existing import. Supports optionally remapping referenced connections (via connectionMap).
The unique identifier of the import to clone
5f8d43a1b9e5a80011a35f2cRequest body for cloning an import.
Optional name for the cloned resource. If omitted, the server may generate a default clone name.
Clone - Import OrdersImport cloned successfully. Returns a manifest of the resource the clone created.
Response body for a clone operation. Some clone endpoints return the cloned resource, while others may return a list of related created resources.
Bad request. The server could not understand the request because of malformed syntax or invalid parameters.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
POST /v1/imports/{_id}/clone HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 114
{
"name": "Clone - Shopify Customer Import",
"connectionMap": {
"60a2c4e6f321d800129a1a3c": "60a2c4e6f321d800129a1a3c"
}
}[
{
"model": "Import",
"_id": "64a1234567890abcdef12345",
"name": "Clone - Shopify Customer Import"
}
]Returns a preview of the resources that would be created by cloning the specified import. The response includes the target import and any transitive dependencies (e.g. connections, scripts). No resources are created by this endpoint.
The unique identifier of the import to preview cloning
5f8d43a1b9e5a80011a35f2cClone preview retrieved successfully
Preview of the resources that would be created by a clone operation.
Each object in the objects array represents a resource that will be
cloned, including the target resource and all transitive dependencies
(connections, scripts, exports, imports, etc.).
Whether the clone requires a stack (connector-level) environment to proceed.
The stack id associated with the resource, or null if no stack is involved.
5f8d43a1b9e5a80011a35f2cUnauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
GET /v1/imports/{_id}/clone/preview HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Accept: */*
{
"objects": [
{
"model": "Import",
"doc": {
"name": "Shopify Customer Import",
"_connectionId": "60a2c4e6f321d800129a1a3c",
"adaptorType": "HTTPImport",
"http": {
"relativeURI": [
"/customers.json"
],
"method": [
"POST"
]
}
}
}
],
"stackRequired": false,
"_stackId": null
}Replaces the connection used by an import in a flow and cancels any related running jobs. This is useful when migrating flows between environments or updating to newer connection versions.
The unique identifier of the import
5f8d43a1b9e5a80011a35f2cThe id of the new connection to be used
60a2c4e6f321d800129a1a3cSuccessfully replaced connection on import
No content
Bad request. The server could not understand the request because of malformed syntax or invalid parameters.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
PUT /v1/imports/{_id}/replaceConnection HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 47
{
"_newConnectionId": "60a2c4e6f321d800129a1a3c"
}No content
Runs an existing import against the destination system with the supplied data records and returns per-record results synchronously.
The request body should contain a data array of records to import. Each record is processed through the import's mappings, transformations, and hooks before being sent to the destination.
The response is an array of per-record result objects, each containing a statusCode, the transformed _json payload, and any errors encountered during processing. This endpoint writes to the destination system — and so does POST /v1/imports/preview (verified to execute the composed request), so neither is a dry run against a production destination. A 200 response may still contain per-record failures in each element's errors array.
Import ID
5f8d43a1b9e5a80011a35f2cRecords to import
Import completed. Returns a per-record result array. Each element
contains the statusCode from the destination, the transformed
_json payload, and any errors encountered.
HTTP status code from the destination system
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Import not found
Unprocessable entity. The request was well-formed but was unable to be followed due to semantic errors.
POST /v1/imports/{_id}/invoke HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 58
{
"data": [
{
"name": "Acme Corp",
"email": "contact@acme.com"
}
]
}[
{
"statusCode": 422,
"_json": {},
"errors": [
{
"source": "application",
"code": "response_failure",
"message": "response failed using path: \"ok\". Value found: \"false\".",
"resolved": false,
"occurredAt": 1777645680144,
"stage": "apiCall",
"classification": "value"
}
]
}
]Runs an import doc through the flow engine's preview pipeline against supplied sample data and returns the per-stage output. The composed request IS executed against the live destination — previewing a create/update import against a production system writes real records (a saved mockResponse does NOT protect this surface; it substitutes only in flow test runs and flow-builder previews), so point previews at sandbox destinations when a live write is not acceptable. There is no request option that disables the send: flags such as preview, sendAndPreview, or send — top level, inside an options object, or on the import doc — are silently ignored and the request executes regardless. For a compose-only preview of the destination request, use POST /v1/pageProcessors/preview with {preview: true} on the target entry (requires a flow context). No Job record is created and no flow-level state is updated.
The integrator.io UI never calls this path — the import editor's "Preview" and "Send" buttons both go through POST /v1/pageProcessors/preview. This endpoint is the API-only, unscoped counterpart to POST /v1/integrations/{_integrationId}/flows/{_flowId}/imports/preview — prefer this variant when previewing a standalone import that is not yet associated with a flow.
Envelope containing the import document to preview plus the sample records to feed it.
Preview executed. Stage-level errors in the import config surface in
stages[].errors and the top-level errors[]; inspect those before
trusting data[]. When data:[] was supplied, the response is a
minimal {data:[null]} with no stages block.
Envelope returned by POST /v1/imports/preview (and the scoped
/v1/integrations/{_integrationId}/flows/{_flowId}/imports/preview
variant). Carries per-stage diagnostics alongside the sampled records
produced by running the supplied source data through the import's
mapping/transform/target pipeline. The target stage executes the
composed destination request — see the operation descriptions for the
write-safety warning.
No content — returned when the request body omits the data key
entirely (the engine has nothing to trace). Supply data:[{}] or
data:[...] to get a populated preview envelope.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Request body is malformed — most commonly the top-level import
object is missing — or the adaptor type is unsupported: RDBMS-family
imports are rejected with invalid_adaptor ("Import preview is not
supported for adaptor type: RDBMSImport"); database imports have no
request-preview surface anywhere (the SQL editor's Handlebars
evaluation is their only preview). Structural validation returns the
standard errors envelope.
POST /v1/imports/preview HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 217
{
"import": {
"name": "preview-agent",
"adaptorType": "AiAgentImport",
"aiAgent": {
"provider": "openai",
"openai": {
"model": "gpt-4.1-mini",
"instructions": "test",
"temperature": 0.5,
"topP": 0.5,
"maxOutputTokens": 5000
}
}
},
"data": [
{}
]
}{
"data": [
"Test response from the model."
],
"stages": [
{
"name": "request",
"data": [
{
"model": "gpt-4.1-mini",
"instructions": "test",
"temperature": 0.5,
"topP": 0.5,
"maxOutputTokens": 5000
}
],
"errors": null
},
{
"name": "raw",
"data": [
"Test response from the model."
],
"errors": null
},
{
"name": "parse",
"data": [
"Test response from the model."
],
"errors": null
}
]
}Preview NetSuite import field mappings against sample data
Resolves a NetSuite import's Mapper 1.0 field mappings against supplied sample records and returns the mapped NetSuite record — the body fields (nlobjFieldIds) and sublists (nlobjSublistIds) that would be sent — without writing anything to NetSuite. Handlebars expressions in the mapping are evaluated, so this is the way to confirm how a mapping resolves before running it live.
This is a stateless dry-run of the mapping engine: no Job is created and no NetSuite record is touched. It is the NetSuite-mapping counterpart to POST /v1/imports/preview, which previews the full import pipeline; use this operation when you specifically want the resolved NetSuite field values.
The NetSuite connection whose Distributed Adaptor configuration resolves the mapping.
5541489353bb53af29000009Envelope for previewing how a NetSuite import's Mapper 1.0 field mappings
resolve against sample source records. Carries the sample data plus the
NetSuite Distributed (netsuite_da) import configuration whose mapping
is applied.
Resource discriminator the mapping engine uses to route the request.
Always previewImportMappingFields for this operation.
Mapping resolved. The mapped NetSuite fields are under
data.returnedObjects.jsObjects.data[].data.nlobjFieldIds. Inspect
data.returnedObjects.mappingErrors before trusting the output — it
lists any fields that failed to resolve.
Result of resolving a NetSuite import's field mappings against the supplied
sample records. The mapped NetSuite fields appear under
data.returnedObjects.jsObjects.data[].data.nlobjFieldIds; mapping failures
surface in data.returnedObjects.mappingErrors. No record is written to
NetSuite.
When true, the mapping engine processed the request. Per-record mapping problems still surface in mappingErrors, so inspect that before trusting the mapped output.
A required input is missing — the _connectionId query parameter or the
importConfig body field.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
PUT /v1/netsuiteDA/previewImportMappingFields?_connectionId=5541489353bb53af29000009 HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 905
{
"data": [
{
"_id": "5d67ab3992080024596e0d8f",
"email": "nirav.pranami@celigo.com",
"verified": true,
"developer": true,
"name": "sai kaivalya",
"role": "Associate QA Engineer",
"company": "celigo",
"createdAt": "2019-08-29T10:38:50.396Z",
"lastModified": "2024-09-25T14:17:50.802Z"
}
],
"importConfig": {
"restletVersion": "suitebundle",
"operation": "add",
"recordType": "customrecord_user",
"internalIdLookup": {
"expression": "[\"custrecord_user_id\",\"is\",\"{{{_id}}}\"]"
},
"lookups": [],
"mapping": {
"fields": [
{
"extract": "_id",
"generate": "custrecord_user_id",
"discardIfEmpty": true
},
{
"extract": "email",
"generate": "custrecord_user_email",
"discardIfEmpty": true
},
{
"extract": "name",
"generate": "custrecord_user_name",
"discardIfEmpty": true
},
{
"extract": "{{#compare createdAt \"<\" \"2025-10-24T00:00:00.000Z\"}}true{{else}}false{{/compare}}",
"generate": "custrecord_user_onboarded"
}
],
"lists": []
}
},
"celigo_resource": "previewImportMappingFields"
}{
"success": true,
"data": {
"returnedObjects": {
"jsObjects": {
"data": [
{
"celigoIsElement": true,
"data": {
"nlobjFieldIds": {
"custrecord_user_id": "5d67ab3992080024596e0d8f",
"custrecord_user_email": "nirav.pranami@celigo.com",
"custrecord_user_name": "sai kaivalya",
"custrecord_user_onboarded": "true"
},
"nlobjSublistIds": {}
}
}
],
"originalSize": 1,
"processedCount": 0
},
"mappingErrors": [],
"celigo_classname": "Celigo.integrator.mapping.model.MapToNetSuiteResult"
}
}
}Runs the import pipeline — field mappings, transformations, and hooks — against the supplied sample data and returns the per-record results. Treat the preview as capable of executing the composed destination request: its unscoped sibling (POST /v1/imports/preview) is verified to write real records to live destinations and offers no option to disable the send, so do not preview create/update imports against production systems with data you do not want written. For a compose-only preview of the destination request, use POST /v1/pageProcessors/preview with {preview: true} on the target entry.
Integration ID
60a2c4e6f321d800129a1a3cFlow ID
64ff4b22612a134bd2f45538Request body for running sample data through an import's pipeline (mappings, transformations, hooks). The preview can execute the composed destination request — see the operation descriptions for the write-safety warning.
The import to preview. Required when previewing within a flow.
5f8d43a1b9e5a80011a35f2cSample source record(s) to run through the import's mappings and transformations. May be a single object or an array of objects depending on the adaptor.
Successfully previewed import data
Result of running a preview against the configured import. Shows the mapped/transformed records as composed for the destination.
Bad request. The server could not understand the request because of malformed syntax or invalid parameters.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
Not found. The requested resource does not exist or is not visible to the caller.
Unprocessable entity. The request was well-formed but was unable to be followed due to semantic errors.
POST /v1/integrations/{_integrationId}/flows/{_flowId}/imports/preview HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Content-Type: application/json
Accept: */*
Content-Length: 101
{
"_importId": "5f8d43a1b9e5a80011a35f2c",
"sampleData": {
"name": "Acme Corp",
"email": "contact@acme.com"
}
}{
"data": [
{
"name": "Acme Corp",
"email": "contact@acme.com"
}
],
"errors": []
}Returns the set of resources that depend on the specified resource. The response is an object whose keys are dependent-resource types (e.g. flows, imports) and whose values are arrays of dependency entries. Returns {} when no dependents exist, including for well-formatted but nonexistent IDs.
Resource ID.
5f8d43a1b9e5a80011a35f2cDependency map. Keys are resource-type strings; values are arrays
of dependency entries. Returns {} when no dependents exist.
Map of dependent-resource types to arrays of dependency entries.
Keys are plural resource type strings (e.g. flows, imports,
connections). An empty object {} means no dependents.
Unauthorized. The request lacks a valid bearer token, or the provided token failed to authenticate.
Note: the 401 response is produced by the auth middleware before the
request reaches the endpoint handler, so it does not follow the
standard {errors: [...]} envelope. Instead the body is a bare
{message: string} object with no code, no errors array. Callers
handling 401s should key off the HTTP status and the message string,
not try to destructure an errors[].
GET /v1/imports/{_id}/dependencies HTTP/1.1
Host: api.integrator.io
Authorization: Bearer YOUR_SECRET_TOKEN
Accept: */*
{}Last updated
Was this helpful?