API in Power Automate Desktop

KT Sessions November 15, 2024

 

API in Power Automate Desktop

When automating workflows, one of the most powerful tools at your disposal is the ability to integrate with APIs. APIs (Application Programming Interfaces) allow different software applications to communicate with each other, enabling you to automate tasks that involve third-party services, like sending data to a web app, retrieving information from an online database, or even interacting with social media platforms.

In Power Automate Desktop (PAD), you can interact with APIs using built-in actions, without writing any code. This makes it easier than ever to connect your automations with external systems.

In this blog post, we’ll explore the API actions in Power Automate Desktop, explain how to use them, and provide simple examples to help you get started.


What Are API Actions in Power Automate Desktop?

API actions in Power Automate Desktop allow you to:

  • Send requests to web APIs (like GET, POST, PUT, DELETE).
  • Retrieve data from an API response.
  • Send data to an API (for creating or updating records).
  • Handle different types of responses (e.g., JSON, XML).

These actions help you interact with external services and automate processes that would otherwise require manual input or complex integrations.

Here are the key API actions available in Power Automate Desktop:

  1. HTTP Request: Send HTTP requests to an API and get the response.
  2. Parse JSON: Process JSON data received from an API.
  3. Store Data: Store API data into variables for use later in the flow.

Basic HTTP Request

The HTTP Request action is the core action for interacting with APIs in Power Automate Desktop. It allows you to send requests like:

  • GET: Retrieve data from an API.
  • POST: Send data to an API (e.g., create a new record).
  • PUT: Update an existing record.
  • DELETE: Remove data from an API.

Example 1: Sending a GET Request to an API

Imagine you want to retrieve the current weather data from a weather API, such as OpenWeatherMap. Here’s how you can do it using the HTTP Request action.

Steps:

  1. Get an API Key from a service like OpenWeatherMap.
  2. Set the URL for the API endpoint that provides weather data, e.g., https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_API_KEY.
  3. Use the HTTP Request action to send a GET request to this API and retrieve the data.
  4. Capture the response from the API, which will usually be in JSON format.

Action: HTTP Request
   Method: GET
   URL: https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_API_KEY
   Response: { "weather": [{"description": "clear sky"}], "main": {"temp": 298.15} }

In this example, you’re retrieving weather data for London. The response will contain the weather description and temperature in Kelvin.

Handling API Responses

When you send a request to an API, the response typically comes in a JSON format (JavaScript Object Notation), which is easy for computers to read and write. However, you need to parse this response in Power Automate Desktop to make the data usable in your workflow.

Example 2: Parsing JSON Data

Now that you’ve received the response from the weather API, you want to extract the temperature and description to use in your flow (e.g., to log the information or display it in a message).

Here’s how to handle the response and extract the data:

  1. Use the Parse JSON action to parse the API response.
  2. Extract specific values from the parsed JSON, like the weather description and temperature.

Steps:

  1. After the HTTP request, use the Parse JSON action to parse the response.
  2. Extract the temperature and weather description from the JSON response.
Action: Parse JSON
   Content: { "weather": [{"description": "clear sky"}], "main": {"temp": 298.15} }
   Schema: {
       "type": "object",
       "properties": {
           "weather": { "type": "array", "items": { "type": "object", "properties": { "description": { "type": "string" } } } },
           "main": { "type": "object", "properties": { "temp": { "type": "number" } } }
       }
   }

Action: Set Variable
   Name: weatherDescription
   Value: ParsedJSON.weather[0].description

Action: Set Variable
   Name: temperature
   Value: ParsedJSON.main.temp

After parsing the JSON response, the weatherDescription variable will contain "clear sky", and the temperature variable will contain 298.15 (temperature in Kelvin).

To make it more readable, you could convert the temperature to Celsius or Fahrenheit:

Action: Set Variable
   Name: temperatureInCelsius
   Value: temperature - 273.15

Example 3: Sending a POST Request to an API

Now, let’s look at an example of sending data to an API. For instance, you might want to submit a new user to a web service.

Suppose you want to send user information (name, email, etc.) to a user registration API. Here’s how to do it:

  1. Set the URL of the API endpoint, e.g., https://api.example.com/users.
  2. Choose the POST method to send data to the API.
  3. Add the user information as JSON data in the body of the request.
Action: HTTP Request
   Method: POST
   URL: https://api.example.com/users
   Headers: Content-Type: application/json
   Body: {
       "name": "John Doe",
       "email": "john.doe@example.com",
       "age": 30
   }
   Response: { "id": 123, "name": "John Doe", "email": "john.doe@example.com", "status": "success" }

In this example, you’re sending a POST request to the users endpoint with the user’s name, email, and age in JSON format. The response will likely include the user’s unique ID and a status message.

4. Using API Authentication

Many APIs require authentication before you can send or receive data. The most common authentication methods are API keys and OAuth tokens.

Example 4: Sending an API Key for Authentication

If an API requires an API key for authentication, you can send it as part of the request headers.

Action: HTTP Request
   Method: GET
   URL: https://api.example.com/data
   Headers:
      - Authorization: Bearer YOUR_API_KEY
   Response: { "data": [...] }

Here, the Authorization header sends the API key in the request to authenticate your call.

Error Handling in API Requests

When making API requests, errors can occur (e.g., if the API is down, if your API key is incorrect, or if the data is malformed). It's essential to handle these errors gracefully.

Example 5: Checking for API Errors

You can check if the API response contains an error or status code indicating failure (e.g., 400 or 500), and then take action accordingly.

Action: HTTP Request
   Method: GET
   URL: https://api.example.com/data
   Response: { "status": "error", "message": "Invalid API Key" }

Action: Condition (If Response.status == "error")
   True Branch: Log Message ("Error: " + Response.message)
   False Branch: Continue with flow

This condition checks if the response contains an error, and logs the error message if needed.

Conclusion

APIs are a powerful way to integrate external data and services into your Power Automate Desktop workflows. By using the HTTP Request action, you can send and receive data from web services, making your automations even more powerful and versatile.

In this post, we’ve learned how to:

  • Send GET and POST requests to interact with APIs.
  • Parse JSON responses to extract useful data.
  • Handle authentication and errors during API calls.

By mastering these API actions, you can integrate Power Automate Desktop with countless external systems and services, streamlining your automation tasks and improving your workflow efficiency

KT Sessions

Posted by KT Sessions