Client1:= NetHTTPClient1.Get('URL');
  for value in Client1.Cookies do
    ShowMessage(value.ToString);

  for value2 in Client1.Headers do
    ShowMessage(value2.Name + ' : ' + value2.value);

    t := TJCookieManager.JavaClass.getInstance;
    t.setAcceptCookie(True);
    t.setAcceptThirdPartyCookies(WebBrowser1.GetJWebBrowser, True);

    s := JStringToString(t.getCookie(StringToJString('URL')));
    ShowMessage(s);

  TScriptCallback = class(TJavaLocal, JValueCallback)
  public
    constructor Create;
    procedure onReceiveValue(value: JObject); cdecl;
  end;

var
 FResultCallback: JValueCallback;
...
FResultCallback := TScriptCallback.Create;


begin
  WebBrowser2.GetJWebBrowser.evaluateJavascript
    (StringToJString('(function() { return document.cookie; })();'), FResultCallback);
end;


procedure TScriptCallback.onReceiveValue(value: JObject);
var
  Str: String;
begin
  try
    Str := TJSONObject.ParseJSONValue(JStringToString(JString(value))).ToString;
  except
    Str := '';
  end;
  if Str <> '' then
  begin

     ShowMessage(Str);
  end;
end;

procedure TCookieManager.UpdateCookie(const ACookie: TCookie; const AURL: TURI);
var
  I: Integer;
  Found: Boolean;
begin
  TMonitor.Enter(FCookies);
  try
    Found := False;
    DeleteExpiredCookies;
    for I := 0 to FCookies.Count - 1 do
    begin
      if SameText(ACookie.Name, FCookies[I].Name) and
         SameText(ACookie.Domain, FCookies[I].Domain) and
         SameText(ACookie.Path, FCookies[I].Path) then
      begin
        Found := True;
        FCookies[I] := ACookie;
        Break;
      end
    end;
    if not Found and ((ACookie.Expires = 0) or (ACookie.Expires > Now)) then
      FCookies.Add(ACookie);
  finally
    TMonitor.Exit(FCookies);
  end;
end;

function StrExpiresToDateTime(const AStrDate: string): TDateTime;
var
  LDate: TDateTime;
  LTime: TDateTime;
  Pos: Integer;
  Len: Integer;
  LFoundTime: Boolean;
  LFoundDayOfMonth: Boolean;
  LFoundMonth: Boolean;
  LFoundYear: Boolean;
  LHours: Integer;
  LMinutes: Integer;
  LSeconds: Integer;
  LYear: Integer;
  LMonth: Integer;
  LDayOfMonth: Integer;
  Token: string;

  function IsDelimiter(C: Char): Boolean;
  // delimiter = %x09 / %x20-2F / %x3B-40 / %x5B-60 / %x7B-7E
  begin
    case C of
      Char($09), Char($20) .. Char($2F), Char($3B) .. Char($40),
        Char($5B) .. Char($60), Char($7B) .. Char($7E):
        Result := True;
    else
      Result := False;
    end;
  end;

  function IsNonDelimiter(C: Char): Boolean;
  // non-delimiter = %x00-08 / %x0A-1F / DIGIT / ":" / ALPHA / %x7F-FF
  begin
    case C of
      Char($00) .. Char($08), Char($0A) .. Char($1F), '0' .. '9', ':',
        'A' .. 'Z', 'a' .. 'z', Char($7F) .. Char($FF):
        Result := True;
    else
      Result := False;
    end;
  end;

  procedure CleanDelimiters;
  begin
    while (Pos < Len) and IsDelimiter(AStrDate.Chars[Pos]) do
      Inc(Pos);
  end;

  function ReadToken: string;
  begin
    Result := '';
    while (Pos < Len) and IsNonDelimiter(AStrDate.Chars[Pos]) do
    begin
      Result := Result + AStrDate.Chars[Pos];
      Inc(Pos);
    end;
  end;

  function CheckTime: Boolean;
  const
    HoursPart = 0;
    MinutesPart = 1;
    SecondsPart = 2;
  var
    Parts: TArray<string>;
  begin
    Result := False;
    if not LFoundTime then
    begin
      Parts := Token.Split([Char(':')]);
      if Length(Parts) = 3 then
      begin
        if (Parts[HoursPart].Length = 1) or (Parts[HoursPart].Length = 2) then
          if not TryStrToInt(Parts[HoursPart], LHours) or (LHours > 23) then
            Exit;

        if (Parts[MinutesPart].Length = 1) or (Parts[MinutesPart].Length = 2)
        then
          if not TryStrToInt(Parts[MinutesPart], LMinutes) or (LMinutes > 59)
          then
            Exit;

        if (Parts[SecondsPart].Length = 1) or (Parts[SecondsPart].Length = 2)
        then
          if not TryStrToInt(Parts[SecondsPart], LSeconds) or (LSeconds > 59)
          then
            Exit;

        LFoundTime := True;
        Result := True;
      end;
    end;
  end;

  function CheckDayOfMonth: Boolean;
  begin
    Result := False;
    if not LFoundDayOfMonth then
    begin
      if (Token.Length = 1) or (Token.Length = 2) then
        if TryStrToInt(Token, LDayOfMonth) and (LDayOfMonth >= 1) and
          (LDayOfMonth <= 31) then
        begin
          LFoundDayOfMonth := True;
          Result := True;
        end;
    end;
  end;

  function CheckMonth: Boolean;
  const
    Months: array [1 .. 12] of string = ('Jan', 'Feb', 'Mar', 'Apr', 'May',
      'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'); // do not localize
  var
    I: Integer;
  begin
    Result := False;
    if not LFoundMonth then
    begin
      for I := 1 to 12 do
        if SameText(Token, Months[I]) then
        begin
          LMonth := I;
          LFoundMonth := True;
          Result := True;
          Break;
        end;
    end;
  end;

  function CheckYear: Boolean;
  begin
    Result := False;
    if not LFoundYear then
    begin
      if (Token.Length = 2) or (Token.Length = 4) then
        if TryStrToInt(Token, LYear) then
        begin
          if (LYear >= 70) and (LYear <= 99) then
            LYear := LYear + 1900
          else if (LYear >= 0) and (LYear <= 69) then
            LYear := LYear + 2000;

          if LYear > 1600 then
          begin
            LFoundYear := True;
            Result := True;
          end;
        end;
    end;
  end;

begin
  LFoundTime := False;
  LFoundDayOfMonth := False;
  LFoundMonth := False;
  LFoundYear := False;
  Pos := 0;
  Len := AStrDate.Length;

  while Pos < Len do
  begin
    CleanDelimiters;
    Token := ReadToken;

    if CheckTime then
      Continue;

    if CheckDayOfMonth then
      Continue;

    if CheckMonth then
      Continue;

    if CheckYear then
      Continue;

    if LFoundTime and LFoundDayOfMonth and LFoundMonth and LFoundYear then
      Break;
  end;

  if LFoundTime and LFoundDayOfMonth and LFoundMonth and LFoundYear then
  begin
    if TryEncodeDate(LYear, LMonth, LDayOfMonth, LDate) and
      TryEncodeTime(LHours, LMinutes, LSeconds, 0, LTime) then
    begin
      LDate := LDate + LTime;
      Result := TTimeZone.Local.ToLocalTime(LDate);
      if Result = 0 then
        // To avoid to create a session cookie if the expire date is in the delphi date limit
        Result := 1;
    end
    else
      Result := 0;
  end
  else
    Result := 0;
end;