I think your data array should be like this:

var data = [{
name: string,
active: bool,
data: { //Use {} instead of []
    value: number,
    date: string
  }
}]

JSON.stringify() and JSON.parse() were meant to serialize and deserialize data. This is why it omits non-data (functions, regex, etc.) on purpose. When you mention serializing prototypes, you are serializing behavior and object relationships, not data. It's the same reason why JSON is preferred over XML for AJAX, because JSON is a data exchange format while XML is a document format.

I suggest you rethink your approach before this becomes a rabbit hole.

FWIW, JSON.serialize() accepts a replacer function as second arg, while JSON.parse() accepts a reviver function as second arg. If what you're building is some kind of object mapper, you can use the replacer to insert metadata about the constructor for that instance, and use the reviver to pick up that metadata and customize how that object instance is created.

The answer I was looking for was: You need to use JSON.stringify to first serialize your object to JSON, and then specify the content-type so your server understands it's JSON.

So, contentType and stringify are necessary if the server is expecting JSON.

You're over-complicating it. Don't stringify until the very end, otherwise you will end up with json inside of json, which is unlikely to be useful in any situation.

var address = {
    country: $('#country').val(),
    region: $('#description').val(),
    postalCode: $('#postalCode').val(),
    locality: $('#locality').val(),
    additionalInfo: $('#additionalInfo').val()
};

var data = {
    agencyName: $('#agencyName').val(),
    description: $('#description').val(),
    phoneNumber: $('#phoneNumber').val(),
    webSite: $('#webSite').val(),
    address: address
};

$.ajax({
    type: "post",
    url: "registerAgency",
    data:  JSON.stringify(data),
    contentType: "application/json",
    success: function(responseData, textStatus, jqXHR) {
        alert("data saved")
    },
    error: function(jqXHR, textStatus, errorThrown) {
        console.log(errorThrown);
    }
});

If you're willing to go to the effort of whitelisting, then you can establish an array of valid keys, which can provide the ability to nest similar to how many systems do JSON nesting (a . separator, or any separator of your choosing).

var whitelistedObj = whitelistJson(obj, ["company_name", "example", "address.street", "address.example"]);

function whitelistJson(obj, whitelist, separator) {
    var object = {};

    for (var i = 0, length = whitelist.length; i < length; ++i) {
        var k = 0,
            names = whitelist[i].split(separator || '.'),
            value = obj,
            name,
            count = names.length - 1,
            ref = object,
            exists = true;

        // fill in any empty objects from first name to end without
        //  picking up neighboring fields
        while (k < count) { // walks to n - 1
            name = names[k++];
            value = value[name];

            if (typeof value !== 'undefined') {
                if (typeof object[name] === 'undefined') {
                    ref[name] = {};
                }

                ref = ref[name];
            }
            else {
                exists = false;
                break;
            }
        }

        if (exists) {
            ref[names[count]] = value[names[count]];
        }
    }

    return object;
}

I have a JSFiddle showing its usage as well (to ensure it actually worked on my admittedly small sample set).

use

JSON.stringify(data) 

instead of using

JSON.stringify({"pChanges": data})

You can use JSON.parse with a "reviver" that recursively tries to parse every decoded string as json (and returns the argument as is if that fails):

function parseNested(str) {
    try {
        return JSON.parse(str, (_, val) => {
            if (typeof val === 'string')
                return parseNested(val)
            return val
        })
    } catch (exc) {
        return str
    }
}

// demo

obj = {
    'abc': 'def',
    'foo': 'bar',
    'nest1': JSON.stringify({deep1: 123}),
    'nest2': JSON.stringify({deep2: JSON.stringify({deep3: ['something', 'else']})}),
}

weird = JSON.stringify(obj)
console.log(weird)
console.log(parseNested(weird))