URL url = new URL("");

try (BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "UTF-8"))) {
    for (String line; (line = reader.readLine()) != null;) {
    System.out.println(line);
  }
}

set_time_limit(0);

$url_info = "";

$channel = curl_init();

curl_setopt($channel, CURLOPT_AUTOREFERER, TRUE);
curl_setopt($channel, CURLOPT_HEADER, 0);
curl_setopt($channel, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($channel, CURLOPT_URL, $url_info);
curl_setopt($channel, CURLOPT_FOLLOWLOCATION, TRUE);
curl_setopt($channel, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
curl_setopt($channel, CURLOPT_TIMEOUT, 0);
curl_setopt($channel, CURLOPT_CONNECTTIMEOUT, 0);
curl_setopt($channel, CURLOPT_SSL_VERIFYHOST, FALSE);
curl_setopt($channel, CURLOPT_SSL_VERIFYPEER, FALSE);

$output = curl_exec($channel);

if (curl_error($channel)) {
    return 'error:' . curl_error($channel);
} else {
 $outputJSON = json_decode($output);
  var_dump($outputJSON);
}

const https = require('https')

const options = {
  hostname: 'financialmodelingprep.com',
  port: 443,
  path: '',
  method: 'GET'
}

const req = https.request(options, (res) => {
  res.on('data', (d) => {
    process.stdout.write(d)
  })
})

req.on('error', (error) => {
  console.error(error)
})

req.end()

#!/usr/bin/env python

try:
    # For Python 3.0 and later
    from urllib.request import urlopen
except ImportError:
    # Fall back to Python 2's urllib2
    from urllib2 import urlopen

import certifi
import json

def get_jsonparsed_data(url):
    """
    Receive the content of ``url``, parse it as JSON and return the object.

    Parameters
    ----------
    url : str

    Returns
    -------
    dict
    """
    response = urlopen(url, cafile=certifi.where())
    data = response.read().decode("utf-8")
    return json.loads(data)

url = ("")
print(get_jsonparsed_data(url))

package main

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

func main() {
    url := ""
    response, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    responseData, err := ioutil.ReadAll(response.Body)
    if err != nil {
        log.Fatal(err)
    }

    responseString := string(responseData)

    fmt.Println(responseString)
}

require 'net/http'
require 'uri'

uri = URI.parse("")
request = Net::HTTP::Get.new(uri)
request["Upgrade-Insecure-Requests"] = "1"

req_options = {
  use_ssl: uri.scheme == "https",
}

response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

# response.code
# response.body

using (var httpClient = new HttpClient())

{
    using (var request = new HttpRequestMessage(new HttpMethod("GET"), ""))

    {
        request.Headers.TryAddWithoutValidation("Upgrade-Insecure-Requests", "1");

        var response = await httpClient.SendAsync(request);
    }
}

require(httr)

headers = c(
  `Upgrade-Insecure-Requests` = '1',
)

params = list(
  `datatype` = 'json'
)

res <- httr::GET(url = 'https://financialmodelingprep.com/api/v3/historical/sp500_constituent', httr::add_headers(.headers=headers), query = params)

version: 2
requests:
  curl_converter:
    request:
      url: 'https://financialmodelingprep.com/api/v3/historical/sp500_constituent'
      method: GET
      headers:
        -
          name: Upgrade-Insecure-Requests
          value: '1'
        -
      queryString:
        -
          name: datatype
          value: json

extern crate reqwest;

use reqwest::headers::*;

fn main() -> Result<(), reqwest::Error> {

    let mut headers = HeaderMap::new();

    headers.insert(UPGRADE_INSECURE_REQUESTS, "1".parse().unwrap());

    let res = reqwest::Client::new()
        .get("")
        .headers(headers)
        .send()?
        .text()?;

    println!("{}", res);

    Ok(())
}

import PlaygroundSupport

import Foundation

let url = URL(string: "")

var request = URLRequest(url: url!)

request.addValue("application/json", forHTTPHeaderField: "Accept")
let task = URLSession.shared.dataTask(with: url!) { data, response, error in
    guard error == nil else {
        print(error!)
        return
    }
    guard let data = data else {
        print("Data is empty")
        return
    }

    let json = try! JSONSerialization.jsonObject(with: data, options: [])
    print(json)
}

task.resume()
PlaygroundPage.current.needsIndefiniteExecution = true

import scala.io.Source.fromURL

val json = fromURL("").mkString

print(json)