How do I send a cross-domain POST request via JavaScript?

How do I send a cross-domain POST request via JavaScript?

How do I send a cross-domain POST request via JavaScript?
Notes – it shouldn’t refresh the page, and I need to grab and parse the response afterwards.


Solution 1:

Update: Before continuing everyone should read and understand the html5rocks tutorial on CORS. It is easy to understand and very clear.

If you control the server being POSTed, simply leverage the “Cross-Origin Resource Sharing standard” by setting response headers on the server. This answer is discussed in other answers in this thread, but not very clearly in my opinion.

In short here is how you accomplish the cross domain POST from to (using PHP as an example). Note: you only need to set Access-Control-Allow-Origin for NON OPTIONS requests – this example always sets all headers for a smaller code snippet.

  1. In postHere.php setup the following:

    switch ($_SERVER['HTTP_ORIGIN']) {
        case '': case '':
        header('Access-Control-Allow-Origin: '.$_SERVER['HTTP_ORIGIN']);
        header('Access-Control-Allow-Methods: GET, PUT, POST, DELETE, OPTIONS');
        header('Access-Control-Max-Age: 1000');
        header('Access-Control-Allow-Headers: Content-Type, Authorization, X-Requested-With');

    This allows your script to make cross domain POST, GET and OPTIONS. This will become clear as you continue to read…

  2. Setup your cross domain POST from JS (jQuery example):

        type: 'POST',
        url: '',
        crossDomain: true,
        data: '{"some":"json"}',
        dataType: 'json',
        success: function(responseData, textStatus, jqXHR) {
            var value = responseData.someKey;
        error: function (responseData, textStatus, errorThrown) {
            alert('POST failed.');

When you do the POST in step 2, your browser will send a “OPTIONS” method to the server. This is a “sniff” by the browser to see if the server is cool with you POSTing to it. The server responds with an “Access-Control-Allow-Origin” telling the browser its OK to POST|GET|ORIGIN if request originated from “” or ““. Since the server is OK with it, the browser will make a 2nd request (this time a POST). It is good practice to have your client set the content type it is sending – so you’ll need to allow that as well.

MDN has a great write-up about HTTP access control, that goes into detail of how the entire flow works. According to their docs, it should “work in browsers that support cross-site XMLHttpRequest”. This is a bit misleading however, as I THINK only modern browsers allow cross domain POST. I have only verified this works with safari,chrome,FF 3.6.

Keep in mind the following if you do this:

  1. Your server will have to handle 2 requests per operation
  2. You will have to think about the security implications. Be careful before doing something like ‘Access-Control-Allow-Origin: *’
  3. This wont work on mobile browsers. In my experience they do not allow cross domain POST at all. I’ve tested android, iPad, iPhone
  4. There is a pretty big bug in FF < 3.6 where if the server returns a non 400 response code AND there is a response body (validation errors for example), FF 3.6 wont get the response body. This is a huge pain in the ass, since you cant use good REST practices. See bug here (its filed under jQuery, but my guess is its a FF bug – seems to be fixed in FF4).
  5. Always return the headers above, not just on OPTION requests. FF needs it in the response from the POST.

Solution 2:

If you control the remote server, you should probably use CORS, as described in this answer; it’s supported in IE8 and up, and all recent versions of FF, GC, and Safari. (But in IE8 and 9, CORS won’t allow you to send cookies in the request.)

So, if you don’t control the remote server, or if you have to support IE7, or if you need cookies and you have to support IE8/9, you’ll probably want to use an iframe technique.

  1. Create an iframe with a unique name. (iframes use a global namespace for the entire browser, so pick a name that no other website will use.)
  2. Construct a form with hidden inputs, targeting the iframe.
  3. Submit the form.

Here’s sample code; I tested it on IE6, IE7, IE8, IE9, FF4, GC11, S5.

function crossDomainPost() {
  // Add the iframe with a unique name
  var iframe = document.createElement("iframe");
  document.body.appendChild(iframe); = "none"; = uniqueString;

  // construct a form with hidden inputs, targeting the iframe
  var form = document.createElement("form"); = uniqueString;
  form.action = "http://INSERT_YOUR_URL_HERE";
  form.method = "POST";

  // repeat for each parameter
  var input = document.createElement("input");
  input.type = "hidden"; = "INSERT_YOUR_PARAMETER_NAME_HERE";


Beware! You won’t be able to directly read the response of the POST, since the iframe exists on a separate domain. Frames aren’t allowed to communicate with each other from different domains; this is the same-origin policy.

If you control the remote server but you can’t use CORS (e.g. because you’re on IE8/IE9 and you need to use cookies), there are ways to work around the same-origin policy, for example by using window.postMessage and/or one of a number of libraries allowing you to send cross-domain cross-frame messages in older browsers:

If you don’t control the remote server, then you can’t read the response of the POST, period. It would cause security problems otherwise.

Solution 3:

  1. Create an iFrame,
  2. put a form in it with Hidden inputs,
  3. set the form’s action to the URL,
  4. Add iframe to document
  5. submit the form


 var ifr = document.createElement('iframe');
 var frm = document.createElement('form');
 frm.setAttribute("action", "yoururl");
 frm.setAttribute("method", "post");

 // create hidden inputs, add them
 // not shown, but similar (create, setAttribute, appendChild)


You probably want to style the iframe, to be hidden and absolutely positioned. Not sure cross site posting will be allowed by the browser, but if so, this is how to do it.

Solution 4:

Keep it simple:

  1. cross-domain POST:
    use crossDomain: true,

  2. shouldn’t refresh the page:
    No, it will not refresh the page as the success or error async callback will be called when the server send back the response.

Example script:

        type: "POST",
        url: "",
        crossDomain: true,
        data: 'param1=value1&param2=value2',
        success: function (data) {
            // do something with server response data
        error: function (err) {
            // handle your error logic here

Solution 5:

If you have access to all servers involved, put the following in the header of the reply for the page being requested in the other domain:


header('Access-Control-Allow-Origin: *');

For example, in Drupal’s xmlrpc.php code you would do this:

function xmlrpc_server_output($xml) {
    $xml = '<?xml version="1.0"?>'."\n". $xml;
    header('Connection: close');
    header('Content-Length: '. strlen($xml));
    header('Access-Control-Allow-Origin: *');
    header('Content-Type: application/x-www-form-urlencoded');
    header('Date: '. date('r'));
    // $xml = str_replace("\n", " ", $xml); 

    echo $xml;

This probably creates a security problem, and you should make sure that you take the appropriate measures to verify the request.

Solution 6:

Check the post_method function in – a good example for the iframe method described above.