Power Apps JSON Polymorphic Error on _ownerid_value: The Fix + Why It Happens

Getting the “The JSON function cannot serialize tables/objects with a nested property called ‘_ownerid_value’ of type ‘Polymorphic'” error in Power Apps?

I ran into this exact issue while building a Power Apps Canvas App against a Dataverse table. I was trying to extract column names from a collection using the JSON function — and out of nowhere, this error completely stopped me. The frustrating part? I had already added JSONFormat.IgnoreBinaryData to the formula, so I assumed that would handle everything. It didn’t.

In this tutorial, I’ll walk you through:

• What this error actually means (and why it happens)
• The exact one-line fix
• Which Dataverse columns commonly trigger it
• Three edge case scenarios where the fix behaves differently
• How to handle polymorphic lookups properly when you need their actual values

What Is This Power Apps JSON Polymorphic Error Telling You?

When you use the JSON() function in Power Apps, it tries to convert your table or collection data into a JSON string. But Power Apps has a strict rule: it won’t serialize data types it doesn’t fully understand — and polymorphic lookup columns fall into that category.

A polymorphic lookup is a special column type in Dataverse that can point to multiple tables. For example, the ownerid column on almost every Dataverse table can refer to either a User or a Team. Because Power Apps can’t determine which table it points to at the time of serialization, it throws this error instead of guessing.

The error message itself is Dataverse’s way of saying: “I found a column I can’t convert to JSON, and you haven’t told me what to do with it.

What Is a Polymorphic Column in Dataverse?

Before we jump to the fix, it helps to understand this properly, because if you have more than one polymorphic column in your dataverse table, the same error will come back even after you fix it for ownerid.

A polymorphic lookup (also called a multi-table lookup) is a column that can reference records from multiple tables. The column stores a record reference rather than a direct record, so Power Apps has to resolve which table it belongs to at runtime.

The most common ones you’ll encounter across Dataverse tables:

Column Name	Display Name	Can Reference
ownerid / _ownerid_value	Owner	User or Team
customerid / _customerid_value	Customer	Account or Contact
regardingobjectid	Regarding	Multiple activity-related tables
primarycontactid	Primary Contact	Contact or Account

Every single Dataverse table has an Owner column. You can’t remove it, and it always has a value. So if you’re using JSON() on any Dataverse-backed collection, you will almost always hit this error — it’s not a bug in your formula, it’s just an unsupported type by default.

My Setup When I Hit This Error

I had a Dataverse table called Car Booking Details with columns like Car Name, Booking Date, Buyer Name, and Buyer Contact Number. My goal was simple: get all the column names from this table dynamically in Power Apps.

Here’s what I did first — I loaded the Dataverse table into a Power Apps Collection on a button’s OnSelect property:

ClearCollect(
    colCarBookingInfo,
    'Car Booking Details'
);

Then I used the JSON() function along with MatchAll() to extract the column names:

Set(
    varColumnNames,
    Distinct(
        Ungroup(
            MatchAll(
                JSON(
                    colCarBookingInfo,
                    JSONFormat.IgnoreBinaryData
                ),
                "([^""]+?)""\s*:"
            ).SubMatches,
            "SubMatches"
        ),
        Value
    )
);

I already had JSONFormat.IgnoreBinaryData in there, which I knew was needed to skip image and file columns. But the moment I ran this, I got the error. That’s because IgnoreBinaryData only handles binary data (images, videos, attachments) — it does nothing for polymorphic lookup types like ownerid.

The Fix: Combine JSONFormat Flags with the & Operator

The solution is to also add JSONFormat.IgnoreUnsupportedTypes to your formula. This tells Power Apps: “If you encounter a column type you can’t serialize, just skip it and move on.”

And here’s the key thing that tripped me up — you don’t pass them as a list or separate parameters. You combine multiple JSONFormat values using the & operator:

Set(
    varColumnNames,
    Distinct(
        Ungroup(
            MatchAll(
                JSON(
                    colCarBookingInfo,
                    JSONFormat.IgnoreBinaryData & JSONFormat.IgnoreUnsupportedTypes
                ),
                "([^""]+?)""\s*:"
            ).SubMatches,
            "SubMatches"
        ),
        Value
    )
);

The & operator here is not string concatenation — it’s a bitwise combination of the format flags. You can chain as many JSONFormat values as you need using the same pattern.

After making this change, save, publish, and test your app. The error disappears, and you’ll get your column names back cleanly.

Here’s a quick reference for all the JSONFormat options available in Power Apps:

JSONFormat Value	What It Does
Compact	Default. No extra spaces or line breaks.
IndentFour	Adds indentation for readability.
IncludeBinaryData	Includes image/video/audio as base64.
IgnoreBinaryData	Skips binary columns entirely.
IgnoreUnsupportedTypes	Skips polymorphic lookups and other unsupported types.

Three Scenarios Where the Behavior Differs

The fix above works perfectly in most cases, but there are a few situations where you need to be aware of what’s actually happening under the hood.

Scenario 1: Extracting Column Names (Works Great)

This is exactly the use case from the fix above — using JSON() + MatchAll() to grab column names from a Dataverse collection. Adding both IgnoreBinaryData and IgnoreUnsupportedTypes works perfectly here. The polymorphic columns are simply skipped in the JSON output, and you still get all the regular column names back.

Scenario 2: Sending JSON to Power Automate (Watch Out)

This is where things get tricky. If your goal is to send the full row data as JSON to a Power Automate flow, adding IgnoreUnsupportedTypes will skip those polymorphic columns entirely — which means the Owner information and other lookup values simply won’t be in the JSON payload at all.

If you need those values in your flow, you have two options:

Option A: Before calling JSON(), create a separate collection where you explicitly expand the lookup values into plain text fields. For example, resolve ownerid to the owner’s name using AsType() first, store it in a new text column, then run JSON() on that cleaned collection.

Option B: In Power Automate, retrieve the Owner details separately using the record GUID that you pass along with the JSON payload.

Scenario 3: Tables with Both Binary and Polymorphic Columns

If your Dataverse table has image columns (like a profile photo) and polymorphic lookups (like ownerid), You need both flags combined:

JSON(
    colMyCollection,
    JSONFormat.IgnoreBinaryData & JSONFormat.IgnoreUnsupportedTypes
)

Leaving out either one will cause the error to reappear for the type you didn’t handle. Always think about what column types your Dataverse table contains before writing your JSON() formula.

When You Actually Need the Polymorphic Column’s Value

If you genuinely need to work with the ownerid or another polymorphic column’s value — not skip it — you need to use the AsType() and IsType() functions in Power Apps.

Here’s an example. Say you want to display the owner’s name for each record in a gallery. Because Owner can be either a User or a Team, you can’t just write ThisItem.Owner.Name — You’d get a blank or an error.

First, make sure you’ve added Users and Teams as data sources in your app. Then use this formula in a label inside your gallery:

If(
    IsType(ThisItem.Owner, Teams),
    "Team: " & AsType(ThisItem.Owner, Teams).'Team Name',
    "User: " & AsType(ThisItem.Owner, Users).'Full Name'
)

What this does:

• IsType() checks whether the Owner record is a Team record
• If yes, AsType() casts it to the Teams table so you can access Team Name
• If no, it treats it as a User record and pulls Full Name

This gives you the actual value of the polymorphic column, which IgnoreUnsupportedTypes alone can never give you, since it just skips those columns entirely.

Quick Summary of the Full Fix

To fix “The JSON function cannot serialize tables/objects with a nested property called ‘_ownerid_value’ of type ‘Polymorphic'”:

1. Open your Power Apps formula where you’re calling the JSON() function
2. Add JSONFormat.IgnoreUnsupportedTypes to your existing JSONFormat argument
3. Use the & operator to combine it with any other format flags you already have
4. If you’re using it to extract column names, you’re done — save, publish, and test
5. If you need the actual polymorphic column values (not just to skip them), use AsType() and IsType() instead

The root cause is always the same: Dataverse’s ownerid, customerid, regardingobjectid, and similar polymorphic lookup columns are stored as record references — not plain values — and the JSON() function can’t serialize record references unless you tell it to skip them.

Hope this saves you the time I spent tracking this down. If you hit a variation of this error with a different column name (like _customerid_value or _regardingobjectid_value), the same fix applies — the column type is still polymorphic, just a different lookup.

Also, you may like:

• Fix: Power Apps JSON Cannot Serialize Attachments Error
• Get Current Screen Name in Power Apps
• Parse JSON in Power Apps
• Iterate Over a JSON Object in TypeScript
• Convert TypeScript Objects to JSON [5 Practical Methods]

FAQ