Azure Data Factory external call POST request body empty

Question

Azure Data Factory external call POST request body empty

TDay 0

In Azure Data Factory I am using the "External Call" action to generate a POST request to an external API:

ContactColumns call(mapColumn(
		firstname,
		lastname
	),
	skipDuplicateMapInputs: true,
	skipDuplicateMapOutputs: true,
	output(
		headers as [string,string],
		status as string
	),
	allowSchemaDrift: true,
	format: 'rest',
	store: 'restservice',
	timeout: 30,
	requestInterval: 0,
	httpMethod: 'POST',
	headerColumnName: 'headers',
	bodyColumnName: 'body',
	statusColumnName: 'status',
	addResponseCode: true,
	requestFormat: ['type' -> 'json'],
	responseFormat: ['type' -> 'json', 'documentForm' -> 'documentPerLine'])

I have temporarily used a Postman mock server as the API endpoint for debugging.

When I try to preview the output data and select 'Copy request payload' - this is what ADF says has been requested of the API endpoint:

Uri: https://<redacted>.mock.pstmn.io

Method: POST

Headers: content-type: application/json | accept: application/json

Body: {"firstname":"TEST1","lastname":"tester1"}

This is what postman receives:

Headers:

x-forwarded-for``: "xxxxxxxxx"

x-forwarded-proto``: "xxxxxxxxx"

x-forwarded-port``: "xxxxxxxxx"

host``: "<redacted>.mock.pstmn.io"

x-amzn-trace-id``: "Root=<redacted>"

content-length``: "42"

content-type``: "application/json"

accept``: "application/json"

user-agent``: "azure-data-factory/2.0"

content-encoding``: "UTF-8"

accept-encoding``: "gzip,deflate"

Body:

{} NOTE ISSUE: this should not be blank

Error message: Request body has invalid format.

See image: User's image

The postman response is consistent with the issue I receive when using my real API endpoint (a logic app). I can't find any information online about this issue, so any help would be very gratefully received!

1 answer

Your answer

Answer 1

Venkat Reddy Navari 1,585 Microsoft External Staff

Hi @TDay You're correct — the runtime body {} should not be blank.

This happens because in Azure Data Factory (ADF) External Call, even though the "Copy request payload" shows the correct JSON (with firstname and lastname), at runtime ADF expects a body field to be explicitly mapped. If you don't map the body, ADF sends {} — an empty body — by default.

In your External Call configuration, you need to build the body field manually, for
Example:

body => toJson({
    "firstname": firstname,
    "lastname": lastname
})

Make sure your External Call activity is configured with:

Request Body Column Name = body
Request Format = JSON

Once mapped correctly, ADF will send the full JSON object at runtime instead of {}.

It's understandable this was confusing — ADF's preview shows what would be sent if mappings were complete, but it doesn't warn if runtime mappings are missing.

Hope this helps. Do let us know if you any further queries.

If this answers your query, do click Accept Answer and Yes for was this answer helpful. And, if you have any further query do let us know.

TDay 0 Reputation points

2025-04-28T13:24:46.7933333+00:00

Hi @Venkat Reddy Navari - thank you for getting back to me so soon.

Please could you point me to the ADF documentation where it specifies how to build the body field, and where to configure the body column name? I can't see where to do that in the UI and couldn't find any relevant documentation.

Also, when I try and use toJson as a function when deriving a column, I get an error that this is an unknown function:

If you could please let me know where I could find an example, or provide me with a complete code example for the external call, that would be really helpful!

Thank you!
TDay 0 Reputation points

2025-04-28T14:09:35.4366667+00:00
Hi @Venkat Reddy Navari

As a follow up, I temporarily just created a 'body' column with the first name in it, to see if that would be passed correctly:

ContactsToCreate call(mapColumn( body = {firstname} ), skipDuplicateMapInputs: false, skipDuplicateMapOutputs: false, output( headers as [string,string], status as string ), allowSchemaDrift: true, format: 'rest', store: 'restservice', timeout: 30, requestInterval: 0, httpMethod: 'POST', headerColumnName: 'headers', bodyColumnName: 'body', statusColumnName: 'status', addResponseCode: true, requestFormat: ['type' -> 'json'], responseFormat: ['type' -> 'json', 'documentForm' -> 'documentPerLine'])

ADF now says the request payload was:

Uri: https://<redacted>.mock.pstmn.io

Method: POST

Headers: content-type: application/json | accept: application/json

Body: {"body":"Test"}

But postman still says the request payload received is {}.

Interestingly, the content-length in the header received into Postman is 15:

content-length``: "15"
Which is the number of characters in "{"body":"test"}

If I change the body to be {"body":"Tribute 1"} in ADF, the content-length header received correctly updates to 21 in postman. This suggests that ADF knows what data it should be sending, but isn't sending it?

Thanks again for your help

Venkat Reddy Navari 1,585 Microsoft External Staff

@TDay Let’s address each of your points carefully:

Missing Documentation

You are correct — currently Azure Data Factory (ADF) does not have complete official documentation explaining how the External Call activity handles the request body mapping, especially when using dynamic content.

Most of this behavior has been learned through internal testing and community experience.

Why toJson() Does Not Work

toJson() is a function available inside Mapping Data Flows, but it is not available in the External Call activity mappings. External Call only supports basic expressions like concat(), string(), and basic functions.

That's why you received the "unknown function" error when trying to use toJson().

Why You Still Get {} Even After Mapping body

Even though you manually created a body field (e.g., with {firstname}), ADF still wraps your body under additional internal structures unless you configure it properly.

The content-length you observed changing confirms that ADF knows your payload size, but because the requestFormat is set to json, it tries to serialize the structure again — resulting in {} being sent.

To fix this, you must:

Manually compose the body using concat() into a valid JSON string.

Set the requestFormat to "Expression", not "Json".

This way, ADF sends your string as-is, without any additional wrapping.

Here is a complete ADF pipeline you can deploy:


{
    "name": "ExternalCallTestPipeline",
    "properties": {
        "activities": [
            {
                "name": "ExternalCall_PostRequest",
                "type": "ExecuteExternalCall",
                "dependsOn": [],
                "policy": {
                    "timeout": "7.00:00:00",
                    "retry": 0,
                    "retryIntervalInSeconds": 30,
                    "secureOutput": false,
                    "secureInput": false
                },
                "userProperties": [],
                "typeProperties": {
                    "request": {
                        "httpMethod": "POST",
                        "url": "https://<your-mockserver-or-api-url>",
                        "requestFormat": "Expression",
                        "headerColumnName": "headers",
                        "bodyColumnName": "body",
                        "statusColumnName": "status",
                        "timeout": 30,
                        "requestInterval": 0,
                        "addResponseCode": true
                    },
                    "response": {
                        "responseFormat": "json",
                        "documentForm": "documentPerLine"
                    },
                    "mapping": {
                        "type": "TabularTranslator",
                        "mappings": [
                            {
                                "source": {
                                    "name": "firstname",
                                    "type": "String"
                                },
                                "sink": {
                                    "name": "firstname",
                                    "type": "String"
                                }
                            },
                            {
                                "source": {
                                    "name": "lastname",
                                    "type": "String"
                                },
                                "sink": {
                                    "name": "lastname",
                                    "type": "String"
                                }
                            },
                            {
                                "source": {
                                    "name": "body",
                                    "type": "String",
                                    "expression": "concat('{\"firstname\":\"', firstname, '\", \"lastname\":\"', lastname, '\"}')"
                                },
                                "sink": {
                                    "name": "body",
                                    "type": "String"
                                }
                            }
                        ],
                        "skipDuplicateMapInputs": false,
                        "skipDuplicateMapOutputs": false
                    }
                },
                "linkedServiceName": {
                    "referenceName": "RestServiceLinkedService",
                    "type": "LinkedServiceReference"
                }
            }
        ]
    }
}

Replace <your-mockserver-or-api-url> with your API endpoint (e.g., your Postman mock server).
Create a Linked Service of type REST called RestServiceLinkedService in your ADF.
Ensure the linked service Base URL matches your API base address.

Hope this helps. Do let us know if you any further queries.

If this answers your query, do click Accept Answer and Yes for was this answer helpful. And, if you have any further query do let us know.

TDay 0 Reputation points

2025-04-29T08:24:27.5066667+00:00
Hi @Venkat Reddy Navari

As a follow up, I temporarily just created a 'body' column with the first name in it, to see if that would be passed correctly:

ContactsToCreate call(mapColumn( body = {firstname} ), skipDuplicateMapInputs: false, skipDuplicateMapOutputs: false, output( headers as [string,string], status as string ), allowSchemaDrift: true, format: 'rest', store: 'restservice', timeout: 30, requestInterval: 0, httpMethod: 'POST', headerColumnName: 'headers', bodyColumnName: 'body', statusColumnName: 'status', addResponseCode: true, requestFormat: ['type' -> 'json'], responseFormat: ['type' -> 'json', 'documentForm' -> 'documentPerLine'])

ADF now says the request payload was:

Uri: https://<redacted>.mock.pstmn.io

Method: POST

Headers: content-type: application/json | accept: application/json

Body: {"body":"Test"}

But postman still says the request payload received is {}.

Interestingly, the content-length in the header received into Postman is 15:

content-length``: "15"
Which is the number of characters in "{"body":"test"}

If I change the body to be {"body":"Tribute 1"} in ADF, the content-length header received correctly updates to 21 in postman. This suggests that ADF knows what data it should be sending, but isn't sending it?

Thanks again for your help
TDay 0 Reputation points

2025-04-29T08:41:50.0166667+00:00

Hi @Venkat Reddy Navari

Thanks for your response again.

I am using Azure Data Factory v2 (2018-06-01). I have no option to create a pipeline activity of type "ExecuteExternalCall". When I copy that ADF JSON into a new pipeline, the activity created is not functional. It looks like a data flow, but I cannot assign it any settings or pass parameters (see image)

I thought perhaps that could be the JSON for a data flow, but it is not in the correct format.

Is this a problem with my ADF version?
Venkat Reddy Navari 1,585 Reputation points Microsoft External Staff

2025-04-29T12:07:36.0133333+00:00
@TDay Thank you again for the detailed feedback and screenshots — very helpful in understanding your setup and challenge.

Clarifying the Issue: Why Your Payload Becomes {"body":"..."} Instead of Direct JSON

From your YAML, you’ve currently defined this:

body = {firstname}

This results in ADF wrapping the entire JSON body inside another body field — so ADF sends:

{"body":"Test"}

That’s why Postman shows {}, because your actual payload ("Test") is inside the key "body" — not a valid standalone JSON body unless the API explicitly expects that structure.

Solution: Send Proper JSON Body — Without Extra Wrapping

To fix this, you need to manually construct a full JSON string using concat() inside the body column, like this:

body = concat('{ "firstName": "', firstname, '" }')

This ensures ADF doesn't auto-wrap the payload in {"body": ...} — and sends exactly:

{ "firstName": "Test" }

Fixing the Activity Confusion in ADF UI Thanks for sharing your screenshot — and yes, you're right.

You're likely using the Mapping Data Flow External Call, not the pipeline-level "Web" or new ExecuteExternalCall (public preview or private features). If you pasted the full JSON I previously shared, and it appeared like a data flow box without options, that's due to pipeline version mismatch or UI limitation (ADF v2 without feature flags or region constraints).

What You Can Do: Use Mapping Data Flow’s External Call — keep your current data flow.

In your mapping step:

Add a derived column called body like this:

concat('{ "firstName": "', firstname, '" }')

bodyColumnName: "body"

requestFormat: ["type" -> "expression"] (not json)

httpMethod: "POST"

This will send a raw payload correctly.

Hope this helps. Do let us know if you any further queries.

If this answers your query, do click Accept Answer and Yes for was this answer helpful. And, if you have any further query do let us know.
TDay 0 Reputation points

2025-04-30T09:43:30.2166667+00:00
Hi @Venkat Reddy Navari

Thanks for your help again.

requestFormat: ["type" -> "expression"] (not json)

When I tried to set this field in the ADF code view:

Then pressed 'ok', and re-opened the code view it had gone:

I tried previewing this request anyway. Here is the request payload:

Uri: https://<mock server>.mock.pstmn.io

Method: POST

Headers: accept: application/json

Body: { "firstName": "TEST1" }

Here are the received headers:

x-forwarded-for``: "xxxxxxxxx"

x-forwarded-proto``: "xxxxxxxxx"

x-forwarded-port``: "xxxxxxxxx"

host``: "e64d8a33-6946-48df-87d8-bb7cbb04e845.mock.pstmn.io"

x-amzn-trace-id``: "Root=1-6811ef38-1fbc6451327a423716e08715"

content-length``: "24"

accept``: "application/json"

user-agent``: "azure-data-factory/2.0"

content-type``: "application/json; charset=UTF-8"

content-encoding``: "UTF-8"

accept-encoding``: "gzip,deflate"

And the received data is blank again, with the warning "Request body has invalid format".

here is my complete (simplified) data flow that I cannot get to work with the REST service. If you have complete data flow code that does work I would be very grateful!

source(output( {Guardian First Name} as string ), allowSchemaDrift: true, validateSchema: false, ignoreNoFilesFound: false) ~> ContactsToCreate CreateBodyColumn call(mapColumn( body ), skipDuplicateMapInputs: false, skipDuplicateMapOutputs: false, output( headers as [string,string], status as string ), allowSchemaDrift: true, format: 'rest', store: 'restservice', timeout: 30, requestInterval: 0, httpMethod: 'POST', headerColumnName: 'headers', bodyColumnName: 'body', statusColumnName: 'status', addResponseCode: true, responseFormat: ['type' -> 'json', 'documentForm' -> 'documentPerLine']) ~> CreateContacts ContactsToCreate derive(body = concat('{ "firstName": "', {Guardian First Name}, '" }')) ~> CreateBodyColumn
Dileep Raj Narayan Thumula 5 Reputation points Microsoft External Staff

2025-04-30T11:14:56.29+00:00

Hi @TDay could you let me know how can we send deeply nested JSON objects in the request body from ADF Web activity? Are there any size or structure limitations
Dileep Raj Narayan Thumula 5 Reputation points Microsoft External Staff

2025-05-01T10:38:46.9133333+00:00

Hello @TDay,We haven’t heard from you on the last response and was just checking back to see if you have a resolution yet. In case if you have any resolution please do share that same with the community as it can be helpful to others. Otherwise, will respond with more details and we will try to help.
TDay 0 Reputation points

2025-05-01T13:24:29.76+00:00
Hi @Dileep Raj Narayan Thumula

Sorry I'm not sure what you mean by

how can we send deeply nested JSON objects in the request body from ADF Web activity?

I am not sure myself, which is why I asked! I provided the data flow code that I couldn't get to work, but I'm not sure what else I can share. Please let me know and I will very happily provide!

Some further notes from me

I realised that if I enable gzip encoding then the data is passed without me needing to map a body column. My problem was that the API that should accept the POST request cannot deal with GZIP encoding. This made me think there is a bug with the non-encoded version?

bodyColumnName: 'body' : this is setting the output body name, not the input.

Thanks

Tabi
Dileep Raj Narayan Thumula 5 Reputation points Microsoft External Staff

2025-05-02T08:47:06.3033333+00:00

@TDay In Azure Data Factory, when using the "External Call" transformation inside Mapping Data Flows, the body column we map gets wrapped as a JSON object with a body property.

like if we map body = {firstname}

{

"body": "Test"

}

But APIs (including Postman) usually expect

{

"firstname": "Test"

}
TDay 0 Reputation points

2025-05-02T09:29:15.2333333+00:00
Hi @Dileep Raj Narayan Thumula

Thanks for the info - how do I fix the problem then?

I tried at first to send the data not wrapped in a body column. Then I was told here to wrap the data into a body column and that also didn't work.

Do you have any insight into these comments?

I realised that if I enable gzip encoding then the data is passed without me needing to map a body column. My problem was that the API that should accept the POST request cannot deal with GZIP encoding. This made me think there is a bug with the non-encoded version?

bodyColumnName: 'body' : this is setting the output body name, not the input. There appears to be no way to set which column of input comprises the body of the request. This, alongside all of the data being sent properly when GZIP encoding is enabled, makes me believe that perhaps there is a bug.

If anyone has actually been able to get the mapping data flow external call activity to work with a POST request please let me know and send the complete data flow code.

Thanks in advance

Share via

Azure Data Factory external call POST request body empty

1 answer

Your answer