OData and REST API connections in Power BI - Deep Dive

Overview - OData and REST API connections

What is it?

OData and REST API connections let Power BI get data from web services. OData is a standard way to ask for data using URLs with filters and queries. REST API is a way to talk to web services by sending requests and getting data back, usually in JSON format. Both help bring live or updated data into Power BI reports.

Why it matters

Without these connections, you would have to manually download data or rely only on files and databases. This slows down decision-making and can cause errors. OData and REST APIs let you automate data updates and connect to many online services, making your reports fresh and reliable.

Where it fits

You should know basic Power BI data loading and query editing before learning this. After this, you can explore advanced data transformations, custom connectors, and automation with Power Query and Power BI dataflows.

Mental Model

Core Idea

OData and REST API connections are like ordering specific data from a web waiter who brings exactly what you ask for, so Power BI can serve fresh reports.

Think of it like...

Imagine you are at a restaurant and want a special dish. OData and REST APIs are like the waiter who takes your order (request) and brings you the exact meal (data) you want, instead of you cooking it yourself.

┌───────────────┐      Request URL/JSON       ┌───────────────┐
│   Power BI    │ ──────────────────────────▶ │   Web API     │
│ (Data Client) │                            │ (Data Server) │
└───────────────┘ ◀───────────────────────── └───────────────┘
          ▲                                         ▲
          │                                         │
     Data Model                               Data Source
     & Visuals                                (Database,
                                               Service)

Build-Up - 7 Steps

1

Foundation

What is OData and REST API

Concept: Introduce the basic idea of OData and REST APIs as ways to get data from web services.

OData is a web protocol that uses URLs to ask for data with filters and sorting. REST API is a broader way to get or send data using HTTP methods like GET or POST. Both let Power BI connect to online data sources beyond files or databases.

Result

You understand that OData and REST APIs are methods to fetch data from the web into Power BI.

Knowing these are data connection methods opens up many new data sources for your reports.

2

Foundation

How Power BI connects to OData and REST APIs

Concept: Explain the process Power BI uses to connect and get data from these services.

Power BI uses Power Query to send requests to OData or REST API URLs. It receives data in formats like JSON or XML, then converts it into tables you can use. You can enter URLs directly or use built-in connectors for OData feeds.

Result

You can connect Power BI to a web service by providing the right URL and credentials.

Understanding the connection flow helps you troubleshoot and customize data imports.

3

Intermediate

Filtering and querying data with OData URLs

🤔Before reading on: do you think OData URLs can request only parts of data or always the full dataset? Commit to your answer.

Concept: Show how OData URLs can include filters, selects, and orders to get only needed data.

OData URLs can have query options like $filter to get rows matching conditions, $select to choose columns, and $orderby to sort data. For example, adding ?$filter=Price gt 100 gets only items with price greater than 100. This reduces data size and speeds up refresh.

Result

You can write OData URLs that bring only relevant data into Power BI.

Knowing how to filter data at the source saves time and memory in your reports.

4

Intermediate

Handling JSON data from REST APIs in Power BI

🤔Before reading on: do you think Power BI automatically understands all JSON data shapes or do you need to shape it manually? Commit to your answer.

Concept: Teach how to parse and transform JSON responses from REST APIs into tables.

REST APIs often return JSON with nested objects and arrays. Power Query lets you expand these nested parts step-by-step to create flat tables. You use 'Record' and 'List' tools in Power Query to drill down and select fields you want.

Result

You can convert complex JSON data into clean tables for analysis.

Understanding JSON structure and Power Query tools is key to unlocking REST API data.

5

Intermediate

Authentication methods for API connections

🤔Before reading on: do you think all APIs allow anonymous access or do most require some form of login? Commit to your answer.

Concept: Explain common ways to authenticate when connecting to APIs.

Many APIs require authentication like API keys, OAuth tokens, or basic username/password. Power BI lets you enter these credentials in the connection dialog or add them in HTTP headers using Power Query. Without proper authentication, data access is denied.

Result

You know how to provide credentials so Power BI can access protected APIs.

Knowing authentication methods prevents connection errors and secures your data.

6

Advanced

Using Power Query M to customize API calls

🤔Before reading on: do you think you can only use static URLs for API calls or can you build dynamic queries in Power Query? Commit to your answer.

Concept: Show how to write M code to build dynamic API requests with parameters and headers.

Power Query M language lets you create functions that build URLs with variables, add HTTP headers, and handle pagination. For example, you can loop through pages of API data or pass user inputs to filter data dynamically. This makes your data refresh flexible and powerful.

Result

You can create advanced API queries that adapt to changing needs.

Mastering M code for APIs unlocks automation and complex data retrieval scenarios.

7

Expert

Performance and reliability considerations for API data

🤔Before reading on: do you think calling APIs frequently always improves data freshness without downsides? Commit to your answer.

Concept: Discuss challenges like rate limits, slow responses, and data caching when using APIs in production.

APIs often limit how many requests you can make per minute. Large or slow responses can delay report refresh. Power BI caches data but you must balance refresh frequency with API limits. Using incremental refresh, error handling, and retry logic in M helps build robust solutions.

Result

You understand how to design API connections that are fast, reliable, and respectful of limits.

Knowing API constraints helps avoid refresh failures and keeps reports responsive.

Under the Hood

When Power BI connects to an OData or REST API, it sends an HTTP request to the service URL. The service processes the request, applies filters or parameters, and returns data usually in JSON or XML format. Power Query engine parses this data, converts nested structures into tables, and loads it into the data model. Authentication tokens or keys are sent in headers or URL parameters to verify access.

Why designed this way?

OData was designed as a standard protocol to simplify querying web data with URL syntax, making it easy for clients to request exactly what they need. REST APIs use HTTP methods for flexibility and broad compatibility. This design allows many different services to expose data in a uniform way, enabling tools like Power BI to connect without custom drivers.

┌───────────────┐       HTTP Request       ┌───────────────┐
│   Power BI    │ ───────────────────────▶ │   API Server  │
│ (Power Query) │                          │ (OData/REST)  │
└───────────────┘ ◀─────────────────────── └───────────────┘
          │                                         │
          │          JSON/XML Response             │
          ▼                                         ▼
┌───────────────────┐                      ┌───────────────────┐
│ Power Query Engine│                      │ Data Source Logic │
│ Parses & Transforms│                      │ Applies Filters   │
└───────────────────┘                      └───────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think OData and REST API connections always return data instantly without limits? Commit to yes or no.

Common Belief: OData and REST APIs always return all data immediately with no restrictions.

Reality: APIs often have limits like paging, rate limits, and response size caps. They may return partial data or require multiple calls to get all data.

Why it matters: Ignoring these limits can cause incomplete reports, slow refreshes, or blocked API access.

Quick: Do you think Power BI automatically understands and flattens any JSON from REST APIs without manual steps? Commit to yes or no.

Common Belief: Power BI can automatically convert any JSON response into a clean table without extra work.

Reality: Many JSON responses are nested and require manual expansion and shaping in Power Query to create usable tables.

Why it matters: Assuming automatic conversion leads to confusing data models and wasted time troubleshooting.

Quick: Do you think all APIs use the same authentication method? Commit to yes or no.

Common Belief: All APIs use the same simple authentication like API keys in the URL.

Reality: APIs use many methods including OAuth, basic auth, tokens, or no auth. Each requires different handling in Power BI.

Why it matters: Using wrong authentication causes connection failures and security risks.

Quick: Do you think refreshing API data in Power BI always means the freshest data? Commit to yes or no.

Common Belief: Every time Power BI refreshes, it gets the latest data from the API.

Reality: APIs or Power BI may cache data, and refresh frequency or API limits can delay updates.

Why it matters: Expecting real-time data without considering caching leads to wrong business decisions.

Expert Zone

1

Some APIs require complex pagination handling that needs custom M code to loop through pages and combine results.

2

OData supports metadata documents that describe the data model, which can be used to generate queries dynamically.

3

Power BI's native OData connector optimizes queries by pushing filters to the server, but custom REST calls may not benefit from this.

When NOT to use

Avoid using direct API calls for very large datasets or high-frequency refreshes due to rate limits and performance. Instead, use data warehouses, dataflows, or cached extracts. For complex authentication scenarios, consider building custom connectors or using Azure services as intermediaries.

Production Patterns

Professionals use parameterized M functions to build flexible API queries, implement incremental refresh to limit data volume, and handle errors gracefully with try-catch logic. They also monitor API usage to avoid hitting limits and schedule refreshes during off-peak hours.

Connections

SQL Queries

Similar pattern

Both OData URLs and SQL queries let you filter, select, and sort data before loading, reducing data volume and improving performance.

HTTP Protocol

Builds-on

Understanding HTTP methods and headers helps grasp how REST APIs communicate and how Power BI sends requests.

Supply Chain Ordering Systems

Analogous process

Just like supply chains order specific parts from suppliers to build products efficiently, API connections request precise data pieces to build reports efficiently.

Common Pitfalls

#1 Trying to load entire API data without filtering or paging.

Wrong approach:

let
Source = Json.Document(Web.Contents("https://api.example.com/data"))
in
Source

Correct approach:

let
Source = Json.Document(Web.Contents("https://api.example.com/data?page=1&size=100"))
in
Source

Root cause:

Not understanding API limits and the need to request data in manageable chunks.

#2 Assuming JSON data is flat and loading it directly without expansion.

Wrong approach:

let
Source = Json.Document(Web.Contents("https://api.example.com/data"))
in
Source

Correct approach:

let
Source = Json.Document(Web.Contents("https://api.example.com/data")),
Records = Source["items"],
Table = Table.FromList(Records, Splitter.SplitByNothing())
in
Table

Root cause:

Not recognizing nested JSON structures and the need to expand them in Power Query.

#3 Entering API key in URL without encoding or using proper headers.

Wrong approach:

let
Source = Json.Document(Web.Contents("https://api.example.com/data?apikey=12345"))
in
Source

Correct approach:

let
Source = Json.Document(Web.Contents("https://api.example.com/data", [Headers=[Authorization="Bearer 12345"]]))
in
Source

Root cause:

Misunderstanding secure authentication practices and API requirements.

Key Takeaways

OData and REST API connections let Power BI fetch live data from web services using URLs and HTTP requests.

Filtering and shaping data at the source reduces load time and improves report performance.

Power Query is essential for parsing and transforming complex JSON or XML data from APIs into usable tables.

Proper authentication is critical to access protected APIs and avoid connection errors.

Understanding API limits and designing queries carefully ensures reliable and efficient data refreshes.

Practice

1. What is the main advantage of using an OData connection in Power BI compared to a generic REST API?

easy

A. It cannot refresh data automatically.

B. It requires manual coding for every data request.

C. It only works with Excel files.

D. It provides a standardized query language and easier data filtering.

Solution

1. Step 1: Understand OData protocol features

   OData supports standardized query options like filtering, sorting, and paging directly in the URL.

2. Step 2: Compare with REST API flexibility

   REST APIs are flexible but often require custom query parameters and manual handling of data requests.

3. Final Answer:

   It provides a standardized query language and easier data filtering. -> Option D

4. Quick Check:

   OData = Standardized queries [OK]

Hint: OData uses standard queries; REST APIs need custom calls [OK]

Common Mistakes:

• Thinking OData only works with Excel
• Assuming REST APIs auto-refresh data
• Believing OData requires manual coding

2. Which Power Query M function is used to connect to a REST API endpoint in Power BI?

easy

A. OData.Feed()

B. Web.Contents()

C. Csv.Document()

D. Excel.Workbook()

Solution

1. Step 1: Identify function for REST API calls

   The Web.Contents() function fetches data from any web URL, including REST APIs.

2. Step 2: Differentiate from OData function

   OData.Feed() is specific for OData sources, not generic REST APIs.

3. Final Answer:

   Web.Contents() -> Option B

4. Quick Check:

   REST API = Web.Contents() [OK]

Hint: Use Web.Contents() for REST API URLs [OK]

Common Mistakes:

• Using OData.Feed() for REST APIs
• Confusing CSV import with API calls
• Trying Excel.Workbook() for web data

3. Given this Power Query M code snippet connecting to an OData feed:

let
  Source = OData.Feed("https://services.odata.org/V4/Northwind/Northwind.svc/Products"),
  Filtered = Table.SelectRows(Source, each [CategoryID] = 1)
in
  Filtered

What will be the result?

medium

A. An empty table because CategoryID is not a valid column.

B. An error because OData.Feed cannot filter data.

C. A table of products where CategoryID equals 1.

D. A list of all categories instead of products.

Solution

1. Step 1: Understand OData.Feed output

   The OData.Feed() function returns a table of products from the OData service.

2. Step 2: Analyze filtering step

   Table.SelectRows() filters rows where CategoryID equals 1, which is valid for this dataset.

3. Final Answer:

   A table of products where CategoryID equals 1. -> Option C

4. Quick Check:

   Filter by CategoryID=1 = filtered product table [OK]

Hint: OData.Feed returns tables; filter with Table.SelectRows() [OK]

Common Mistakes:

• Assuming OData.Feed cannot filter
• Confusing products with categories
• Thinking CategoryID column is missing

4. You wrote this Power Query M code to get data from a REST API:

let
  Source = Web.Contents("https://api.example.com/data"),
  Json = Json.Document(Source),
  Table = Table.FromList(Json, Splitter.SplitByNothing())
in
  Table

But you get an error saying "Expression.Error: We cannot convert the value to a table." What is the likely cause?

medium

A. The JSON returned is an object, not a list, so Table.FromList fails.

B. Web.Contents() cannot fetch JSON data.

C. Json.Document() only works with XML data.

D. Splitter.SplitByNothing() is not a valid function.

Solution

1. Step 1: Check JSON structure expected

   Table.FromList() expects a list, but if JSON is an object (record), it cannot convert directly.

2. Step 2: Understand error cause

   The error means the JSON is not a list but an object, so conversion fails.

3. Final Answer:

   The JSON returned is an object, not a list, so Table.FromList fails. -> Option A

4. Quick Check:

   JSON object ≠ list causes conversion error [OK]

Hint: Check if JSON is list or object before Table.FromList() [OK]

Common Mistakes:

• Thinking Web.Contents() can't get JSON
• Assuming Json.Document() only parses XML
• Believing Splitter.SplitByNothing() is invalid

5. You want to combine data from an OData feed and a REST API in Power BI. The OData feed provides product details, and the REST API returns live stock levels as JSON. Which approach is best to create a unified table for reporting?

hard

A. Use OData.Feed() to get products, Web.Contents() + Json.Document() for stock, then merge tables in Power Query.

B. Use only OData.Feed() for both sources since it supports all APIs.

C. Import REST API JSON as CSV and append to OData feed table directly.

D. Load both sources separately and create relationships in the data model without merging.

Solution

1. Step 1: Connect to each data source appropriately

   Use OData.Feed() for the OData product details and Web.Contents() with Json.Document() to parse REST API stock JSON.

2. Step 2: Combine data in Power Query

   Merge the two tables on product ID to create a unified table before loading into the report.

3. Final Answer:

   Use OData.Feed() to get products, Web.Contents() + Json.Document() for stock, then merge tables in Power Query. -> Option A

4. Quick Check:

   Combine sources with correct connectors and merge [OK]

Hint: Use correct connectors per source, then merge in Power Query [OK]

Common Mistakes:

• Trying to use OData.Feed() for REST API JSON
• Appending JSON as CSV without parsing
• Not merging data, just relating tables