✦ BeginnerPower AutomateRest API9 min readSeptember 2025

REST API GET Requests in Power Automate: Complete Guide to HTTP Actions and JSON Parsing

Learn how to make REST API GET requests in Power Automate to retrieve data from external services. This guide covers creating HTTP actions, configuring request parameters, testing API calls, parsing JSON responses, and using retrieved data in subsequent flow actions like sending emails or posting to Teams.

Rob Lees

Founder & Principal Consultant

Overview

REST APIs enable Power Automate flows to interact with external services and retrieve data from web-based systems. Using the HTTP action with GET method, you can call API endpoints, receive JSON responses, parse the data structure, and use the retrieved information throughout your flow. This opens possibilities for integrating third-party services, custom APIs, and any web-based data source into your automation workflows.

Prerequisites

Power Automate cloud flow experience
Basic understanding of HTTP methods
Familiarity with JSON data format
Experience with Parse JSON action

Understanding REST API GET Requests

Integrating external REST APIs into your Power Automate flows opens up a world of possibilities—from enriching your data to triggering workflows based on external events. In this post, we'll walk through how to make a simple GET request to the Dog API, a fun and free API that returns random dog images and breed data.

This example is perfect for beginners looking to understand how to use HTTP actions in Power Automate.

What is a REST API GET request?

A GET request retrieves data from an API endpoint without modifying any server-side data. It's the most common HTTP method for reading information from external services.

Common use cases for API GET requests:

Retrieving weather data from weather APIs for location-based automations
Fetching customer information from CRM systems
Getting product inventory from e-commerce platforms
Pulling financial data from accounting systems
Reading configuration settings from external management systems
Accessing public data sets for analytics and reporting

Why use REST APIs in Power Automate?

Integration – Connect to any service with a REST API, even if no connector exists
Flexibility – Access specific endpoints and parameters not supported by pre-built connectors
Real-time data – Retrieve current information on demand during flow execution
Custom services – Integrate with your own APIs and internal systems

💡 Key Concept

REST APIs return data in JSON format—a structured text format that Power Automate can parse and use. After making a GET request, you'll receive JSON data in the HTTP action's output. Use the Parse JSON action to define the structure, making individual properties accessible as dynamic content in subsequent actions throughout your flow.

Setting Up the Flow

Go to Power Automate

Navigate to make.powerautomate.com and sign in.

Click Create → Instant cloud flow

Choose "Manually trigger a flow" as the trigger. This allows you to test the flow on demand.

Choose Manually trigger a flow and name it something like "Dog API GET Request"

Give your flow a descriptive name that indicates it's making an API call to the Dog API.

Why use manual trigger for API testing?

Manual triggers are ideal for learning and testing because:

You control exactly when the flow runs
Easy to test repeatedly while developing
No risk of automated triggers firing unexpectedly
Can add trigger inputs later for dynamic parameters

Alternative triggers for production APIs:

Trigger Type	Use Case	Example
Recurrence	Fetch data on schedule	Get weather data every hour
When a row is added	API call triggered by new data	Get customer details when new order created
PowerApps	User-initiated from canvas app	Lookup product info when user searches
HTTP request	Webhook from external system	Third-party service triggers flow via webhook

⚠️ API Rate Limits

Most APIs enforce rate limits—maximum number of requests allowed per minute or hour. When designing flows that call APIs frequently (e.g., recurrence triggers), check the API documentation for rate limits. Exceeding limits causes failures. Add delay actions or batch processing to stay within allowed request rates.

Configuring the HTTP Request

Add a new step and search for HTTP.

Choose the HTTP action

Select the standard HTTP action (not HTTP with Azure AD or HTTP webhook).

Configure it as follows:

Set the Method to GET and enter the API endpoint URL.

Method: GET
URI: https://dogapi.dog/api/v2/facts

This endpoint returns a random dog fact.

Understanding the HTTP action fields:

Field	Purpose	When to Use
Method	HTTP verb (GET, POST, PUT, DELETE, PATCH)	GET for retrieving data, POST for creating, PUT/PATCH for updating
URI	API endpoint URL	Always required - the full URL including https://
Headers	Request metadata (authentication, content type)	When API requires API keys, tokens, or specific content types
Queries	URL parameters	For filtering, pagination, or passing parameters to API
Body	Data sent with request	POST/PUT/PATCH requests only (not used for GET)

Example with authentication header:

Method: GET
URI: https://api.example.com/data

Headers:
{
  "Authorization": "Bearer YOUR_API_KEY",
  "Content-Type": "application/json"
}

Example with query parameters:

Method: GET
URI: https://api.example.com/products

Queries:
{
  "category": "electronics",
  "limit": "10",
  "sort": "price_asc"
}

Query parameters are appended to the URL as: `https://api.example.com/products?category=electronics&limit=10&sort=price_asc`

💡 Pro Tip

Always check API documentation for required headers and authentication methods before configuring HTTP actions. Common authentication patterns include API keys in headers (Authorization: Bearer token), API keys in query parameters (?api_key=value), or basic authentication (username:password encoded in headers). The Dog API used in this example requires no authentication.

Running and Inspecting the Response

Click Test → Manually → Run Flow.

Once the flow runs, inspect the Outputs of the HTTP action. You should see a JSON response like:

"facts": [
  "Dogs have three eyelids."
],
"success": true

Understanding the HTTP response:

The HTTP action outputs contain several important properties:

Property	Description	Example Value
statusCode	HTTP response code	200 (success), 404 (not found), 500 (server error)
headers	Response metadata	Content-Type, Date, Server info
body	The actual JSON data returned	{"facts": [...], "success": true}

Common HTTP status codes:

200 OK – Request succeeded, data returned
201 Created – Resource created successfully (POST requests)
400 Bad Request – Invalid request format or missing required parameters
401 Unauthorized – Authentication required or invalid credentials
404 Not Found – Endpoint doesn't exist or resource not found
429 Too Many Requests – Rate limit exceeded
500 Internal Server Error – API server error

Viewing outputs in flow run history:

Click on the HTTP action in the run history

The action expands showing inputs and outputs.

Expand "Show raw outputs"

This displays the complete JSON response body.

Copy the body content

You'll need this sample JSON for the Parse JSON action schema.

⚠️ Error Handling

If the HTTP action fails with status code 4xx or 5xx, the flow marks as failed by default. Add Configure run after settings to handle errors gracefully. Check the status code in a Condition action and branch logic based on success (200) vs errors. This prevents entire flow failures when APIs are temporarily unavailable.

Extracting Data from API Response

To use the data in later steps, add a Parse JSON action.

Add a new action and search for Parse JSON

Select the Data Operations - Parse JSON action.

Content: body from the HTTP action

Select the Body dynamic content from the HTTP action outputs.

Schema: Use the following schema:

Click "Use sample payload to generate schema" and paste the JSON from the HTTP response.

{
  "type": "object",
  "properties": {
    "facts": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "success": {
      "type": "boolean"
    }
  }
}

Understanding JSON schema:

Schema Element	Meaning	Example
type: "object"	Root level is a JSON object {}	The entire response structure
type: "array"	Property contains array []	facts: ["fact1", "fact2"]
type: "string"	Text value	"Dogs have three eyelids"
type: "boolean"	True/false value	success: true
type: "number"	Numeric value	count: 42

Generating schema automatically:

Instead of writing schema manually, use the "Use sample payload to generate schema" button:

Copy the entire JSON body from the HTTP action's output
Click "Use sample payload to generate schema" in Parse JSON action
Paste the JSON sample
Click Done - schema auto-generates

Why Parse JSON is necessary:

Without Parse JSON, you can access the entire body as text, but individual properties aren't available in dynamic content. After parsing, you get clean access to each property:

// Without Parse JSON
body('HTTP')?['facts']?[0]  // Expression required

// With Parse JSON  
facts  // Available in dynamic content picker
success  // Available in dynamic content picker

💡 Pro Tip

Always test your HTTP action first and use the actual response to generate the Parse JSON schema. API documentation may not always match the real response structure. Using a real response ensures your schema accurately reflects what the API returns, preventing parsing errors when the flow runs in production.

Using Parsed API Data in Actions

Now you can use the parsed data. For example, add a Send an email (V2) action.

To: your@email.com
Subject: Dog Fact of the Day
Body: @{body('Parse_JSON')?['facts']?[0]}

Or post it to a Teams channel using the Post a message in a chat or channel action.

Example: Sending email with API data

Add "Send an email (V2)" action

Search for and select the Outlook Send an email action.

Configure email fields

Use dynamic content from Parse JSON to populate subject and body.

To: recipient@company.com
Subject: Dog Fact of the Day
Body: 
Here's your daily dog fact:

@{body('Parse_JSON')?['facts']?[0]}

Status: @{body('Parse_JSON')?['success']}

Example: Posting to Teams

Action: Post message in a chat or channel

Post as: Flow bot
Post in: Channel
Team: Your Team Name
Channel: General

Message:
🐕 Dog Fact of the Day 🐕

@{body('Parse_JSON')?['facts']?[0]}

Example: Storing in SharePoint

Action: Create item

Site Address: https://company.sharepoint.com/sites/facts
List Name: Dog Facts

Title: Dog Fact - @{utcNow('yyyy-MM-dd')}
Fact: @{body('Parse_JSON')?['facts']?[0]}
Retrieved: @{utcNow()}

Accessing array items:

The Dog API returns facts as an array. To access the first fact, use index [0]:

// Expression to get first fact
body('Parse_JSON')?['facts']?[0]

// If API returns multiple facts, loop through them
Apply to each:
  Items: body('Parse_JSON')?['facts']
  
  Current item: items('Apply_to_each')

This simple example shows how easy it is to connect Power Automate to external APIs. You can expand this by using other endpoints from the Dog API, such as:

https://dogapi.dog/api/v2/breeds
https://dogapi.dog/api/v2/images

⚠️ Null Value Handling

API responses may contain null or missing properties. If you reference a property that doesn't exist, the flow fails. Always use the ? safe navigation operator in expressions: body('Parse_JSON')?['facts']?[0]. This returns null instead of failing when properties are missing. Add Condition checks or coalesce() for default values when nulls are expected.

Next Steps

You now understand how to make REST API GET requests in Power Automate, parse JSON responses, and use retrieved data in flow actions. This fundamental skill enables integration with countless external services and custom APIs.

Expand your API integration capabilities by exploring:

POST requests – Sending data to APIs to create records or trigger actions
PUT/PATCH requests – Updating existing records via API calls
DELETE requests – Removing records through API endpoints
Authentication patterns – OAuth, API keys, bearer tokens, basic auth implementation
Pagination handling – Retrieving all pages when APIs return limited results per call
Error handling – Gracefully managing API failures, timeouts, and rate limits
Response caching – Storing API responses to reduce redundant calls
Webhook integration – Receiving real-time notifications from external services

The Microsoft Custom Connectors documentation provides comprehensive guidance on building reusable API connections, creating custom connectors for frequently-used APIs, and implementing advanced authentication schemes for secure API integration in Power Automate and Power Apps.

Article Info

Suitable for those new to Power Platform.

9 min read · September 2025