Microsoft Power Automate (Microsoft Flow)

Back in 2021, I wrote a popular article showing how to batch create items in SharePoint using Power Automate. Since then, the chunk() expression has been introduced which makes batching far simpler.

In this post, I will show you how it works on a CSV file of 15,000 rows.

This method is:

• Faster
• Simpler – no variables or complex expressions.
• More efficient – Has fewer steps and less API actions.

Example Data

The CSV file used in the example, which you can download here, looks like this:

Customer,Invoice Number,Invoice Amount
Skibox,1,3051.83
Jabberstorm,2,4121.73
Yoveo,3,355.97
BlogXS,4,1606.71
Fanoodle,5,1680.15

New Method

The new method is similar to the one in the previous blog post, but makes use of the new chunk() expression. This function enabled the removal of the variable controlled loop and complex expressions.

Here is a visual overview of the flow, as you can see, it is quite simple:

SharePoint Setup

If you want to follow along with the sample data, setup a SharePoint List with the following fields:

• Customer – Single Line of Text.
• InvNum – Number – No Decimal Places.
• InvoiceAmount – Number – Two Decimal Places.

How the flow works

Settings (Parse JSON)

A single place to configure the settings for the flow:

• Tenant URL, Site Path and List Name
• Batch Size
• oData Level

You will need to edit the contents of this action to configure it for your environment.

Get File Content and GenerateSPData

Here the content from the CSV file is loaded and then used as the input to the GenerateSPData, which is a select action. I used an expression to trim the contents of the CSV and then split it on a new line character.

The select then gets each field from the CSV and generates a clean array of objects which exactly match SharePoint internal column names.

This is the step where you will reshape your own data to fit with your columns.

Batch Request Template (Compose)

Prepares a single changeset POST template with a |RowData| placeholder:

/POST /{sitePath}/_api/web/lists/getByTitle('{listName}')/items
Content-Type: application/json;odata={oDataLevel}
Prefer: return=minimal

|RowData|

This keeps the HTTP boilerplate out of the loop logic.

Chunking & per-batch preparation (For each batch)

The chunk() expression splits the transformed items into arrays of size batchSize.

PrepBatch (another Select) replaces |RowData| with the stringified item for each row, yielding a list of POST parts ready for the changeset.

Send to SharePoint ($batch)

Posts a single multipart/mixed request to /_api/$batch containing one changeset with all the item creates for that chunk. This minimizes API calls and is much faster than per-item requests.

Why this method is superior to the previous version

• Greatly Simplified – The loop control has been removed completely which allowed the removal of several complex expressions.
• No Variables – Everything is expressed as direct transformations in Select, which makes the flow easier to maintain.
• Smaller Payload – The payload size has been slightly reduced which should result in slightly improved performance.

Note on CSV parsing

This example uses basic string splitting. If your CSV includes quoted fields, embedded commas, or newlines, swapping this step for My CSV parser keeps the exact same downstream mapping pattern, but with resilient parsing for more complex CSV files.

Choosing the Right Batch Size

It can be tempting to set the batch size to 1,000 items in order to minimise the number of API calls. In practice, this usually causes more problems than it solves:

• Payload size limits – Large batches can quickly exceed SharePoint’s maximum payload size for the $batch endpoint, especially if your list items contain multiple columns or large text fields.
• Debugging difficulty – When something goes wrong, isolating the error in a 1,000-item batch is far harder than in a smaller, more manageable batch.

From experience, I’ve found that 250 items per batch strikes the right balance:

• It delivers nearly all of the performance benefit compared to much larger batches.
• It keeps requests lightweight, reliable, and easier to troubleshoot.

If your payload is very simple (e.g., only a few fields of plain text or numbers), you might safely increase the batch size to around 500. But going beyond that provides diminishing returns while increasing the risk of hitting limits.

An Even Easier Way with PowerTools

Everything shown above can be built natively in Power Automate, but if you want to make it even simpler, Power Tools for Power Automate lets you do the same job in a single action.

Instead of creating a scope with multiple steps, you can:

• Drop in the PowerTools Batch Create SharePoint Items action.
• Point it at your target site and list.
• Supply your array of data (for example, rows parsed from a CSV file).

That’s it — PowerTools automatically handles the batching, chunking, and API calls behind the scenes.

This makes your flows cleaner, faster to build, and easier to maintain, while still giving you the same performance and reliability.

The entire flow above, including parsing the CSV becomes as simple as this:

In addition to the batching actions, Power Tools offers many actions that make building flows faster and easier. Check out the full list of capabilities here.

Flow Code

Because there are no variable in this flow, you can copy the code below and paste it into your own flow. You’ll then have a completely functional flow which only needs the settings and connections updated.

Important Note: You will not be able to paste this scope into the new designer. You will need to go into the classic designer:

• Copy the code below into your clipboard.
• Add a new action in the classic desginer.
• Click on My Clipboard
• Press CTRL-V
• Click on the Scope named Create SharePoint Items
• Modify the settings as per your own environment.

{
    "id": "29ab039d-eccc-4442-a7bd-b8853228a457",
    "brandColor": "#8C3900",
    "connectionReferences": {
        "shared_powertools-5fc8929d8f1923503b-5f2f2ee6f39ab8efad": {
            "connection": {
                "id": "/providers/Microsoft.PowerApps/apis/shared_powertools-5fc8929d8f1923503b-5f2f2ee6f39ab8efad/connections/shared-powertools-5f-c52fe3e7-1ac2-4f14-be7e-87b210125878"
            }
        },
        "shared_onedriveforbusiness": {
            "connection": {
                "id": "/providers/Microsoft.PowerApps/apis/shared_onedriveforbusiness/connections/b728329fd30647b4ab6ade7e3a033f2e"
            }
        },
        "shared_sharepointonline": {
            "connection": {
                "id": "/providers/Microsoft.PowerApps/apis/shared_sharepointonline/connections/dd614c719a574e8788a7d3de1dc00b7b"
            }
        }
    },
    "connectorDisplayName": "Control",
    "icon": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZlcnNpb249IjEuMSIgdmlld0JveD0iMCAwIDMyIDMyIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPg0KIDxwYXRoIGQ9Im0wIDBoMzJ2MzJoLTMyeiIgZmlsbD0iIzhDMzkwMCIvPg0KIDxwYXRoIGQ9Im04IDEwaDE2djEyaC0xNnptMTUgMTF2LTEwaC0xNHYxMHptLTItOHY2aC0xMHYtNnptLTEgNXYtNGgtOHY0eiIgZmlsbD0iI2ZmZiIvPg0KPC9zdmc+DQo=",
    "isTrigger": false,
    "operationName": "Create_SharePoint_Items",
    "operationDefinition": {
        "type": "Scope",
        "actions": {
            "batchTemplate": {
                "type": "Compose",
                "inputs": "--changeset_c1\nContent-Type: application/http\nContent-Transfer-Encoding: binary\n\nPOST /@{body('Settings')?['sitePath']}/_api/web/lists/getByTitle('@{body('Settings')?['listName']}')/items HTTP/1.1\nContent-Type: application/json;odata=@{body('Settings')?['oDataLevel']}\nPrefer: return=minimal\n\n|RowData|\n",
                "runAfter": {
                    "GenerateSPData": [
                        "Succeeded"
                    ]
                },
                "metadata": {
                    "operationMetadataId": "7510be95-4ad3-4c3b-8d0f-8ce2ea5fe270"
                }
            },
            "Settings": {
                "type": "ParseJson",
                "inputs": {
                    "content": {
                        "tenantBaseUrl": "accendo1.sharepoint.com",
                        "sitePath": "sites/PowerAutomateText",
                        "listName": "Invoices Development Test",
                        "batchSize": 350,
                        "oDataLevel": "nometadata"
                    },
                    "schema": {
                        "type": "object",
                        "properties": {
                            "tenantBaseUrl": {
                                "type": "string",
                                "title": "Base URL of SharePoint Site",
                                "description": "Base URL of SharePoint Site"
                            },
                            "sitePath": {
                                "type": "string",
                                "title": "Relative path of the site"
                            },
                            "listName": {
                                "type": "string",
                                "title": "Sharepoint List",
                                "description": "List where items are to be batch created"
                            },
                            "batchSize": {
                                "type": "integer",
                                "title": "Batch Size",
                                "description": "Number of items to send in a single batch"
                            },
                            "oDataLevel": {
                                "type": "string",
                                "title": "oData Level",
                                "description": "verbose, minimalmetadata or nometadata"
                            }
                        }
                    }
                },
                "runAfter": {},
                "trackedProperties": {
                    "meta": {
                        "type": "SP.Data.@{outputs('settings')?['listName']}ListItem"
                    },
                    "batchGUID": "@{guid()}",
                    "changeSetGUID": "@{guid()}"
                },
                "metadata": {
                    "operationMetadataId": "e2c45d0b-2dd7-458c-af66-4aaba453a85c"
                }
            },
            "Each_Batch": {
                "type": "Foreach",
                "foreach": "@chunk(body('GenerateSPData'), body('Settings')?['batchSize'])",
                "actions": {
                    "PrepBatch": {
                        "type": "Select",
                        "inputs": {
                            "from": "@items('Each_Batch')",
                            "select": "@replace(outputs('batchTemplate'), '|RowData|', string(item()))"
                        },
                        "runAfter": {},
                        "metadata": {
                            "operationMetadataId": "0f90539a-b12a-4080-af7b-f54a5562333a"
                        }
                    },
                    "sendBatch": {
                        "type": "ApiConnection",
                        "inputs": {
                            "host": {
                                "connection": {
                                    "name": "@json(decodeBase64(triggerOutputs().headers['X-MS-APIM-Tokens']))['$connections']['shared_sharepointonline']['connectionId']"
                                }
                            },
                            "method": "post",
                            "body": {
                                "method": "POST",
                                "uri": "/_api/$batch",
                                "headers": {
                                    "X-RequestDigest": "digest",
                                    "Content-Type": "multipart/mixed;boundary=batch_b1"
                                },
                                "body": "--batch_b1\nContent-Type: multipart/mixed; boundary=\"changeset_c1\"\nContent-Transfer-Encoding: binary\n\n@{join(body('PrepBatch'), decodeUriComponent('%0A'))}\n--changeset_c1--\n\n--batch_b1--"
                            },
                            "path": "/datasets/@{encodeURIComponent(encodeURIComponent('https://',body('Settings')?['tenantBaseUrl'],'/',body('Settings')?['sitePath'],'/'))}/httprequest",
                            "authentication": {
                                "type": "Raw",
                                "value": "@json(decodeBase64(triggerOutputs().headers['X-MS-APIM-Tokens']))['$ConnectionKey']"
                            }
                        },
                        "runAfter": {
                            "PrepBatch": [
                                "Succeeded"
                            ]
                        },
                        "metadata": {
                            "operationMetadataId": "cd8e1c16-ce3f-4626-96f6-74175878a718",
                            "flowSystemMetadata": {
                                "swaggerOperationId": "HttpRequest"
                            }
                        }
                    },
                    "Result": {
                        "type": "Compose",
                        "inputs": "@base64ToString(body('sendBatch')['$content'])",
                        "runAfter": {
                            "sendBatch": [
                                "Succeeded"
                            ]
                        },
                        "metadata": {
                            "operationMetadataId": "d3eab115-bee1-4d3f-ae84-5573cde48b04"
                        }
                    }
                },
                "runAfter": {
                    "batchTemplate": [
                        "Succeeded"
                    ]
                },
                "metadata": {
                    "operationMetadataId": "4e0e72da-48b8-40b9-a824-d948006e98a8"
                }
            },
            "GenerateSPData": {
                "type": "Select",
                "inputs": {
                    "from": "@take(skip(split(trim(body('Get_file_content')), decodeUriComponent(decodeUriComponent('%0A'))),1),100)",
                    "select": {
                        "Customer": "@split(item(), ',')[0]",
                        "InvNum": "@int(split(item(), ',')[1])",
                        "InvoiceAmount": "@split(item(), ',')[2]"
                    }
                },
                "runAfter": {
                    "Get_file_content": [
                        "Succeeded"
                    ]
                },
                "metadata": {
                    "operationMetadataId": "7f2df4b2-3704-4b7e-9be4-25baf2e005ac"
                }
            },
            "Get_file_content": {
                "type": "ApiConnection",
                "inputs": {
                    "host": {
                        "connection": {
                            "name": "@json(decodeBase64(triggerOutputs().headers['X-MS-APIM-Tokens']))['$connections']['shared_onedriveforbusiness']['connectionId']"
                        }
                    },
                    "method": "get",
                    "path": "/datasets/default/files/@{encodeURIComponent(encodeURIComponent('b!Xm9bgFp6o0yRZXE2CnS2bsRojWZetglOshpzrfOcZOZ3RtFM3COMT4fTC4d_A2tk.01CM5RGF6C5YHGIXWZERCLCOADO5MDURKV'))}/content",
                    "queries": {
                        "inferContentType": true
                    },
                    "authentication": {
                        "type": "Raw",
                        "value": "@json(decodeBase64(triggerOutputs().headers['X-MS-APIM-Tokens']))['$ConnectionKey']"
                    }
                },
                "runAfter": {
                    "Settings": [
                        "Succeeded"
                    ]
                },
                "metadata": {
                    "b!Xm9bgFp6o0yRZXE2CnS2bsRojWZetglOshpzrfOcZOZ3RtFM3COMT4fTC4d_A2tk.01CM5RGF6C5YHGIXWZERCLCOADO5MDURKV": "/ExcelMockData.txt",
                    "operationMetadataId": "ea8fd25e-7432-407a-98af-90cde9f799fc",
                    "flowSystemMetadata": {
                        "swaggerOperationId": "GetFileContent"
                    }
                }
            }
        },
        "runAfter": {},
        "metadata": {
            "operationMetadataId": "301650a5-14dd-4a16-9a19-514c36f2b009"
        }
    }
}

Conclusion

This new approach makes batch-creating SharePoint list items in Power Automate much faster, cleaner, and easier to maintain. By using the chunk() function and the Select action to shape your data directly, you avoid variables, reduce complexity, and cut down on unnecessary API calls.

Even with large files, the flow stays reliable and efficient. With the right batch size (I recommend around 250), you get nearly all the performance benefits while avoiding the risks of oversized requests.

If you built flows using my original 2021 method, I encourage you to give this new approach a try, you’ll find it dramatically simpler.

If you want the very easiest, maker friendly method of SharePoint Batching, Power Tools for Power Automate is the way to go.

Zip File Support in Power Automate is fairly limited. There are actions to extract files from an archive, but no support for creating your own zip files.

I’ve written before about a method to create Zip files in Power Automate for free using SharePoint.

The SharePoint method described worked, but did not provide any file compression, only stored the requested files. If you need compression, the only option until now, is to use a 3rd party connector but that generally means paying a monthly fee and data leaving your environment.

In this post I will demonstrate a new method for working with Zip Files which uses a custom C# connector, to easily create Zip files in Power Automate or extract files from them.

The key features are:

• You will not have to pay any monthly subscription to an API service.
• The data will not leave your Office 365 environment.
• You can create Zip Files easily.
• You can extract data from Zip files without having to extract the contents to OneDrive or SharePoint first

N.B. Custom connectors require a Power Automate Premium License. So, if you do not have one, this solution is not for you.

Introduction to the Zip Connector

Here is a screenshot of the available actions:

Summary of the actions available:

• Create a Zip File – Will accept an array of files and return a Zip File.
• Extract Zip File Content – Will return an array which contains all the files in the source Zip File (subject to some limitations).
• Extracts a file stored in a Zip Archive – This action extracts a single file from a Zip archive given its path within the Zip.
• List files stored in a Zip Archive – This action returns the list of files contained in the Zip file without the File Content.

Creating a Zip File

Here is the most simple example of the Create a Zip File action in a flow:

The action accepts two Parameters:

• The list of files to be compressed.
• The compression level to apply to the files.

The list of files to be compressed can be manually populated as shown above or provided with a JSON array by clicking on the button to switch to Input Entire Array mode:

This should be an array of objects containing values for Name and Content, like this:

[
  {
    "Name": "Text File.txt",
    "Content": "VGhpcyBpcyBhIHRlc3QgZmlsZQ=="
  },
  {
    "Name": "Text File 2.txt",
    "Content": "VGhpcyBpcyB0aGUgc2Vjb25kIHRlc3QgZmlsZQ=="
  },  
]

The file content is a Base64 representation of the file. I will provide more detail on this in the sample flows below.

Compression level has four options:

• Optimal – Which provides the best balance between compression and the speed of the operation.
• Smallest – Produces the smallest possible Zip file but takes longer to complete.
• Fastest – Provides the fastest operation but the resulting Zip file will be slightly larger.

Optimal would be the best option in most cases.

The output of the action is a base64 representation of the Zip file, which can be used in subsequent actions to save the Zip file or send in an email etc.

Simple Power Automate Flow to Zip a Single File

Below is a screenshot of the simplest example of how this action can be used:

The flow has three actions:

• Get file content, which provides the input for the Zip action.
• The Create a Zip file action which zips the input.
• The create file action which takes the output from the zip action to create the file.

Example Flow to Zip many files

Take a look at the flow below and the explanation that follows:

Step by step explanation

First, use the Initialize Variable to hold the file content of the files that we want to zip.

Next use the Get Files (properties only) action to get a list of files that we want to Zip. I selected the option to Include nested items and added an odata filter of FSObjType eq 0 to return file objects and not folders.

Next add Get file content using path and supply the file path from the dynamic output of the Get Files action. This will automatically create an apply to each loop.

Next add an Append to array variable action. Supply JSON in the format of:

{
  "Name": "",
  "Content": ""
}

For the Name – you can use the dynamic content from the Get Files action. You can also supply the Folder path as per my screenshot if you want the Zip file to retain the paths.

For the content use the output of the Get file content using path action.

Next, outside of the apply to each loop, you can supply the array variable to the Create a Zip file action. Don’t forget to switch the action to entire array mode!

In the final action, I am simply creating a file using the Create File action, using the output from the Zip action. But you could easily change that to a Send an Email action or whatever suits your need.

Example Result

I zipped a SharePoint folder containing 87 files that totalled 55 Megabytes, this resulted in a Zip file of 11 Megabytes.

Password and Encryption Support

The libraries required to create a Zip file with password protection are simply not available in the custom code tool in Power Platform. If you need to create Zip files with Password and Encryption Support I would recommend using Flowr from Encodian.

Working with Existing Zip Archives

Power Automate has two actions for working with Zip Files:

Both of these actions work in a similar way, you specify a source Zip file, a destination folder and it will extract the files for you:

The output from this action is a JSON array of file information which you can then work with to get the file contents, here is some example output:

[
  {
	"Id": "b!Xm9bgFp6o0yRZXE2CnS2bsR4d_A2tk.01CM5RGF5GTCVBUQWV6VGJWZGNKHZ3O3BC",
	"Name": "2k-Rows.csv",
	"NameNoExt": "2k-Rows",
	"DisplayName": "2k-Rows.csv",
	"Path": "/drives/b!Xm9bgFp64d_A2tk/root:/_zip/ZipExtract/Shared Documents/Zip Test/CSV Files/2k-Rows.csv",
	"LastModified": "2024-06-27T07:35:40Z",
	"Size": 140421,
	"MediaType": "text/csv",
	"IsFolder": false,
	"ETag": ""{1AAA98A6-D542-4CF5-9B64-CD51F3B76C22},2"",
	"FileLocator": "b!Xm9bgFp6o0yRZXE2CnS2bsRojWZetglOshpzGJWZGNKHZ3O3BC",
	"LastModifiedBy": "Paul Murana"
  }
]

In many cases the above actions are perfectly adequate, but do require you to write the files out to a folder, and then read them back in again if you want to use the file content in the flow.

The actions included in this connector work in a different way. Instead of extracting the Zip Archive contents to a folder the content of each file in the Zip Archive is returned to the flow for direct use. This makes for a much cleaner flow.

There are three actions for working with Zip archives:

Extract Zip File Content

This action will extract the entire contents of the provided Zip File and return a JSON array of file information and the file content:

Here is a sample of the output:

• All Files Extracted – This informs you that all files were extracted from the archive. This will return false of either the entire size of the output generated would be over 100MB or a single file within the archive is over 100MB.
• File Count – The number of files extracted.
• Files – An array which contains the File information and file data:
  • Filepath – The path of the file within the Zip File.
  • FilenameWithExtension – Just the Filename without the path.
  • FolderPath – The path of the file within the Zip without the File name.
  • FileContent – The base64 representation of the File.

The files array can be used in any action that can handle arrays, such as an apply to each loop, a select action or a filter array action.

List files stored in a Zip Archive

This action is the same as the Extract Zip File Content action except it does not return the file content. This is designed so that you can examine the content of the Zip file and then extract specific files with the Extract File action. Example response:

[
  {
    "Filepath": "test file.txt",
    "FilenameWithExtension": "test file.txt",
    "FolderPath": "",
    "FileSize": 14,
    "OverSizeLimit": false
  }
]

The output includes an additional property called OverSizeLimit, if the file within the archive is over 100MB this will be true and you will be unable to extract it as it will be over the maximum size of an action that Power Automate allows.

The array of output can be filtered so that you can extract only the files you want to access. You can then use the Extract File action on each file you want to extract.

Extract a file stored in a Zip Archive

Once you have used the List Files action to list the contents of a Zip File, you can then use this action to extract each file from the archive:

The output array of the List Files action can be used as the input for an Apply to each loop and then each file can be extracted from the Zip. Note how the Zip File Content content is the same for both actions.

Limitations

Power Platform Custom Connectors are limited to an execution time of five seconds. This means that if you supply the connector with too much data it will fail.

The connector also returns an additional header of x-processingtime which tells you how long the operation took to process, you can see this in the raw outputs or with an expression:

outputs('Create_a_Zip_file')?['headers']?['x-processingtime']

This will tell you how many milliseconds the operation took, the maximum allowed being 5,000.

Purchase this connector

If you would like to use this connector in your own environment, you can purchase it from Gumroad. You will receive an Zip file containing a solution which you can import into your environment which will make the custom connector available.

---

How to Import the connector

After you have purchased the connector from Gumroad, importing it is easy:

• Go to https://make.powerautomate.com/
• Select Solutions from the left hand menu:
  
• Click on Import solution from the top menu:
  
• Click on the browse button and upload the Zip solution file.
• Click Next.
• Click on Import.
• The solution will now import. This normally takes a few minutes. Then the action will be available in your flows under the custom tab:
  

Conclusion

This connector provides a really neat way to add Zip functionality to your flows. Crucially your data does not leave your environment and uses only tools already built into your environment.

You will not have to pay a monthly fee to produce Zip files, just a simple one time purchase:

Please let me know in the comments how you get on and if you have any feedback.

When using the SharePoint Update Item action in Microsoft Power Automate it forces you to enter values for mandatory columns. For lists with many columns this can be a long process if you only want to update a few fields. Example:

This list item contains a number of fields:

Field Name	Type	Mandatory
Name	Single Line of Text	Yes
Department	Single Line of Text	Yes
Gender	Choice	No
Marital Status	Choice	No
Status	Multiple Selection Choice	No
Homepage	Hyperlink or Picture	No

If you want to be able to update one or more of those fields without supplying the information for every field, there is an easy way to do it.

The Update Item Trick

The update item action helpfully retrieves the column information from SharePoint for us to give us the fields to fill in. Most of the time, this is what we want. But here is how to force it so that it cannot do that.

Simply Create a Compose action and type the name of your list into it. Then create an Update Item action, choose your SharePoint site as normal, but for the list name choose Enter Custom Value and from the dynamic content panel choose the output of your compose action:

Now your Update Item action will not suggest any columns at all and you must supply this information manually:

Updating the SharePoint List Item

Our example list has a bunch of different column types and they are all updated in a slightly different way. So I will give examples of how to update each type, and then update multiple fields in a single request.

Single Line of Text

The single line of text field is the easiest to update. Simply supply the field name and the new value, like this:

{
  "Title": "Paulie"
}

Hyperlink

With the hyperlink we need to first supply the field name, and then the URL and description.

{
  "homepage": {
    "Url": "http://tachytelic.net",
    "Description": "somesite"
  }
}

Single Choice Column

The single choice column can only take a single value. So, only the field name and value are required.

{
  "Marital_x0020_Status": {
    "Value": "Common-Law"
  }
}

Multi Choice Column

The multi choice column must be supplied with an array of values, so an example would look like this:

{
  "Status": [
    {
      "Value": "Subscribed"
    },
    {
      "Value": "Liked"
    }
  ]
}

Updating Multiple Columns

If you want to update multiple values, you can easily combine the examples above, like this:

{
	"Title": "Paulie",
	"homepage": {
		"Url": "http://tachytelic.net",
		"Description": "somesite"
	},
	"Marital_x0020_Status": {
		"Value": "Common-Law"
	},
	"Status": [{
			"Value": "Subscribed"
		},
		{
			"Value": "Liked"
		}
	]
}

Conclusion

So, as you can see from the above, by supplying the JSON directly to the Update Item action, you can easily update columns without having to supply the information for every other column again.

Hope this helps.