GET Compute atmospheric density and temperatures
{{baseUrl}}/jb2008
QUERY PARAMS
year
month
day
altitude
geodetic_latitude
geodetic_longitude
utc
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/jb2008" {:query-params {:year ""
                                                                 :month ""
                                                                 :day ""
                                                                 :altitude ""
                                                                 :geodetic_latitude ""
                                                                 :geodetic_longitude ""
                                                                 :utc ""}})
require "http/client"

url = "{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="

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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="

	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/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="))
    .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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/jb2008',
  params: {
    year: '',
    month: '',
    day: '',
    altitude: '',
    geodetic_latitude: '',
    geodetic_longitude: '',
    utc: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=';
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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=',
  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}}/jb2008',
  qs: {
    year: '',
    month: '',
    day: '',
    altitude: '',
    geodetic_latitude: '',
    geodetic_longitude: '',
    utc: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/jb2008');

req.query({
  year: '',
  month: '',
  day: '',
  altitude: '',
  geodetic_latitude: '',
  geodetic_longitude: '',
  utc: ''
});

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}}/jb2008',
  params: {
    year: '',
    month: '',
    day: '',
    altitude: '',
    geodetic_latitude: '',
    geodetic_longitude: '',
    utc: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=';
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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="]
                                                       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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=",
  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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=');

echo $response->getBody();
setUrl('{{baseUrl}}/jb2008');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'year' => '',
  'month' => '',
  'day' => '',
  'altitude' => '',
  'geodetic_latitude' => '',
  'geodetic_longitude' => '',
  'utc' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/jb2008');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'year' => '',
  'month' => '',
  'day' => '',
  'altitude' => '',
  'geodetic_latitude' => '',
  'geodetic_longitude' => '',
  'utc' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")

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

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

url = "{{baseUrl}}/jb2008"

querystring = {"year":"","month":"","day":"","altitude":"","geodetic_latitude":"","geodetic_longitude":"","utc":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/jb2008"

queryString <- list(
  year = "",
  month = "",
  day = "",
  altitude = "",
  geodetic_latitude = "",
  geodetic_longitude = "",
  utc = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")

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/jb2008') do |req|
  req.params['year'] = ''
  req.params['month'] = ''
  req.params['day'] = ''
  req.params['altitude'] = ''
  req.params['geodetic_latitude'] = ''
  req.params['geodetic_longitude'] = ''
  req.params['utc'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/jb2008";

    let querystring = [
        ("year", ""),
        ("month", ""),
        ("day", ""),
        ("altitude", ""),
        ("geodetic_latitude", ""),
        ("geodetic_longitude", ""),
        ("utc", ""),
    ];

    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}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc='
http GET '{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/jb2008?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")! 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
{
  "at_alt_temp": {
    "units": "K",
    "value": 667.005615234375
  },
  "exospheric_temp": {
    "units": "K",
    "value": 666.522705078125
  },
  "total_mass_density": {
    "units": "kg/m3",
    "value": 5.201439105817496e-12
  }
}
GET Compute atmospheric composition, density, and temperatures
{{baseUrl}}/nrlmsise00
QUERY PARAMS
year
month
day
altitude
geodetic_latitude
geodetic_longitude
utc
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/nrlmsise00" {:query-params {:year ""
                                                                     :month ""
                                                                     :day ""
                                                                     :altitude ""
                                                                     :geodetic_latitude ""
                                                                     :geodetic_longitude ""
                                                                     :utc ""}})
require "http/client"

url = "{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="

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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="

	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/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="))
    .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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/nrlmsise00',
  params: {
    year: '',
    month: '',
    day: '',
    altitude: '',
    geodetic_latitude: '',
    geodetic_longitude: '',
    utc: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=';
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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=',
  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}}/nrlmsise00',
  qs: {
    year: '',
    month: '',
    day: '',
    altitude: '',
    geodetic_latitude: '',
    geodetic_longitude: '',
    utc: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/nrlmsise00');

req.query({
  year: '',
  month: '',
  day: '',
  altitude: '',
  geodetic_latitude: '',
  geodetic_longitude: '',
  utc: ''
});

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}}/nrlmsise00',
  params: {
    year: '',
    month: '',
    day: '',
    altitude: '',
    geodetic_latitude: '',
    geodetic_longitude: '',
    utc: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=';
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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc="]
                                                       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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=",
  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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=');

echo $response->getBody();
setUrl('{{baseUrl}}/nrlmsise00');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'year' => '',
  'month' => '',
  'day' => '',
  'altitude' => '',
  'geodetic_latitude' => '',
  'geodetic_longitude' => '',
  'utc' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/nrlmsise00');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'year' => '',
  'month' => '',
  'day' => '',
  'altitude' => '',
  'geodetic_latitude' => '',
  'geodetic_longitude' => '',
  'utc' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")

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

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

url = "{{baseUrl}}/nrlmsise00"

querystring = {"year":"","month":"","day":"","altitude":"","geodetic_latitude":"","geodetic_longitude":"","utc":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/nrlmsise00"

queryString <- list(
  year = "",
  month = "",
  day = "",
  altitude = "",
  geodetic_latitude = "",
  geodetic_longitude = "",
  utc = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")

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/nrlmsise00') do |req|
  req.params['year'] = ''
  req.params['month'] = ''
  req.params['day'] = ''
  req.params['altitude'] = ''
  req.params['geodetic_latitude'] = ''
  req.params['geodetic_longitude'] = ''
  req.params['utc'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/nrlmsise00";

    let querystring = [
        ("year", ""),
        ("month", ""),
        ("day", ""),
        ("altitude", ""),
        ("geodetic_latitude", ""),
        ("geodetic_longitude", ""),
        ("utc", ""),
    ];

    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}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc='
http GET '{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nrlmsise00?year=&month=&day=&altitude=&geodetic_latitude=&geodetic_longitude=&utc=")! 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
{
  "Ar_density": {
    "units": "/m3",
    "value": 345221344
  },
  "H_density": {
    "units": "/m3",
    "value": 846266302464
  },
  "He_density": {
    "units": "/m3",
    "value": 14137357762560
  },
  "N2_density": {
    "units": "/m3",
    "value": 7370196910080
  },
  "N_density": {
    "units": "/m3",
    "value": 424038367232
  },
  "O2_density": {
    "units": "/m3",
    "value": 285386670080
  },
  "O_density": {
    "units": "/m3",
    "value": 160525593870336
  },
  "anomalous_O_density": {
    "units": "/m3",
    "value": 2940371.25
  },
  "ap": {
    "value": 3
  },
  "at_alt_temp": {
    "units": "K",
    "value": 590.3972778320312
  },
  "exospheric_temp": {
    "units": "K",
    "value": 590.4319458007812
  },
  "f107": {
    "units": "sfu",
    "value": 70
  },
  "f107a": {
    "units": "sfu",
    "value": 69.35802469135803
  },
  "total_mass_density": {
    "units": "kg/m3",
    "value": 4.7264410267533474e-12
  }
}
GET Forecast winds, ion and molecular densities, and temperatures in the atmosphere
{{baseUrl}}/wam-ipe
QUERY PARAMS
latitude
longitude
altitude
year
month
day
hour
minute
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/wam-ipe" {:query-params {:latitude ""
                                                                  :longitude ""
                                                                  :altitude ""
                                                                  :year ""
                                                                  :month ""
                                                                  :day ""
                                                                  :hour ""
                                                                  :minute ""}})
require "http/client"

url = "{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute="

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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute="

	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/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute= HTTP/1.1
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute="))
    .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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=")
  .get()
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=")
  .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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/wam-ipe',
  params: {
    latitude: '',
    longitude: '',
    altitude: '',
    year: '',
    month: '',
    day: '',
    hour: '',
    minute: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=';
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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=")
  .get()
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=',
  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}}/wam-ipe',
  qs: {
    latitude: '',
    longitude: '',
    altitude: '',
    year: '',
    month: '',
    day: '',
    hour: '',
    minute: ''
  }
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/wam-ipe');

req.query({
  latitude: '',
  longitude: '',
  altitude: '',
  year: '',
  month: '',
  day: '',
  hour: '',
  minute: ''
});

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}}/wam-ipe',
  params: {
    latitude: '',
    longitude: '',
    altitude: '',
    year: '',
    month: '',
    day: '',
    hour: '',
    minute: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=';
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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute="]
                                                       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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=",
  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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=');

echo $response->getBody();
setUrl('{{baseUrl}}/wam-ipe');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'latitude' => '',
  'longitude' => '',
  'altitude' => '',
  'year' => '',
  'month' => '',
  'day' => '',
  'hour' => '',
  'minute' => ''
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/wam-ipe');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'latitude' => '',
  'longitude' => '',
  'altitude' => '',
  'year' => '',
  'month' => '',
  'day' => '',
  'hour' => '',
  'minute' => ''
]));

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

echo $response->getBody();
$response = Invoke-WebRequest -Uri '{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=' -Method GET 
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=' -Method GET 
import http.client

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

conn.request("GET", "/baseUrl/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=")

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

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

url = "{{baseUrl}}/wam-ipe"

querystring = {"latitude":"","longitude":"","altitude":"","year":"","month":"","day":"","hour":"","minute":""}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/wam-ipe"

queryString <- list(
  latitude = "",
  longitude = "",
  altitude = "",
  year = "",
  month = "",
  day = "",
  hour = "",
  minute = ""
)

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

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=")

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/wam-ipe') do |req|
  req.params['latitude'] = ''
  req.params['longitude'] = ''
  req.params['altitude'] = ''
  req.params['year'] = ''
  req.params['month'] = ''
  req.params['day'] = ''
  req.params['hour'] = ''
  req.params['minute'] = ''
end

puts response.status
puts response.body
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/wam-ipe";

    let querystring = [
        ("latitude", ""),
        ("longitude", ""),
        ("altitude", ""),
        ("year", ""),
        ("month", ""),
        ("day", ""),
        ("hour", ""),
        ("minute", ""),
    ];

    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}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute='
http GET '{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute='
wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute='
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wam-ipe?latitude=&longitude=&altitude=&year=&month=&day=&hour=&minute=")! 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
{
  "N2_density": {
    "units": "/m3",
    "value": 1.8508440362185578e+25
  },
  "O2_density": {
    "units": "/m3",
    "value": 5.005040353829904e+24
  },
  "O_density": {
    "units": "/m3",
    "value": 4279507561218048
  },
  "eastward_wind_neutral": {
    "units": "m/s",
    "value": 0.15444904565811157
  },
  "northward_wind_neutral": {
    "units": "m/s",
    "value": -9.831161499023438
  },
  "point": {
    "altitude": 327.6,
    "latitude": 30,
    "longitude": 348
  },
  "temp_neutral": {
    "units": "K",
    "value": 296.2078
  },
  "total_mass_density": {
    "units": "kg/m3",
    "value": 4.124548465486878e-11
  },
  "upward_wind_neutral": {
    "units": "m/s",
    "value": -0.00033221824560314417
  }
}