breakdown / fixes

CORS (Cross-Origin Resource Sharing) is a security feature implemented by web browsers to prevent malicious websites from reading sensitive data from other sites without permission. When you develop web applications, especially during local development, your frontend (like a React app) and backend (Node.js server) might run on different ports or domains. This setup can lead to CORS errors because the browser enforces a same-origin policy by default.

Understanding Same-Origin Policy

The same-origin policy is a critical security mechanism that restricts how a document or script loaded from one origin can interact with resources from another origin. An origin is defined by the scheme (protocol), hostname (domain), and port of the URL. For instance:

  • URL 1: http://localhost:3000
  • URL 2: http://localhost:3001

Here, even though both URLs are on localhost, they differ in port numbers (3000 vs. 3001), thus representing different origins according to browser security policies.

How CORS Works

CORS is a protocol that allows servers to explicitly allow certain cross-origin requests while rejecting others. It uses HTTP headers to tell browsers to give a web application running at one origin, access to selected resources from a different origin. When a browser makes a cross-origin HTTP request (e.g., a call from your React app on port 3000 to your backend API on port 3001), it sends an HTTP request to the target server with an Origin header that indicates the origin of the requesting site.

Here are the basic steps in a CORS request:

  1. Preflight Request: Before sending the actual request, the browser can send a preflight request to the server using the HTTP OPTIONS method. This request checks what HTTP methods and headers are allowed by the server for cross-origin requests.

  2. Server Response: The server responds with appropriate CORS headers:

    • Access-Control-Allow-Origin: Specifies which origins are allowed. It can be * (all origins), a specific origin like http://localhost:3000, or null.
    • Access-Control-Allow-Methods: Specifies allowed methods (e.g., GET, POST, PUT).
    • Access-Control-Allow-Headers: Specifies headers that can be used during the actual request.
  3. Actual Request: If the preflight response allows the request, the browser sends the actual request with the original HTTP method. The server then handles this request and includes CORS headers in its response.

Why You Might See CORS Errors

If CORS is not configured correctly on the server, or if the browser does not receive the expected CORS headers, it will block the response from being accessed by your JavaScript code, resulting in a CORS error. This is why setting up CORS properly is crucial for development environments where the front end and back end run on different servers or ports.

Adding CORS to php script

you can add it directly to the script –

header("Access-Control-Allow-Origin: *");
header("Content-Type: application/json");
header("Access-Control-Allow-Methods: POST");
header("Access-Control-Allow-Headers: Content-Type");
  1. Access-Control-Allow-Origin: This header specifies which domains are permitted to access the resources. For instance, header('Access-Control-Allow-Origin:'); allows only requests from However, header("Access-Control-Allow-Origin: *"); allows requests from any domain. If you include both lines in your script, the last one will override the earlier one.
  2. Content-Type: application/json: This header tells the browser that the content being returned by the server is JSON. It helps the client (browser or other consuming system) to parse the response correctly.
  3. Access-Control-Allow-Methods: POST: This specifies which HTTP method(s) are allowed when accessing the resource. Here, it's set to allow only POST requests.
  4. Access-Control-Allow-Headers: Content-Type: This allows the client to send headers of specified types along with the request. Here, it's specifically allowing headers of type Content-Type, which is essential for informing the server about the type of data being sent by the client.

By setting these headers directly in your PHP file, you can control access and interactions with your API on a per-script basis, which can be more flexible than configuring settings on the server level. This is particularly useful in shared hosting environments where you might not have access to server-wide configuration settings.

When setting CORS headers, make sure to configure them correctly to avoid inadvertently opening up your API to potential security risks, such as allowing any domain to interact with your backend or allowing methods that should not be allowed for all endpoints.




Step 1: Setting Up the PHP Server

First, ensure your PHP server can accept cross-origin requests from your React app's domain. Modify your PHP script to include CORS headers, as discussed in previous messages.

Here’s an example PHP script that also logs data to a file:

// Enable error reporting for debugging (remove in production)
ini_set('display_errors', 1);

// Function to log data
function logData($data) {
    $file = 'path_to_log_file.log'; // Ensure the path is correct and writable
    $time = date('Y-m-d H:i:s');
    file_put_contents($file, "$time - $data\n", FILE_APPEND);

header("Access-Control-Allow-Origin: *");
header("Content-Type: application/json");
header("Access-Control-Allow-Methods: POST");
header("Access-Control-Allow-Headers: Content-Type");

// Handle preflight requests

// Assuming JSON data is sent, decode it
$inputJSON = file_get_contents('php://input');
$input = json_decode($inputJSON, TRUE); //convert JSON into array

if (!is_null($input)) {
    logData("Received data: " . print_r($input, true));
    echo json_encode(["status" => "success", "message" => "Data logged successfully"]);
} else {
    echo json_encode(["status" => "error", "message" => "No data received"]);

Step 2: Creating the Fetch Request in React

In your React application, you can use the Fetch API to send data to the PHP script. Here's an example of how you might do this:

const sendDataToServer = async (data) => {
    const url = '';

    try {
        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            body: JSON.stringify(data)
        if (!response.ok) throw new Error('Network response was not ok.');
        const jsonResponse = await response.json();
        console.log("Server response:", jsonResponse);
    } catch (error) {
        console.error("Error sending data:", error);

// Example usage
sendDataToServer({ key: 'value', anotherKey: 'anotherValue' });

Enabling CORS in Express

To handle CORS in an Express application, you can use the cors middleware, which simplifies the process of adding the necessary headers:

const express = require('express');
const cors = require('cors');
const app = express();

// Enable all CORS requests

// Your routes here

app.listen(3001, () => {
    console.log('Server running on http://localhost:3001');

This basic setup allows any domain to interact with your backend. For more controlled environments, you can configure specific origins:

    origin: 'http://localhost:3000'  // Allow only this origin to access


Enabling CORS in PHP

To enable CORS in a PHP server, you'll need to add specific headers that allow cross-origin requests. Here's a simple example of how you can modify a PHP script to send these headers:

// Allow from any origin
if (isset($_SERVER['HTTP_ORIGIN'])) {
    // Decide if the origin in $_SERVER['HTTP_ORIGIN'] is one
    // you want to allow, and if so:
    header("Access-Control-Allow-Origin: {$_SERVER['HTTP_ORIGIN']}");
    header('Access-Control-Allow-Credentials: true');
    header('Access-Control-Max-Age: 86400');    // cache for 1 day

// Access-Control headers are received during OPTIONS requests

        // may also be using PUT, PATCH, HEAD etc
        header("Access-Control-Allow-Methods: GET, POST, OPTIONS");         

        header("Access-Control-Allow-Headers: {$_SERVER['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']}");


// Your PHP logic here
echo "Hello, this is my API!";

This script checks for an incoming origin and accepts requests from it if found. It also handles the preflight OPTIONS request by sending the necessary Access-Control-Allow-Methods and Access-Control-Allow-Headers responses.

Enabling CORS in Node.js using Express

In Node.js, especially when using the Express framework, enabling CORS can be efficiently done using the cors middleware. First, you need to install the cors package:

npm install cors

Then, you can use it in your application like this:

const express = require('express');
const cors = require('cors');
const app = express();

// Use CORS with default options - this will allow all cross-origin requests

// You can also configure CORS for specific routes and with more specific options
app.get('/data', cors(), (req, res) => {
    res.json({ message: 'This route supports CORS' });

app.listen(3000, () => {
    console.log('Server listening on http://localhost:3000');

For more granular control, such as enabling CORS only for specific domains:

const corsOptions = {
    origin: '',
    optionsSuccessStatus: 200 // some legacy browsers (IE11, various SmartTVs) choke on 204

app.get('/data', cors(corsOptions), (req, res) => {
    res.json({ message: 'This route supports CORS for only' });

These examples should help you enable CORS in both PHP and Node.js environments, ensuring your applications can communicate across different domains when necessary.

Scroll to Top