Fix: Power Apps JSON Cannot Serialize Attachments Error (Table(Attachment)) — 2 Solutions

If you’ve been building a Power Apps canvas app connected to a SharePoint list or Dataverse table and hit this error:

“The JSON function cannot serialize tables / objects with a nested property called ‘{Attachments}’ of type ‘Table(Attachment)'”

You’re in the right place. I’ve run into this exact error myself while trying to extract column names from a SharePoint list using the JSON() function. The fix is simple, but the why behind it is worth understanding so you don’t get surprised again.

Let me walk you through the root cause, the fix, and a few real-world scenarios where this pops up.

What Causes This Error?

The JSON() function in Power Apps converts a data structure — a collection, record, or table — into a JSON text string. It’s useful for tasks such as sending data to Power Automate, extracting column names, or logging app state.

Here’s the basic syntax:

JSON(DataStructure [, Format])

The Format parameter controls how the function handles different data types. By default (JSONFormat.Compact), it blocks binary data and unsupported column types — and throws an error if it runs into either.

Now, here’s the thing about SharePoint lists: every SharePoint list has an Attachments column built in, even if you never use it. This column is stored as a Table(Attachment) type — a nested table inside your list record. That’s not a binary value (like an image or video), so JSONFormat.IgnoreBinaryData alone doesn’t catch it. The JSON() function hits that nested table, doesn’t know what to do with it, and throws the error.

In short: IgnoreBinaryData handles media files. IgnoreUnsupportedTypes handles everything else that JSON can’t serialize — including nested table columns like Attachments.

The Fix: Power Apps JSON Cannot Serialize Attachments Error (Table(Attachment))

Combine JSONFormat Flags with the & Operator

The solution is to add JSONFormat.IgnoreUnsupportedTypes to your formula. You can combine multiple JSONFormat flags using the & operator.

Here’s the corrected formula:

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

That’s it. The IgnoreUnsupportedTypes flag tells Power Apps: “If you hit a data type you can’t serialize, just skip it — don’t throw an error.”

⚠️ Important warning: IgnoreUnsupportedTypes silently drops those unsupported fields from your output. So if your downstream logic (a Power Automate flow, for example) is expecting an Attachments field in the JSON, it won’t be there. You won’t get an error — you’ll just get missing data. Always check your JSON output after applying this fix.

Scenario 1: Extracting Column Names from a SharePoint List

This is the scenario I hit personally. I had an Employee Onboarding SharePoint list with columns like Employee Name, Employee Last Name, Employee ID, and so on. I wanted to dynamically grab all column names in Power Apps.

Step 1: Create a Power Apps Collection from your SharePoint list on a button’s OnSelect property:

ClearCollect(
    colEmpOnboardingDetails,
    'Employee Onboarding'
);

Where:

• colEmpOnboardingDetails = your collection name
• 'Employee Onboarding' = your SharePoint list name

Step 2: Use the JSON() function to extract column names:

Set(
    varListColumnNames,
    Distinct(
        Ungroup(
            MatchAll(
                JSON(colEmpOnboardingDetails, JSONFormat.IgnoreBinaryData),
                "([""][^""]+[""])\s*:"
            ).SubMatches,
            "SubMatches"
        ),
        Value
    )
)

The JSON function cannot serialize tables / objects with a nested property called '{Attachments}' of type 'Table (Attachment)'.

This is where the error hits, because the JSON() function encounters the Attachments column of type Table(Attachment).

Step 3: Apply the fix by adding JSONFormat.IgnoreUnsupportedTypes:

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

Save, publish, and test your app — the error is gone, and you get your column names back cleanly.

Scenario 2: Sending a SharePoint Collection to Power Automate as JSON

Another very common place this error shows up is when you’re passing a collection to a Power Automate flow. You might have something like this on a Power Apps button:

PowerAutomateFlow.Run(
    JSON(colMySharePointData, JSONFormat.IgnoreBinaryData)
)

Here, inplace of colMySharePointData, provide your collection name that contains SharePoint list data.

If the SharePoint list behind that collection has Attachments enabled (which almost all do by default), you’ll get the same serialization error.

The JSON function cannot serialize tables / objects with a nested property called '{Attachments}' of type 'Table (Attachment)'.

The fix is identical — just add the second flag:

ClearCollect(
    colLeaveRequests,'Employee Leave Requests'
);

LeaveRequestsPARSING.Run(JSON(colLeaveRequests,JSONFormat.IncludeBinaryData& JSONFormat.IgnoreUnsupportedTypes))

One thing to keep in mind here: if you’re sending this JSON to a flow that parses the payload with a Parse JSON action, regenerate the schema after applying the fix. The Attachments field will no longer appear in your output, which can break schema validation downstream.

Scenario 3: Dataverse Tables with Polymorphic or Complex Columns

This error doesn’t just happen with SharePoint. If you’re working with a Dataverse table that contains polymorphic lookup columns (like an Owner field, which can point to either a User or a Team), you’ll see a similar error:

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

The fix is the same approach. When you call JSON() on a Dataverse collection, use:

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

Dataverse tables tend to have more of these unsupported column types — Owner, Regarding (polymorphic lookups), Activity Party columns — so this combination of flags is practically standard when working with Dataverse collections.

All JSONFormat Flags and What They Do

Since you’re already using the Format parameter, here’s a quick reference for all available JSONFormat enum values you can combine:

Flag	What It Does
JSONFormat.Compact	Default. No extra spaces or newlines. Blocks binary data and unsupported types.
JSONFormat.IndentFour	Adds newlines and 4-space indentation. Easier to read for debugging.
JSONFormat.IncludeBinaryData	Includes image, video, and audio columns in the output.
JSONFormat.IgnoreBinaryData	Skips image, video, and audio columns without erroring.
JSONFormat.IgnoreUnsupportedTypes	Skips unsupported data types (like nested tables) without erroring.
JSONFormat.FlattenValueTables	Flattens Power Fx Value tables into standard JSON arrays.

You can combine any of these with &. For example, if you also want a readable output while debugging:

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

When Should You NOT Use IgnoreUnsupportedTypes?

This flag is great for scenarios where you only care about the supported fields — like extracting column names, logging, or passing simple data to a flow.

But avoid it if:

• Your flow or API needs the Attachments data. The flag silently drops those fields — you won’t get an error, but the data will be missing.
• You’re generating a JSON payload for a strict schema. Missing fields can break schema validation in Power Automate’s Parse JSON action or an external API.
• You’re trying to back up or migrate record data. Silent data loss in that context is a real problem.

In those cases, you’ll need a different approach — like handling attachments separately using EncodeUrl() or passing attachment metadata through a dedicated flow action instead of serializing it with JSON().

Quick Summary of the Fix

If you’re in a hurry, here’s everything in three lines:

• Root cause: SharePoint’s built-in Attachments column is stored as Table(Attachment) — a nested table type that JSON() can’t serialize by default
• Why IgnoreBinaryData alone doesn’t work: That flag only handles media files (images, videos, audio), not nested table columns
• The fix: Add JSONFormat.IgnoreUnsupportedTypes using the & operator → JSON(yourCollection, JSONFormat.IgnoreBinaryData & JSONFormat.IgnoreUnsupportedTypes)

Also, you may like:

• Show a Different Home Screen Per User in Power Apps
• Power Apps JSON Polymorphic Error on _ownerid_value
• Parse JSON in Power Apps
• Power Apps CountRows Function
• Power Apps Dropdown Show Only Unique Values

Frequently Asked Questions