Community API

GET Comments by Date

{{baseUrl}}/user-content/by-date.json

QUERY PARAMS

api-key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user-content/by-date.json" {:query-params {:api-key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/by-date.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/by-date.json',
  qs: {'api-key': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user-content/by-date.json');

req.query({
  'api-key': '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/by-date.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D');

echo $response->getBody();

setUrl('{{baseUrl}}/user-content/by-date.json');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'api-key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user-content/by-date.json');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'api-key' => '{{apiKey}}'
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user-content/by-date.json"

querystring = {"api-key":"{{apiKey}}"}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user-content/by-date.json"

queryString <- list(api-key = "{{apiKey}}")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user-content/by-date.json') do |req|
  req.params['api-key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user-content/by-date.json";

    let querystring = [
        ("api-key", "{{apiKey}}"),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D'

http GET '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user-content/by-date.json?api-key=%7B%7BapiKey%7D%7D")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "copyright": "Copyright (c) 2016 The New York Times Company.  All Rights Reserved.",
  "debug": {
    "version": 3.1
  },
  "results": {
    "api_timestamp": "1458149967",
    "comments": [
      {
        "approveDate": "1451710808",
        "assetID": 3444599,
        "assetURL": "http://cooking.nytimes.com/recipes/1017904",
        "commentBody": "We used black eyed peas and kale (couldn't find mustard greens), and this recipe is fantastic! With cornbread it was perfect!",
        "commentID": 17096625,
        "commentSequence": 17096625,
        "commentTitle": "
",
        "commentType": "comment",
        "createDate": "1451710797",
        "editorsSelection": 0,
        "lft": 42,
        "parentID": null,
        "recommendationCount": 0,
        "replies": [],
        "replyCount": 0,
        "rgt": 43,
        "status": "approved",
        "statusID": 2,
        "updateDate": "1451710808",
        "userDisplayName": "Sharon",
        "userID": 72856041,
        "userLocation": "
",
        "userTitle": "NULL",
        "userURL": 72856041
      }
    ],
    "totalCommentsFound": 4121,
    "totalCommentsReturned": 25
  },
  "status": "OK"
}

GET Comments by URL

{{baseUrl}}/user-content/url.json

QUERY PARAMS

api-key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user-content/url.json" {:query-params {:api-key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user-content/url.json?api-key=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/url.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user-content/url.json?api-key=%7B%7BapiKey%7D%7D',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/url.json',
  qs: {'api-key': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user-content/url.json');

req.query({
  'api-key': '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/url.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D');

echo $response->getBody();

setUrl('{{baseUrl}}/user-content/url.json');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'api-key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user-content/url.json');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'api-key' => '{{apiKey}}'
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/user-content/url.json?api-key=%7B%7BapiKey%7D%7D")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user-content/url.json"

querystring = {"api-key":"{{apiKey}}"}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user-content/url.json"

queryString <- list(api-key = "{{apiKey}}")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user-content/url.json') do |req|
  req.params['api-key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user-content/url.json";

    let querystring = [
        ("api-key", "{{apiKey}}"),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D'

http GET '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user-content/url.json?api-key=%7B%7BapiKey%7D%7D")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "copyright": "Copyright (c) 2016 The New York Times Company.  All Rights Reserved.",
  "debug": {
    "version": 3.1
  },
  "results": {
    "api_timestamp": "1455718117",
    "callerID": null,
    "comments": [
      {
        "approveDate": "1199322293",
        "commentBody": "I have always wondered how much energy US would save if it shut down Vegas? Can you imagine the amount of electricity consumed on the strip, the ice melted for its water supply - all in the name of gambling? That's the kind of consumerism I would like to see halted. Same goes for all the downtown skylines which cause so much light pollution. Even a simple thing like having an \"off\" switch in the homes rather than just power outlets would save a lot of energy and hopefully make a huge difference in the \"consumption footprint.\" Can American live with that?

As for the growing economies of China & India: the increased industrialization has also increased environmental pollution in those countries. West has conveniently handed down it's dirty work to them. And at the same time we have Americans screaming about lost jobs. When will they realize that they can't have it both ways?

All in all they are acting like spoilt brats who have realized that they are no longer the teacher's favorite. Is it surprising that other folks hate you for your spoilt ways, at the same time envying how you have it so easy?

",
        "commentID": 20831,
        "commentSequence": 138,
        "commentTitle": "",
        "commentType": "comment",
        "createDate": "1199309173",
        "depth": 1,
        "editorsSelection": false,
        "parentID": null,
        "parentUserDisplayName": null,
        "permID": "138",
        "picURL": "http://graphics8.nytimes.com/images/apps/timespeople/none.png",
        "recommendations": 5,
        "recommendedFlag": null,
        "replies": [],
        "replyCount": 0,
        "reportAbuseFlag": null,
        "sharing": 0,
        "status": "approved",
        "timespeople": 1,
        "trusted": 0,
        "updateDate": "1199322293",
        "userDisplayName": "byakushi",
        "userID": 44150303,
        "userLocation": "US",
        "userTitle": null,
        "userURL": null
      }
    ],
    "depthLimit": 0,
    "filter": "",
    "page": 1,
    "replyLimit": 3,
    "sort": "oldest",
    "totalCommentsFound": 138,
    "totalCommentsReturned": 25,
    "totalEditorsSelectionFound": 13,
    "totalEditorsSelectionReturned": 1,
    "totalParentCommentsFound": 138,
    "totalParentCommentsReturned": 25,
    "totalRecommendationsFound": 118,
    "totalRecommendationsReturned": 23,
    "totalReplyCommentsFound": 0,
    "totalReplyCommentsReturned": 0,
    "totalReporterReplyCommentsFound": 0,
    "totalReporterReplyCommentsReturned": 0
  },
  "status": "OK"
}

GET Comments by User

{{baseUrl}}/user-content/user.json

QUERY PARAMS

api-key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user-content/user.json" {:query-params {:api-key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user-content/user.json?api-key=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/user.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user-content/user.json?api-key=%7B%7BapiKey%7D%7D',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/user.json',
  qs: {'api-key': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user-content/user.json');

req.query({
  'api-key': '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/user.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D');

echo $response->getBody();

setUrl('{{baseUrl}}/user-content/user.json');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'api-key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user-content/user.json');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'api-key' => '{{apiKey}}'
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/user-content/user.json?api-key=%7B%7BapiKey%7D%7D")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user-content/user.json"

querystring = {"api-key":"{{apiKey}}"}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user-content/user.json"

queryString <- list(api-key = "{{apiKey}}")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user-content/user.json') do |req|
  req.params['api-key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user-content/user.json";

    let querystring = [
        ("api-key", "{{apiKey}}"),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D'

http GET '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user-content/user.json?api-key=%7B%7BapiKey%7D%7D")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "copyright": "Copyright (c) 2016 The New York Times Company.  All Rights Reserved.",
  "debug": {
    "version": 3.1
  },
  "results": {
    "api_timestamp": "1458150045",
    "comments": [
      {
        "approveDate": "1316728099",
        "asset": {
          "all-properties": [
            {
              "description": "Not in a group",
              "name": "no-group",
              "properties": []
            }
          ],
          "assetID": 3267087,
          "assetTitle": "Cellphone Service Coming to the Subway",
          "assetURL": "http://cityroom.blogs.nytimes.com/2011/09/22/cell-phone-service-on-some-subway-platforms-starts-next-week/",
          "createDate": "1316722025",
          "labels": [
            {
              "labelID": 54906,
              "labelName": "NYT_Blogs"
            }
          ],
          "properties": {
            "automoderation-off": {
              "groupID": 2,
              "taxonomyID": 199832
            },
            "comment-list-sort-approvedate-desc": {
              "groupID": 1,
              "taxonomyID": 199832
            },
            "reached-max-com-on": {
              "groupID": 3,
              "taxonomyID": 199832
            }
          },
          "source": "url",
          "taxonomies": [
            [
              {
                "name": "blogs",
                "taxonomyID": 70457
              }
            ]
          ],
          "taxonomy": "blogs/cityroom/Cellphone Service Coming to the Subway",
          "text": [],
          "updateDate": "1319743568",
          "vendorID": "P12Rq7kT2AvJyomlFgcylQ=="
        },
        "commentBody": "time to Google for \"cell phone signal blocker\"...",
        "commentID": 4570862,
        "commentSequence": 10,
        "commentTitle": "hardcoded comment title",
        "commentType": "comment",
        "createDate": "1316723787",
        "editorsSelection": false,
        "labels": [],
        "parentID": null,
        "permid": 10,
        "picURL": "http://pimage.timespeople.nytimes.com/2364/811/cropped-2364811.jpg?0.8428952772024576",
        "recommendations": 11,
        "replies": [],
        "replyCount": 0,
        "status": "approved",
        "updateDate": "1316728099",
        "userDisplayName": null,
        "userID": 2364811,
        "userLocation": null,
        "userSubmittedDisplayName": "Jim",
        "userSubmittedLocation": "NYC",
        "userSubmittedTitle": null,
        "userSubmittedURL": null,
        "userTitle": null,
        "userURL": null
      }
    ],
    "totalCommentsFound": 2,
    "totalCommentsReturned": 2
  },
  "status": "OK"
}

GET Recent User Comments

{{baseUrl}}/user-content/recent.json

QUERY PARAMS

api-key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user-content/recent.json" {:query-params {:api-key "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/recent.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/recent.json',
  qs: {'api-key': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user-content/recent.json');

req.query({
  'api-key': '{{apiKey}}'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user-content/recent.json',
  params: {'api-key': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D');

echo $response->getBody();

setUrl('{{baseUrl}}/user-content/recent.json');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'api-key' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user-content/recent.json');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'api-key' => '{{apiKey}}'
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user-content/recent.json"

querystring = {"api-key":"{{apiKey}}"}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user-content/recent.json"

queryString <- list(api-key = "{{apiKey}}")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user-content/recent.json') do |req|
  req.params['api-key'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user-content/recent.json";

    let querystring = [
        ("api-key", "{{apiKey}}"),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D'

http GET '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user-content/recent.json?api-key=%7B%7BapiKey%7D%7D")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "copyright": "Copyright (c) 2016 The New York Times Company.  All Rights Reserved.",
  "debug": {
    "version": 3.1
  },
  "results": {
    "api_timestamp": "1458149501",
    "comments": [
      {
        "approveDate": "1458149469",
        "asset": {
          "all-properties": [
            {
              "description": "Not in a group",
              "name": "no-group",
              "properties": []
            }
          ],
          "assetID": 3449092,
          "assetTitle": "Kasich, the Boulder Between the G.O.P. and Trump (16collins)",
          "assetURL": "http://www.nytimes.com/2016/03/16/opinion/campaign-stops/kasich-the-boulder-between-the-gop.html",
          "createDate": "1458096538",
          "labels": [],
          "properties": {
            "automoderation-on": {
              "groupID": 2,
              "taxonomyID": 364114
            },
            "comment-list-sort-editors": {
              "groupID": 1,
              "taxonomyID": 364114
            },
            "reached-max-com-off": {
              "groupID": 3,
              "taxonomyID": 9188
            }
          },
          "source": "url",
          "taxonomies": [
            [
              {
                "name": "opinion",
                "taxonomyID": 9188
              }
            ]
          ],
          "taxonomy": "opinion/Kasich, the Boulder Between the G.O.P. and Trump (16collins)",
          "text": [],
          "updateDate": "1458149477",
          "vendorID": "MQdKLYFNCfZ7XvixkGz2rw=="
        },
        "assetID": 3449092,
        "commentBody": "Two things to know about our Governor Kasich. First, he was one of the few Republican governors to accept Obamacare and Medicaid expansion in Ohio, despite the efforts of legislators from his party. Second, as Gail Collins pointed out, he has done everything in his power to eliminate access to safe abortion in Ohio. This will soon include a bill he is expected to sign that will make it illegal for women to have an abortion after learning their fetus has Down's syndrome. Like most candidates these days, we have to take the good with the bad.",
        "commentID": 17912830,
        "commentSequence": 17912830,
        "commentTitle": "
",
        "commentType": "comment",
        "createDate": "1458149421",
        "display_name": "DD",
        "editorsSelection": 0,
        "location": "Cincinnati, OH",
        "parentID": null,
        "recommendationCount": 0,
        "replies": [],
        "status": "approved",
        "statusID": 2,
        "updateDate": "1458149469",
        "userDisplayName": "DD",
        "userID": 64507566,
        "userLocation": "Cincinnati, OH",
        "userTitle": "NULL",
        "userURL": "NULL"
      }
    ],
    "totalCommentsReturned": 25
  },
  "status": "OK"
}