How to get Powershell Invoke-Restmethod to return body of http 500 code response

The other answer does get you the response, but you need an additional step to get the actual body of the response, not just the headers. Here is a snippet:

try {
        $result = Invoke-WebRequest ...
}
catch {
        $result = $_.Exception.Response.GetResponseStream()
        $reader = New-Object System.IO.StreamReader($result)
        $reader.BaseStream.Position = 0
        $reader.DiscardBufferedData()
        $responseBody = $reader.ReadToEnd();
}

This solution no longer works with PowerShell 6 - it does not support GetResponseStream(). Instead use

try {
    $result = Invoke-WebRequest ...
}
catch {
    $_.ErrorDetails.Message
}

I wrote a short helper function to support PowerShell 6 and earlier:

function ParseErrorForResponseBody($Error) {
    if ($PSVersionTable.PSVersion.Major -lt 6) {
        if ($Error.Exception.Response) {  
            $Reader = New-Object System.IO.StreamReader($Error.Exception.Response.GetResponseStream())
            $Reader.BaseStream.Position = 0
            $Reader.DiscardBufferedData()
            $ResponseBody = $Reader.ReadToEnd()
            if ($ResponseBody.StartsWith('{')) {
                $ResponseBody = $ResponseBody | ConvertFrom-Json
            }
            return $ResponseBody
        }
    }
    else {
        return $Error.ErrorDetails.Message
    }
}

try {
    $result = Invoke-WebRequest ...
}
catch {
    ParseErrorForResponseBody($_)
}

Searching an answer for my problem I found this thread.

These solution worked for me, but I had to add two new line:

 $reader.BaseStream.Position = 0
 $reader.DiscardBufferedData()

Thanks!

I have been using Invoke-RestMethod exclusively - and since it might be a wrapper for Invoke-WebRequest, the following information might be useful.

You need to catch the exception and then get the response stream from Response like so.

    try
    {
        $response = Invoke-RestMethod Method Get uri "$($uri)" -Headers $headers
        return $response
    }
    catch
    {
        Write-Host "Exception details: "
        $e = $_.Exception
        Write-Host ("`tMessage: " + $e.Message)
        Write-Host ("`tStatus code: " + $e.Response.StatusCode)
        Write-Host ("`tStatus description: " + $e.Response.StatusDescription)

        Write-Host "`tResponse: " -NoNewline
        $memStream = $e.Response.GetResponseStream()
        $readStream = New-Object System.IO.StreamReader($memStream)
        while ($readStream.Peek() -ne -1) {
            Write-Host $readStream.ReadLine()
        }
        $readStream.Dispose();
    }

Reference: https://social.technet.microsoft.com/Forums/windowsserver/en-US/7d838d53-bfd5-4706-b0df-c4bee2d00412/using-memorystream-and-textreader

Please note as an extension to the answer provider by Florial Feldhaus the $_.ErrorDetails.Message is not the original response body. An HTML tag removal regex is used to make the response easier to read github link. Since the stream is disposed on line 1535 there is currently no way to retrieve the original response body.

The work around is to use the dotnet HttpClient to get the original response instead of using the Invoke-WebRequest cmdlet

$url = "http://localhost"
$client = [System.Net.Http.HttpClient]::new()
$request = [System.Net.Http.HttpRequestMessage]::new([System.Net.Http.HttpMethod]::Post, $url)
$request.Content = [System.Net.Http.StringContent]::new("Hello World", [System.Text.Encoding]::UTF8, "plain/text")

$result = $client.SendAsync($request).GetAwaiter().GetResult()
$content = $result.Content.ReadAsStringAsync().GetAwaiter().GetResult()

Write-Verbose $content -Verbose

The powershell core github issue is here

Because this is one of the first hits on google, here is answer for powershell core 6.0.0/7.0.0

Invoke-RestMethod and Invoke-WebRequest supports -SkipHttpErrorCheck switch:

This parameter causes the cmdlet to ignore HTTP error statuses and continue to process responses. The error responses are written to the pipeline just as if they were successful.

If this switch is used then Cmdlets does not throw error when failing status code is received.

Also Invoke-RestMethod now has command line parameters -StatusCodeVariable and -ResponseHeadersVariable that can be used to extract and save response status code and headers

-ResponseHeadersVariable was added on v6.0.0 and -SkipHttpErrorCheck/ResponseStatusVariable on v7.0.0

Better Native Handling Now (?)
I'm using Powershell 7.3.9 on Linux & 5.1.19041.3570 on Windows and found the response body is now shown in the error message. So I removed my extra exception handling and let default behavior take over.

I propose this Invoke-RestMethodEx cmdlet for any PowerShell version.

It throws an exception with a message similar to the original one, but tries to suffix it with the response body.

function Invoke-RestMethodEx {
    try {
        return Invoke-RestMethod  @Args
    }
    catch [System.Net.WebException] {
        $OrigEx = $_;
        $WebEx = $_.Exception;

        if ($PSVersionTable.PSVersion.Major -lt 6) {
            # PS < 6
            if ($null -eq $WebEx.Response) {
                throw $OrigEx;
            }
            try {
                $RespStream = $WebEx.Response.GetResponseStream();
                $RespBody = (New-Object System.IO.StreamReader($RespStream)).ReadToEnd();
                $RespStream.Close();
            }
            catch {
                throw $OrigEx;
            }
        }
        else {
            # PS >= 6
            $RespBody = $OrigEx.ErrorDetails.Message;
        }

        throw "Invoke-RestMethodEx: $($WebEx.Message) Body:`r`n${RespBody}";
    }
}