How to Solve the XMLHttpRequest 'No Access-Control-Allow-Origin' Error

The XMLHttpRequest 'No Access-Control-Allow-Origin' error is a common issue faced by developers when trying to make cross-origin requests in JavaScript. This error occurs when the requested resource does not have the necessary 'Access-Control-Allow-Origin' header, which is required to allow the browser to access the resource from a different origin. In this article, we will explore what causes this error and how to solve it.

Understanding the Same Origin Policy

In order to understand the 'No Access-Control-Allow-Origin' error, we first need to understand the Same Origin Policy. The Same Origin Policy is a security measure implemented by web browsers to prevent scripts running on one origin from accessing resources on a different origin. An origin is defined by the combination of the protocol, domain, and port number.

For example, if a script running on the origin '' tries to access a resource on the origin '', the browser will block the request unless the server hosting the resource includes the necessary 'Access-Control-Allow-Origin' header.

Causes of the 'No Access-Control-Allow-Origin' Error

The 'No Access-Control-Allow-Origin' error occurs when the server hosting the requested resource does not allow cross-origin requests from the origin making the request. This can happen for several reasons:

  • The server does not include the 'Access-Control-Allow-Origin' header in the response.
  • The server includes the 'Access-Control-Allow-Origin' header, but it does not match the origin making the request.
  • The server includes the 'Access-Control-Allow-Origin' header, but it is set to a wildcard (*) value, which means it allows requests from any origin. However, the server also includes other headers (e.g., 'Access-Control-Allow-Credentials') that prevent wildcard access.

Solving the 'No Access-Control-Allow-Origin' Error

There are several ways to solve the 'No Access-Control-Allow-Origin' error, depending on your specific requirements and the server hosting the resource. Below are some possible solutions:

1. Add the 'Access-Control-Allow-Origin' Header

If you have control over the server hosting the requested resource, you can add the 'Access-Control-Allow-Origin' header to the server's response. This header should include the origin from which you want to allow requests. For example:

Access-Control-Allow-Origin: http://localhost:4300

By including this header, you are explicitly allowing requests from the specified origin, and the 'No Access-Control-Allow-Origin' error should be resolved.

2. Use a Proxy Server

If you do not have control over the server hosting the requested resource, or if you need to make cross-origin requests to multiple servers, you can use a proxy server. A proxy server acts as an intermediary between the client and the server, forwarding requests from the client to the server and forwarding responses from the server to the client.

To use a proxy server, you can create a server-side script (e.g., in PHP, Node.js, etc.) that proxies the request to the intended server and includes the necessary 'Access-Control-Allow-Origin' header in the response. Your JavaScript code can then make requests to the proxy server instead of the original server, bypassing the Same Origin Policy. Here is an example of a basic proxy server in Node.js:

const http = require('http');
const request = require('request');

http.createServer((req, res) => {
    const url = '' + req.url;

In this example, any requests made to the proxy server at 'http://localhost:4300' will be forwarded to '', and the server's response will be sent back to the client. You can modify this code to handle different routes or add additional headers as needed.

3. Use JSONP or CORS

If the server hosting the requested resource supports JSONP (JSON with Padding) or CORS (Cross-Origin Resource Sharing), you can use these techniques to make cross-origin requests without encountering the 'No Access-Control-Allow-Origin' error.

JSONP is a technique that allows scripts to retrieve data from a different origin by including a callback function in the request URL. The server responds with a JSON payload wrapped in the callback function, which can be executed by the client-side script. However, JSONP is limited to GET requests and requires the server to explicitly support it.

CORS, on the other hand, is a standard mechanism for making cross-origin requests in modern browsers. It allows both simple and complex requests (e.g., with custom headers or methods) and is supported by most modern web servers. To use CORS, the server needs to include the appropriate 'Access-Control-Allow-Origin' header and handle preflight requests if necessary.


The 'No Access-Control-Allow-Origin' error is a common obstacle when making cross-origin requests in JavaScript. By understanding the Same Origin Policy and implementing the appropriate solutions, such as adding the 'Access-Control-Allow-Origin' header or using a proxy server, you can overcome this error and retrieve the desired resources from different origins.

Remember to always check the server's documentation or consult with the server administrator to ensure that your requests comply with their security policies and are allowed to access the requested resources.