Title: How can I get php to return 500 upon encountering a fatal exception?
Tags: php;error-handling;error-code
Question: PHP fatal errors come back as status code 200 to the HTTP client. How can I make it return a status code 500 (Internal server error)?
Comment: the fact php return an error that is not related to the HTML header you get in the browser. If you run that script from the command line you wont get any 200 error code

Comment: I need the exact opposite. I have set up a shutdown function that with `auto_prepend_file` catches all fatal errors. However, I also want to have `status code 200` sent when that function is invoked. But I keep getting `status code 500`.

Comment: See http://stackoverflow.com/questions/2331582/catch-php-fatal-error for a solution.


Here is another answer: Standard PHP configuration does return 500 when error occurs! Just make sure that your display_errors = off. You can simulate it with:
ini_set('display_errors', 0);
noFunction();
On production display_errors directive is off by default.
Comment for this answer: This should be higher up. This is actually the correct way of setting up the server to return 500 on fatal errors. If you need to see the error messages, you should be using the error log.

Here is another answer: It is not possible to handle PHP E_ERROR in any way according to the PHP documentation:
http://www.php.net/manual/en/function.set-error-handler.php
Nor is is possible to handle "E_PARSE, E_CORE_ERROR, E_CORE_WARNING, E_COMPILE_ERROR, E_COMPILE_WARNING, and most of E_STRICT" according to that link.
You CAN provide a handler for the other error, warning, and notices including E_USER_ERROR, but that's really not as useful as it sounds since this error only gets thrown intentionally by the programmer with trigger_error().
And of course you can catch any Exception (even the ones thrown by the native PHP functions).
I agree that this is a problem.  Servers should NOT return 200 OK when application code crashes and burns.
Comment for this answer: replying to super old answer here... but as of php 5.2... you can use `error_get_last()` inside the shutdown function..  if the last error was fatal.. tada

Here is another answer: I have used "set_exception_handler" to handle uncaught exceptions.
function handleException($ex) {
error_log("Uncaught exception class=" . get_class($ex) . " message=" . $ex-&gt;getMessage() . " line=" . $ex-&gt;getLine());
ob_end_clean(); # try to purge content sent so far
header('HTTP/1.1 500 Internal Server Error');
echo 'Internal error';
set_exception_handler('handleException');
Comment for this answer: Use both set_error_handler and set_exception_handler. The first one is for old style fatal errors, the second one is for object-oriented exceptions.
Comment for this answer: You can do this if you want to handle fatal errors: http://stackoverflow.com/questions/277224/how-do-i-catch-a-php-fatal-error

Here is another answer: The hard thing when dealing with fatal errors (compile errors, for example a missing semicolon) is that the script won't be executed, so it won't help to set the status code in that script. However, when you include or require a script, the calling script will be executed, regardless of errors in the included script. With this, I come to this solution:
rock-solid-script.php:
// minimize changes to this script to keep it rock-solid
http_response_code(500); // PHP &gt;= 5.4
require_once("script-i-want-to-guard-for-errors.php");
script-i-want-to-guard-for-errors.php:
// do all the processsing
// don't produce any output
// you might want to use output buffering
http_response_code(200); // PHP &gt;= 5.4
// here you can produce the output
Direct your call to the rock-solid-script.php and you're ready to go.
I would have liked it better to set the default status code to 500 in .htaccess. That seems more elegant to me but I can't find a way to pull it off. I tried the RewriteRule R-flag, but this prevents execution of php altogether, so that's no use.

Here is another answer: You would have to catch the thrown error using try/catch and then use that catch block to send a header() with the 500 error.
...badcode...
throw new Exception('error');
} catch (Exception $e) {
header("Status: 500 Server Error");
var_dump($e-&gt;getMessage());
If the fatal exception is not surrounded by try {} catch blocks then you must register a global handler and use register_shutdown_function() to check for an error at script end.
Comment for this answer: @ChrisRamakers: I've read something about using output handlers to catch PHP fatal errors.
Comment for this answer: Fatal/syntax errors can't be captured as far as i know, neither by errorhandling nor by exceptionhandling
Comment for this answer: depends, syntax errors are triggered at compile time thus the logic that handles output or exception handling simple never occurs because the page is simply not executed because i could not be compiled. But again, i'm not an absolute expert so i might not be aware of the output handlers you are talking about
Comment for this answer: That will catch exceptions, but it won't catch PHP Fatal errors, which are handled outside the scope of exceptions.
Comment for this answer: Actually, you use `register_shutdown_function()` to catch E_FATAL errors.

Here is another answer: This is exactly the problem I had yesterday and I found solution as follows:
1) first of all, you need to catch PHP fatal errors, which is error type E_ERROR. when this error occurs, script will be stored the error and terminate execution. you can get the stored error by calling function error_get_last().
2) before script terminated, a callback function register_shutdown_function() will always be called. so you need to register a error handler by this function to do what you want, in this case, return header 500 and a customized internal error page (optional).
function my_error_handler()
$last_error = error_get_last();
if ($last_error &amp;&amp; $last_error['type']==E_ERROR)
{
header("HTTP/1.1 500 Internal Server Error");
echo '...';//html for 500 page
}
register_shutdown_function('my_error_handler');
Note: if you want to catch custom error type, which start with E_USER*, you can use function set_error_handler()  to register error handler and trigger error by function trigger_error, however, this error handler can not handle E_ERROR error type. see explanation on php.net about error handler
Comment for this answer: Be sure to also use `ini_set("display_errors", "off");` in a production environment, otherwise the fatal error messages will be sent back to the client.
Comment for this answer: I suggest checking for E_PARSE as well - that's also catchable in this way, provided the shutdown function is set before the file with the parse error in it is included.

Here is another answer: header("HTTP/1.1 500 Internal Server Error");
Comment for this answer: @DrewSears I don't think you "have" to; you could just use the `Status` header field just like in CGI. But it must be said that for PHP programmers unfamiliar with CGI, the "HTTP/1.1" syntax is easier to read, because, well, it mimics an HTTP response.
Comment for this answer: Since PHP >= 5.4 there is the `http_response_code([int $responseCode])` function.
Comment for this answer: It's just silly that you should have to manually specify the HTTP version in order to emit a status code.

Here is another answer: Never forget to set header("HTTP/1.1 200 OK", true, 200); as the last line of any execution path:
//first things first:
header("HTTP/1.1 500 Internal Server Error", true, 500);
//Application code, includes, requires, etc. [...]
//somewhere something happens
//die();
throw new Exception("Uncaught exception!");
//last things last, only reached if code execution was not stopped by uncaught exception or some fatal error
header("HTTP/1.1 200 OK", true, 200);
In PHP 5.4 you can replace the header function above with the much better http_response_code(200) or http_response_code(500).
Comment for this answer: That doesn't work if any output is generated between the first and last `header()` call, because then the header will have already been sent. Working pages may be delivered with status 500. This approach is way too risky.
Comment for this answer: Use output buffering and output after the header. Which is obvious. If output buffering fails in any way, thats not a working page, its a buggy page.

Here is another answer: You can use php error handling
http://www.w3schools.com/php/php_error.asp
Comment for this answer: Good answer consists more than just linking to other pages. You could for example refer that page shortly. What happens when destination site is down or they move that content? Also, w3schools are not-so-good source.

Here is another answer: Since PHP >= 5.4
http_response_code(500);
echo json_encode( [ 'success' =&gt; false , 'message' =&gt; 'Crazy thing just happened!' ]);
exit();
Please set the httpCode before echo.

{'source': 'StackExchangeDataset', 'subset': 'stackoverflow.com', 'metadata': {'AnswerCount': 10, 'CommentCount': 3, 'ContentLicense': 'CC BY-SA 3.0', 'CreationDate': '2009:00:10/12/09', 'FavoriteCount': 10.0, 'PostTypeId': 1, 'Tags': '<php><error-handling><error-code>', 'Title': 'How can I get php to return 500 upon encountering a fatal exception?', 'ViewCount': 72714, 'id': 1555862, 'user_AboutMe': None, 'user_AccountId': 562794.0, 'user_DisplayName': 'Mike', 'user_Reputation': 701.0, 'user_Views': 19.0, 'user_id': 188570.0}}