---
title: Routing Data to Cloud
description: Learn how to connect Blues Notecard applications to third-party cloud services using Notehub Routes and Cellular, Satellite, LoRa, or WiFi connectivity.
source_url: https://dev.blues.io/guides-and-tutorials/routing-data-to-cloud/blynk/
canonical_url: https://dev.blues.io/guides-and-tutorials/routing-data-to-cloud/blynk/
markdown_url: https://dev.blues.io/guides-and-tutorials/routing-data-to-cloud/blynk.md
---

# Routing Data to Cloud: Blynk

#### Watch a video of this tutorial

[Video: quickstart-step-4.1280w.20260521.mp4](https://dev.blues.io/_media/quickstart-step-4.1280w.20260521.mp4)

In previous tutorials you've learned about the Blues Notecard, and used it to collect data and send it to Notehub, the Blues cloud service.

One powerful feature of Notehub is routes, which allow you to forward your data from Notehub to a public cloud like AWS, Azure, or Google Cloud, to a data cloud like Snowflake, to dashboarding services like Datacake or Ubidots, or to a custom HTTP or MQTT-based endpoint. The tutorial below guides you through sending data to several popular services, and teaches you how to build visualizations using that data.

*Don't see a cloud or backend that you need? Notehub is able to route data to virtually any provider. If you're having trouble setting up a route, [reach out in our forum](https://discuss.blues.com/) and we will help you out.*

## Introduction

*This tutorial should take approximately 30-40 minutes to complete.*

In this tutorial, you'll learn how to connect your Notecard-powered app to **Blynk**, and learn how to start creating simple visualizations with sensor data.

This tutorial assumes you've already completed the initial [Sensor Tutorial](https://dev.blues.io/guides-and-tutorials/collecting-sensor-data.md) to capture sensor data, saved it in a [Notefile](https://dev.blues.io/api-reference/glossary.md#notefile) called `sensors.qo`, and sent that data through the Notecard to Notehub (or that you've already created your own app with sensor data and are ready to connect your app to external services).

## Create a Route

A Route is an external API, or server location, where Notes can be forwarded upon receipt.

Routes are defined in Notehub for a [Project](https://dev.blues.io/api-reference/glossary.md#project) and can target Notes from one or more [Fleets](https://dev.blues.io/api-reference/glossary.md#fleet) or all [Devices](https://dev.blues.io/api-reference/glossary.md#device). A Project can have multiple routes defined and active at any one time.

Before you create a Route, ensure the data you want to route is available in Notehub by navigating to the **Events** view:

![events view in notehub](https://dev.blues.io/images/guides/route-tutorial/events-view.png?v=e1b03b17)

We'll start with a simple route that will pass Notecard events through to [webhook.site](https://webhook.site), where you can view the full payload sent by Notehub. Using this service is a useful way to debug routes, add a simple health-check endpoint to your app, and familiarize yourself with Notehub's Routing capabilities.

1. Navigate to [webhook.site](https://webhook.site). When the page loads, you'll be presented with a unique URL that you can use as a Route destination. Copy that URL for the next step.

   ![webhook.site service](https://dev.blues.io/images/guides/route-tutorial/webhook-site-url.png?v=5ed567fe)

2. Navigate to the [Notehub.io](https://notehub.io) project for which you want to create a route and click on the Routes menu item in the left nav.

3. Click **Create Route**.

   ![create a route button in notehub](https://dev.blues.io/images/guides/route-tutorial/add-route.png?v=4724c860)

4. Select the **General HTTP/HTTPS Request/Response** route type.

   ![general https request route](https://dev.blues.io/images/guides/route-tutorial/general-route.png?v=b3b8e6a5)

5. Give the route a name (for example, "Health").

   ![name notehub route](https://dev.blues.io/images/guides/route-tutorial/route-name.png?v=9aa60fa8)

6. For the Route **URL**, use the unique URL you obtained from webhook.site.

   ![url for notehub route](https://dev.blues.io/images/guides/route-tutorial/route-url.png?v=449917f5)

7. In the **Filters** section, choose **Selected Notefiles** and check the box(es) next to the Notefile(s) you want to route. For example, we used `sensors.qo` for the sensor tutorial.

   ![choose the notefile to sync](https://dev.blues.io/images/guides/route-tutorial/sensors-qo.png?v=b347af44)

8. Make sure the **Enabled** switch at the top remains selected, and click **Create Route**.

9. Only Notes received *after* the Route is created are routed automatically. If new Notes have been received since you created the Route, proceed to the next step.

   Alternatively, you can **manually route** existing Notes by (1) checking the box next to an event, (2) clicking the **Route** button, and (3) choosing the Route you would like to use:

   ![manually route notes](https://dev.blues.io/images/guides/route-tutorial/manual-route.png?v=904af97c)

10. Return to webhook.site. This page will update automatically with data sent from Notehub. The data from your sensor is contained within the `body` attribute. Notice that Notehub provides you with a lot of information, by default. In the next section, we'll look at using transformations to customize what Notehub sends in a Route.

    ![notehub data in webhook.site](https://dev.blues.io/images/guides/route-tutorial/webhook-site-data.png?v=83ed5ec7)

## Use JSONata to Transform JSON

Before moving on to routing data to an external service, let's briefly explore using JSONata expressions to transform the data Notehub routes.

As mentioned above, Notehub provides a lot of information in each Route request. You may want to trim down what you send to the external service, or you might need to transform the payload to adhere to a format expected by that service. Either way, Notehub supports shaping the data sent to a Route using JSONata.

> **Note:**
>
> To learn more about JSONata later, have a look at the [Blues JSONata Guide](https://dev.blues.io/guides-and-tutorials/notecard-guides/using-jsonata-to-transform-json.md).

### Transform Your Data

Let's try a simple query to the webhook.site Route created in the last section.

1. Navigate to the **Routes** page in Notehub and click on the Route you wish to edit.

   ![view a route](https://dev.blues.io/images/guides/route-tutorial/routes-screen.png?v=0a7ebd91)

2. In the **Transform Data** drop-down, select **JSONata Expression**.

   ![jsonata expression](https://dev.blues.io/images/guides/route-tutorial/jsonata-expression.png?v=98cabc60)

3. In the JSONata Expression text area, add the following query to select the `temp` and `humidity` from the `body`, create a `location` field that concatenates the `tower_location` and `tower_country` fields, and create a `time` field.

   ```json
   {
      "temp": body.temp,
      "humidity": body.humidity,
      "location": tower_location & ', ' & tower_country,
      "time": when
   }
   ```

4. Click **Apply changes**. Then, navigate back to webhook.site. As requests come in, you'll see your custom, JSONata-transformed payload in the Raw Content section.

   ![transformed data routed to webhook.site](https://dev.blues.io/images/guides/route-tutorial/webhook-site-jsonata.png?v=e69aa638)

   > **Note:**
   >
   > The `tower_location` and `tower_country` fields are only populated for events sent over cellular. For Starnote/satellite, LoRa or WiFi devices, those fields will be empty. If you want a single expression that works across connectivity types, use the `best_location` and `best_country` fields instead — Notehub appends those to every event, choosing the most accurate source available (GPS/GNSS, triangulation, or cell tower). See [Data Notehub Appends to Events](https://dev.blues.io/notehub/notehub-walkthrough.md#data-notehub-appends-to-events) to learn more.

JSONata is simple, powerful, and flexible, and will come in handy as you create Routes for your external services. To explore JSONata further, [visit our Blues JSONata Guide](https://dev.blues.io/guides-and-tutorials/notecard-guides/using-jsonata-to-transform-json.md).

## Route to an External Service

Now that you've created your first Route and learned how to use JSONata to shape the data sent by a Route, you can connect Notehub to an external service.

In this section of the tutorial, you'll connect your app to [Blynk](https://blynk.io/), a low-code IoT software platform for businesses and developers.

### Create a Blynk Account

If you haven't already, [create a Blynk account](https://blynk.cloud/dashboard/register). A free Blynk account allows you to use two devices and store one week of historical data.

![Create a Blynk account](https://dev.blues.io/images/guides/route-tutorial/blynk/blynk-account.png?v=dad577a0)

With your account created, you'll next be taken to [Blynk.Console](https://docs.blynk.io/en#blynk.console) where you can manage your Blynk devices, data, users, and settings.

### Enabling the Blues Integration

Enabling the Blues integration in Blynk allows you to import your devices from Notehub, and to establish a data flow that will later allow you to build dashboards. To enable the integration you'll first need to create a Blynk template and datastream.

1. In your Blynk.Console, click **Developer Zone**, then click **My Templates**, and then finally click the **New Template** button. ![Create a Blynk template](https://dev.blues.io/images/guides/route-tutorial/blynk/new-template.png?v=21b49732)

2. Give your template a name, select **Other** for **Hardware**, set your **Connection Type** to **GSM**, optionally add a description, and then click **Done**. ![Create a Blynk template with fields](https://dev.blues.io/images/guides/route-tutorial/blynk/new-template-2.png?v=d9647e07)

3. Next, you'll need to tell Blynk about the type of data coming in. To do so, click **Set up datastreams** (or go to the Datastreams section of Blynk.Console), and then click **New Datastream**. ![A new datastream in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/new-datastream.png?v=c1e05540)

4. Use the **Virtual Pin** option to create two datastreams with the following set of values.

   - Temperature

     - Name: `temp`
     - Pin: (leave the default)
     - Units: Degrees
     - Min: -100
     - Max: 100

   - Humidity

     - Name: `humidity`
     - Pin: (leave the default)
     - Units: Percentage
     - Min: 0
     - Max: 100

5. When you're done, confirm your datastreams look like what's shown in the screenshot below, and then click **Save**. ![Datastreams in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/datastreams.png?v=a05d0d86)

### Authenticating With OAuth

Your template and datastreams are now both in place. As one final step to enable the integration, you'll next need to create an OAuth Client on your Notehub project and register it with Blynk. (Blynk uses this access to automate many of the steps of discovering and working with your devices.)

1. In your Blynk.Console, click **Developer Zone**, then **Integrations**, and then the **Blues** box. ![The Blues integration in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/blues-integration.png?v=aed25646)

2. The next dialog will ask for a **Client ID** and **Client Secret**. To get them, return to your Notehub project, go to the **Settings** screen, scroll down, and then click the **Create OAuth Client** button. ![creating an OAuth client for a Notehub project](https://dev.blues.io/images/notehub/api-oauth.png?v=39b3b197)

3. The next screen will display your Notehub **Client ID** and **Client Secret**. Copy those values into the corresponding inputs back in Blynk.Console, and then click **Connect**.

4. After connecting, scroll down in the dialog and find your Blues ProductUID. On this section's dropdown select the template you created earlier, and then click the **Add** button. ![Add button in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/add-button.png?v=d5e0a7b7)

5. Next, hover over your product in the same dialog, and find and click the **Import devices** button. ![Import devices button in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/import-devices-button.png?v=87db9ed3)

6. If all went well, Blynk should've found your device and imported it into Blynk. You can see your device if you go to the **Devices** screen in Blynk.Console.

   ![Devices view in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/devices.png?v=d0d11bb9)

Now that Blynk knows about your device, your last step is to create a Notehub route so that Notehub forwards its data to Blynk.

### Create a Blynk Notehub Route

1. Return to your Notehub project and go to the **Routes** screen, click **Create Route**, and then scroll down and select the **Blynk** option.

2. Give your route a name, for example “Blynk”. ![Configuring a Blynk route](https://dev.blues.io/images/guides/route-tutorial/blynk/blynk-route.png?v=f7eb92fa)

3. For the region field, return to your Blynk.Console and locate the region on the bottom-right section of the screen. ![A region in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/region.png?v=3366fbb5)

4. Click **Create Route** to save your new route.

And with that, you're all set! If you visit your Notehub project's **Events** screen you should see green checkboxes indicating your data is routing to Blynk successfully.

Remember, if you don't have any new Notes coming in to Notehub, you can always **manually route** existing Notes by (1) checking the box next to an event, (2) clicking the **Route** button, and (3) choosing the Route you would like to use.

![Data routing to Blynk successfully](https://dev.blues.io/images/guides/route-tutorial/blynk/data-routing.png?v=c95bcff9)

> **Note:**
>
> This [guide from Blynk](https://docs.blynk.io/en/hardware-guides/blues) has more details on what you can do with a Blues integration, such as sending downlink data in a `blynk.qi` Notefile, and [manually provisioning devices](https://docs.blynk.io/en/hardware-guides/blues#device-provisioning)

> **Note:**
>
> If you wish to send a location to Blynk, that location *must* be sent in the `body` of your events.
>
> By default, Notehub places all location information, such as the [various `best_location` fields](https://dev.blues.io/notehub/notehub-walkthrough.md#bestlocation), in the root of the event and *not* the `body`.
>
> However, you can move the necessary fields to the `body` by adding a JSONata expression to your route (like we did in [the section above](#use-jsonata-to-transform-json)). The following JSONata takes the `best_lat` and `best_lon` fields that Notehub automatically adds to all events, and merges them into each event’s `body` as a new `"location"` field.
>
> ```json
> (
>     $merge([$, {"body": $merge([body, { 
>         "location": [best_lon, best_lat]
>     }])}])
> )
> ```

> **Tip:**
>
> To debug a route or inspect the exact request Notehub sends to your third-party service, open an event in Notehub, click **Route as cURL**, and choose the appropriate HTTP-based route. The modal shows a cURL command that reproduces the same request Notehub makes, with secrets (API keys, passwords, etc.) replaced by placeholders.
>
> ![view curl request from route](https://dev.blues.io/images/guides/route-tutorial/event-route-curl.png?v=22e6a261)

## Build Data Visualizations

One of the many powerful features of Blynk is its ability to create rich dashboards for your devices. Let's look at how to build one for your device now that you have data flowing into Blynk.

1. Within Blynk.Console, go to **Devices**, select your device, and then click **Edit Dashboard** to add new widgets. ![Editing a dashboard in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/edit-dashboard.png?v=42e1821e)

2. On the next screen, experiment with adding widgets from the **Widget Box**. For each widget you add, click its settings button and select the appropriate datastream for the value you wish to use. For example, the screenshot below shows how to create a label widget that uses the temperature datastream. ![Temperature widget in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/temp-widget.png?v=8d716c2d)

3. Play around in Blynk until you have a dashboard you're happy with—remembering that now that you have the dataflow in place, you can easily add new datastreams and include them in your dashboards.

   ![A dashboard in Blynk](https://dev.blues.io/images/guides/route-tutorial/blynk/blynk-dashboard.png?v=72f70786)

## Next Steps

**Congratulations!** You've created your first Route and connected your Notecard app to an external service. If you're following a Cell+WiFi Quickstart, you're done!

Now that you know the basics of how Notecard and Notehub work, you’re ready to apply what you’ve learned towards a real project. We have a few recommendations on what to do next:

- [**Learn Best Practices for Production Projects**](https://dev.blues.io/guides-and-tutorials/best-practices-for-production-ready-projects.md): This skimmable guide has a list of best practices for moving your project from a prototype to a real, production-ready deployment.

- [**Browse Example Apps**](https://dev.blues.io/example-apps.md): Our collection of IoT apps that show how to build common projects with Blues. These example apps include dozens of [official Blues project accelerators](https://dev.blues.io/example-apps/accelerators/) and a collection of [purpose-built sample apps](https://dev.blues.io/example-apps.md).

- [**Follow the Notehub Walkthrough**](https://dev.blues.io/notehub/notehub-walkthrough.md): Learn how to manage projects and device fleets, update Notecard and host firmware, set up alerts, securely route your data, and more.

At any time, if you find yourself stuck, please reach out on the [community forum](https://discuss.blues.com/).