---
title: "Run HTTP connectors in apps"
slug: "run-http-connectors-in-apps"
updated: 2023-03-23T16:39:18Z
published: 2023-03-23T16:39:18Z
canonical: "support.tulip.co/run-http-connectors-in-apps"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://support.tulip.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Run HTTP connectors in apps

*Learn how to use HTTP Connectors in applications.*

## Overview

So you’ve configured a connector, set up a Connector Function, and are getting data returned in your test results–great! Now what?

Now, you can run your connectors in apps and use Trigger logic, Variables, and interactive tables to control and utilize your test results.

## Set Up

In order to use HTTP connectors in applications, you’ll need to set up a connector and create a connector function so that you have data coming through. If you haven’t done so already, check out the following articles for help on how to do so:

- [Connectors and Integrations](/r230/docs/connectors-and-integrations)
- [How to Configure a Connector](/r230/docs/how-to-configure-a-connector)
- [How to Create and Configure an HTTP Connector Function](/r230/docs/how-to-create-and-configure-an-http-connector-function)

Before you begin, map out what you want to do in your app with your connector data. This will be based on the **Call Type** you set up in the connector function. Do you want to display information? Or delete data? Or write information to your server? Knowing what action you need to do helps you to understand what you need to build in your app to accomplish your goals.

## Using Connectors in an App

### Trigger Logic

In order for a connector to make an API Call to a server, we need to set up some logic within an application to make this happen. Connector Functions can be run anywhere you place a Trigger, including on buttons, when a device like a barcode fires, on timers, or on Step Level Triggers or App Level Triggers.

In our example, our connector function returns information about a knowledge base article based on an article ID entered into a text input field. This input field in the application maps to the Input in our connector function, and will set the value of the input for the connector. For a simple connector function like our example, our application only needs two elements: an input field for collecting an article ID, and a button for triggering the connector function. The app below has a text Input Widget to specify the article ID and button that will run the connector using the value of the text Widget as the connector function input.

![HTTP in App1.png](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App1.png)

If we want to run the connector function when a button is pressed, the following example shows how the logic would flow.

![HTTP in App2.png](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App2.png)

Let’s break this logic down.

When the button is pressed, if the variable is not blank, then it will run the connector’s (Doc360 Connector) function (Get Article Info by ID) based on the variable input (article id) and save the result into a new Variable (articles).

### Variables and Interactive Tables

Displaying the connector function results in an interactive table is quick and simple to do, just be sure to remember the Outputs you set up in the function.

Choose **Variable** as the datasource and you’ll find the object list you made as outputs in the connector function.

![HTTP in App3.png](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App3.png)

After selecting the variable, choose the fields you want to display in the table, i.e. the outputs within the Object list.

![HTTP in App4.png](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App4.png)

In Developer Mode, the interactive table populates the results of the connector function when the call is made. The outputs instantly save as values to their respective variables.

![HTTP in App1.gif](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App1.gif)

Additionally, you can use variables to populate the information from connectors. This is useful if you want to expand your view on a piece of data without seeing all the information listed in the interactive table.

![HTTP in App5.png](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App5.png)

To do this, replicate the trigger above. The data source variable is the same as the linked variable to the interactive table. Create a new variable for the data to be stored in.

Next, configure a variable so that the datasource is the variable we just created. This ensures that when a row in the interactive table is selected, the data of that field stores in the variables of the widget.

![HTTP in App6.png](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App6.png)

The result operates as the following:

![HTTP in App2.gif](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/HTTP%20in%20App2.gif)

Now that you’ve seen how you can use your HTTP connectors in applications, you can replicate these steps to use in your own apps to work with your processes.

## Further Reading

- [An Overview of HTTP Connectors](/r230/docs/an-overview-of-http-connectors)
- [How to Format HTTP Connector Outputs](/r230/docs/how-to-format-http-connector-outputs)

---

Did you find what you were looking for?

You can also head to [community.tulip.co](https://community.tulip.co/?utm_source=intercom&amp;utm_medium=article-link&amp;utm_campaign=all) to post your question or see if others have faced a similar question!

**Connectors**

**Connectors** enable real-time connectivity between your Tulip solution and a transactional system (e.g. an ERP). The output of a Connector Function can be used in Tulip Apps, Automations, and Functions.

- **HTTP Connectors** utilize HTTP API endpoints.
- **SQL Connectors** can enable connectivity with certain SQL databases.
- **MQTT Connectors** can connect to MQTT brokers for machine monitoring.

![](https://cdn.document360.io/7c6ff534-cad3-4fc8-9583-912c4016362f/Images/Documentation/connector.gif)

**Connector Function**

**Connector Functions** are individual operations to interact with an HTTP or SQL Datasources. Connector Functions can have inputs and outputs, and can be called from: Triggers, Functions, Automations, and AI Agents.

Once pulled, data can be used throughout your applications.

**Trigger**

**Triggers** are groups of logic that are tied to an app event, such as step open, timer, widget interaction, etc. App builders can add triggers to **widgets**, **machines**, **devices**, **apps**, and **steps**.

**Triggers** can contain **actions**, **transitions**, and **conditions**.

**Variables**

**Variables**are a location to store app information. Variables have a specific type that must match the contents they can store.

Variables are only accessible within a single application and are cleared when the app is restarted or completed.

**API Call**

An **API call** is a message sent to a server asking an API to provide a service or information.

**Step-Level Trigger**

A**step-level trigger** is a trigger configured with each app step. Step-level triggers can be triggered based on 4 actions:

1. Step Opened
2. Every X seconds (Timer)
3. Machine/Device outputs data
4. Step Exited

**App-Level Triggers**

**App-level Triggers**are triggers that are configured with each app. App-level triggers can be triggered based on 3 actions:

1. App Started
2. App Cancelled
3. App Completed

**Input**

An **input** is transmission of data from a data set to a program.

**Input Widget**

**Input widgets**are a set of **Widgets**specifically designed for users to enter information. Input widgets must be associated with a location where the user input is stored.

**Widget**

**Widgets**are the elements that make up a specific **App Step.**Widgets can display information to users, collect user input, or trigger app logic.

*Common widgets include: Interactive Tables, Number inputs, Machine attribute widgets, and more.*

**Variable**

**Variables**are a location to store app information. Variables have a specific type that must match the contents they can store.

Variables are only accessible within a single application and are cleared when the app is restarted or completed.

**Output**

An **output** is the transmission of data from a program to a data set.

**Object**

**Objects**are a Tulip Datatype. Objects represent an arbitrary grouping of attributes. Leveraging objects can simplify the process of working with complex data architectures. Often **Connector** **Functions** will return **Arrays** of **Objects**

*ex. My car object has 5 attributes, Color, Make, Model, # of wheels, # of seats.*

**Developer Mode**

**Developer Mode**is a dedicated interface to test your applications. Dev mode doesn't write to **Tables**or create **Completions**so production data isn't impacted.
