The " Z " at the end of 2019-10-18T11:23:27.756Z indicates that this date and time is in UTC.

Already when printing the Date, notice that it has GMT-0300, which indicates 3 hours behind UTC.

That is, both represent the same instant. This is a confusing half point, but the Date JavaScript , despite the name, does not represent a single date and time value (a single specific day, month, year, hour, minute, and second).

She actually represents a timestamp : the amount of milliseconds since the Unix Epoch. This value represents a single instant, a specific point in the timeline. Only that the same timestamp can represent a different date and time, depending on the time zone (just think that now, at this exact moment, in each part of the world the "Today" and the "current time" can be different, depending on the time zone you are in).

Thus, when printing a Date with console.log, it shows you the value considering the browser's timezone. But by sending the Date in a request, it is converting it to UTC. But the value of Date (its timestamp, the instant it corresponds to) has not changed.

In this case, it would be enough for the backend to take this date and convert to the correct timezone (and each language has its own ways of doing this).

locale controls the language and location settings, but it does not interfere with the time zone used, it's different things. I can use the locale corresponding to the Portuguese language, but show the date in a time zone of any other country, one thing is not related to another.

By changing the timestamp value, as suggested by another response (which has been deleted), you will be changing the instant the date matches. It may even "work", but it is not ideal, depending on what you want do.

To better understand, an analogy. Now in Brazil it is 10:20 and in London it is 14: 20 (the English are in summer time, hence the difference of 4 hours). Imagine that my computer is incorrectly configured with the London spindle, so it shows 14: 20.

So that it shows the correct time, I can do two things:

• change your computer setting to Brasilia Time
• delay the clock by 4 hours

In both cases, the time will now be shown as 10:20, but the second option is worse, because now my clock is indicating an instant in the past. this is what happens when you manipulate the timestamp value , and this is the error of the other answer. Although the value shown is "correct", you have created a Date corresponding to a different instant, and depending on what you are going to do with the date, it may give incorrect results.

In addition, the difference will not always be 4 hours. When in London it is not in summer time the difference is 3 hours, except that, when the gmt is the time in the summer, when the difference is two hours, but there have been periods of time where they're both at the time of the summer, and the difference is around 3 hours, for many years, with the summer time in Brazil, since the end of October, and in England in the end of October, and then in a few days they were at the time of the see).

In the specific case of Brazil, this year we will not have daylight saving time, but since this is something defined by the government, nothing guarantees that this will not change in the future. So manipulating the timestamp value still has this other drawback: it won't be synchronized with real-world changes. You would have to consult the timezone information to know if it uses 2 or 3 hours for its calculation.

That is, using fixed values to do this calculation is extremely error prone, and ideally always use the correct timezone.

Unfortunately JavaScript doesn't have a decent way to convert between time zones. The most you can do is get the date and time values in the timezone of the browser or in UTC. If you want in the same format as above, but using the browser timezone, you will have to do it manually:

function pad(value) {
    return value.toString().padStart(2, 0);
}
let d = new Date();
console.log(`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`);

The difference is that it will not have the Z at the end, since it is no longer in UTC. In this case, you will have to assume that the backend knows which timezone it is on. You can still use d.getTimezoneOffset(), which returns the difference in minutes with respect to UTC. In the case of Brasilia Time, The Return is 180 (or 120 when it is in summer time). If you want, you can send this information separately, so that the backend can do the conversion correctly.

Also notice that I had to add 1 in the month, because in JavaScript the months are indexed at zero (January is zero, February is 1, etc).

Moment.js

If you want, you can use Moment.js , along with the Moment Timezone , to manipulate the dates in the correct timezone:

let d = moment.tz('America/Sao_Paulo');
console.log(d.format()); //2019-10-18T10:32:31-03:00

<script src="https://momentjs.com/downloads/moment.min.js"></script>
<script src="https://momentjs.com/downloads/moment-timezone-with-data.min.js"></script>

Thus, it sends the date in the correct timezone (ex: 2019-10-18T10:32:31-03:00), without relying on the browser timezone, and you can manipulate it the way you see fit in the backend.

The names of timezones (like America/Sao_Paulo) are defined by Iana and are constantly undergoing constant updates (it keeps track of Daylight Saving Time changes around the world, so you don't have to worry about it: just use the correct timezone and the API does the rest). With the Moment.js you can have a list of available timezones using moment.tz.names():

console.log(moment.tz.names());

<script src="https://momentjs.com/downloads/moment.min.js"></script>
<script src="https://momentjs.com/downloads/moment-timezone-with-data.min.js"></script>

Angular

On the Angular, it seems to use JSON.stringify to convert the Date, when sending it in an HTTP request ^{lacks fonts, but I'm looking for}.

Anyway, I did a quick test, following the idea of this answer :

// aproveitando a função pad() já vista anteriormente
Date.prototype.toJSON = function() {
    return `${this.getFullYear()}-${pad(this.getMonth() + 1)}-${pad(this.getDate())}T${pad(this.getHours())}:${pad(this.getMinutes())}:${pad(this.getSeconds())}`;
}

By doing this, all dates sent via HttpClient are converted using the above function (which you can adapt to whatever you need).

Evidently this will change for all instances of Date in your project (which from the comments below, seems to be the case).