Terminology and acronyms

Connections are used to store credentials, along with other access information for an application or system. integrator.io supports hundreds of pre-built connectors that you can configure for a system, as well as generic connection types like HTTP that allow you to configure your own request headers and other parameters. Some of the mostly used connection types are NetSuite, HTTP, SFTP/FTP, Amazon MWS, and AS2.

integrator.io has two classes of data:

• In-process data: files, records, and any other data that passes through an integration flow. 
• Integration settings data: customer credentials to source or destination applications, field mappings, transformations, lookups, connectors, imports, exports, and all customer-specific settings related to the integrator.io environment. This also includes information about the customer, and may include personally identifiable information (PII) depending on if system-specific email addresses were used.

Electronic Data Interchange (EDI) is a standard format for the digital exchange of business information. integrator.io supports converting between ISA EDI or fixed-width files and JSON files. 

Each application or technology service that you create a connection to in integrator.io. Unlimited connections to each application are allowed and only count as one endpoint.
Note: Beginning with the February 2022 integrator.io release, connections to the integrator․io API are no longer counted as part of the endpoint entitlement calculation. Previously if your subscription was consuming all available endpoints, you could be prevented from certain operations that required special use of the integrator.io endpoint (for example, cloning some templates and integration apps, and accessing flow errors via integrator.io error APIs). Now that it is no longer counted, these issues will not occur. 

Enterprise service bus.

Extract Transform Load (ETL) is the process of extracting, transforming, and loading data in a database. It is also often used to retrieve data from external data storage or transmission sources. Legacy ETL technologies were designed to move large batches of structure data (rows and columns). While this strategy is optimal for initial migrations and periodic data loading requirements, some integrations require both real time and batch transfers. Modern cloud integration platforms go beyond data loading and point-to-point use cases with event-based orchestration and big data integration bulk loading and data transformation for analytics. An on-premise enterprise service bus (ESB) or single-tenant hosted versions of legacy on-prem software typically communicate only via XML and SOAP. Modern cloud integration technologies can work with these formats and protocols and are designed to take advantage of JSON and REST. Celigo supports Extract (Export flow), Transform (Field mapping transformation UI) and Load (Import Flow and Data Loader).

Exports extract data from an application or system. Exports can run standalone or in the context of a flow:

• Standalone exports are useful for integrations where user interaction (like clicking a button) invokes an external application’s API in real time and returns the results immediately. Standalone exports are especially useful for applications that integrate with more than one application when the development environment is inconveniently designed and writing native API client code would be counterproductive. Celigo uses standalone exports extensively for spreadsheet and email synchronization.
• Exports running in the context of a flow execute asynchronously. The data is broken into one or more pages, and integrator.io uses those pages to pass data into one or more imports.

A flow is a stream of data between two or more systems or applications. A flow exports the data from one or more systems, processes the data according to your settings, and imports the processed data into another system. 

The integrator.io REST API supports the following custom HTTP headers:

• Integrator-Relative-URI
• Integrator-Record-Type
• Integrator-Passthrough

Hooks are custom code that can run at different stages during the execution of a flow to modify the behavior of export and import processes. Hooks can be run during the export or import stages, including preSavePage, postResponse, preMap, postMap, postSubmit, and postAggregate.

If you are using NetSuite exports, you can also execute these SuiteScript hooks during your data flow. SuiteScript hooks are run entirely in NetSuite.

Imports regulate the flow of data into a destination application by adding, updating, uploading, or deleting files or records, according to the system’s configuration. Imports can run standalone or in the context of a flow: 

• Standalone imports are useful for integrations where user actions (like clicking a button) need to invoke an API in real time and return the results immediately. Standalone imports are especially useful for applications that integrate with multiple applications or applications with inconveniently designed development environments, where writing native API client code would be counterproductive. Celigo uses standalone imports for spreadsheet and email synchronization.
• Imports running in the context of a flow execute synchronously, but the results return back to the flow for statistical reporting in a job record.

An integration contains one or more flows set up to achieve your needs for manipulating and moving data between systems. An integration can refer to a single flow or a set of flows grouped together in a folder. The container that organizes these flows is an integration; and, it is represented by a rectangular tile in the grid view or a specific row in the list view of the Home page. You can group flows into integrations however you like. You can click the integration in either the grid or list view to manage and monitor the flows within the integration.

Integration apps represent fully functional pre-built integrations that you can install into your integrator.io account from the integrator.io Marketplace. They include an installer, an uninstaller, and a settings interface. Developers can push updates at any time for any connector to their entire install base. Integration apps are mostly made up of code that uses the integrator.io API to interact with a user’s account. All components created in a customer’s account are tagged with the integration app’s _id (via the _connectorId field). An integration app can modify only those components tagged with its own _id. The schema primarily serves the purpose of listing an integration app in the integrator.io marketplace with a description, imageURL, websiteURL, and so forth.

Integration views indicate how integrations are displayed. integrator.io provides two integration views, namely Tile view and List view. The tile view (default) displays integrations as tiles; whereas, the list view displays integrations in a list. You can switch from one integration view to another by clicking the view icons in the upper-right corner of the Home page.

JavaScript Object Notation (JSON) is a standard lightweight data-interchange format. It is easy for humans to read and write, as well as for machines to parse and generate. JSON is a text format that is completely language independent, making it an ideal data-interchange language.

Lookups allow you to find deeper levels of information for a record and transfer that information later in the flow.

For example, if you export 10 Shopify customers to NetSuite, for each of those records you can look up transaction data for the customer (based on a saved search) and add the new data to the original export data by means of response mapping. 

If you are using integrator.io to build NetSuite-based integrations, we highly recommend you install the Celigo integrator.io bundle, a SuiteApp installed directly in your NetSuite account. Once installed, it enables a powerful export engine that can export NetSuite data in real time, intercepting events in NetSuite as they happen, and also run batch-based exports that utilize NetSuite SuiteScript APIs for more advanced and efficient search and custom logic capabilities.

If installing the bundle in your NetSuite account is not an option, you can still create NetSuite exports that use the NetSuite web services API. The capabilities are slightly more limited and the performance can also be slower depending on the complexity of your exports, especially related to the number of dynamic searches each record will require before export. Using the web services API enables you to get started immediately without involving a NetSuite admin to install anything right away. 

If you are using integrator.io to build NetSuite-based integrations, we highly recommend you install the Celigo integrator.io bundle, a SuiteApp installed directly in your NetSuite account. Once installed, it enables a rich import engine that can be used to map and load NetSuite data in very creative (and efficient) ways.

Differences in imports when you install the bundle:

1. field ids are all lowercase
2. expressions are not yet supported
3. customFieldMetadata is not required
4. hooks in the distributed adaptor are implemented in SuiteScript (vs. node.js without the bundle)

If installing the bundle in your NetSuite account is not an option, you can still create NetSuite imports that use the NetSuite web services API. The capabilities are slightly more limited and the performance can also be slower depending on the complexity of your imports, especially related to the number of dynamic internal id lookups each record in NetSuite will require before import. Using the web services API enables you to get started immediately without involving a NetSuite admin to install anything right away.

You may want to take the ID of the submission response and use this ID to reference another record and call other data flows from one flow. For example, you could check if the customer exists before inserting an order. If it doesn’t exist, insert the customer first and then insert the order.

The integrator.io API is rate-limited using a leaky-bucket algorithm with a bucket size of 1,000 and a fill rate of 300 tokens every second, allowing up to approximately 1,080,000 requests per hour.

A webhook is an HTTP callback: an HTTP POST that occurs when something happens; a simple event-notification via HTTP POST. integrator.io is capable of receiving events from any application that supports webhook adaptors.

integrator.io also supports the ability to integrate with any JSON-based webhook. An export record is used to register a listener that can then be posted to. The following webhooks are built into integrator.io:

• activecampaign
• aha
• box
• dropbox
• errorception
• github
• helpscout
• intercom
• jira

• mailchimp
• pagerduty
• postmark
• segment
• shopify
• slack
• stripe
• travis

In addition, we support custom webhooks that you can configure as an export.

A wrapper is a mechanism for any developer to build your own API and plug imports or exports to the integrator.io platform. This allows you to do custom transformations and connect to systems that do not have direct adapters. This is also Celigo’s answer to on-premise application integrations.