OpenUV - Global Real-Time UV Index Forecast API

GET Get daily protection time by location, UV Index from and UV Index to with 10 minutes accuracy. Optional altitide and ozone level could be provided.

{{baseUrl}}/protection

HEADERS

x-access-token

QUERY PARAMS

lat

lng

from

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/protection?lat=&lng=&from=&to=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/protection" {:headers {:x-access-token ""}
                                                      :query-params {:lat ""
                                                                     :lng ""
                                                                     :from ""
                                                                     :to ""}})

require "http/client"

url = "{{baseUrl}}/protection?lat=&lng=&from=&to="
headers = HTTP::Headers{
  "x-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/protection?lat=&lng=&from=&to="),
    Headers =
    {
        { "x-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/protection?lat=&lng=&from=&to=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/protection?lat=&lng=&from=&to="

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

	req.Header.Add("x-access-token", "")

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

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

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

}

GET /baseUrl/protection?lat=&lng=&from=&to= HTTP/1.1
X-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/protection?lat=&lng=&from=&to=")
  .setHeader("x-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/protection?lat=&lng=&from=&to="))
    .header("x-access-token", "")
    .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}}/protection?lat=&lng=&from=&to=")
  .get()
  .addHeader("x-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/protection?lat=&lng=&from=&to=")
  .header("x-access-token", "")
  .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}}/protection?lat=&lng=&from=&to=');
xhr.setRequestHeader('x-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/protection',
  params: {lat: '', lng: '', from: '', to: ''},
  headers: {'x-access-token': ''}
};

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

const url = '{{baseUrl}}/protection?lat=&lng=&from=&to=';
const options = {method: 'GET', headers: {'x-access-token': ''}};

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}}/protection?lat=&lng=&from=&to=',
  method: 'GET',
  headers: {
    'x-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/protection?lat=&lng=&from=&to=")
  .get()
  .addHeader("x-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/protection?lat=&lng=&from=&to=',
  headers: {
    'x-access-token': ''
  }
};

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}}/protection',
  qs: {lat: '', lng: '', from: '', to: ''},
  headers: {'x-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.query({
  lat: '',
  lng: '',
  from: '',
  to: ''
});

req.headers({
  'x-access-token': ''
});

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}}/protection',
  params: {lat: '', lng: '', from: '', to: ''},
  headers: {'x-access-token': ''}
};

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

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

const url = '{{baseUrl}}/protection?lat=&lng=&from=&to=';
const options = {method: 'GET', headers: {'x-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"x-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/protection?lat=&lng=&from=&to="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/protection?lat=&lng=&from=&to=" in
let headers = Header.add (Header.init ()) "x-access-token" "" in

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

 "{{baseUrl}}/protection?lat=&lng=&from=&to=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-access-token: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/protection?lat=&lng=&from=&to=', [
  'headers' => [
    'x-access-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/protection');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lat' => '',
  'lng' => '',
  'from' => '',
  'to' => ''
]);

$request->setHeaders([
  'x-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/protection');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lat' => '',
  'lng' => '',
  'from' => '',
  'to' => ''
]));

$request->setHeaders([
  'x-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/protection?lat=&lng=&from=&to=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/protection?lat=&lng=&from=&to=' -Method GET -Headers $headers

import http.client

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

headers = { 'x-access-token': "" }

conn.request("GET", "/baseUrl/protection?lat=&lng=&from=&to=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/protection"

querystring = {"lat":"","lng":"","from":"","to":""}

headers = {"x-access-token": ""}

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

print(response.json())

library(httr)

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

queryString <- list(
  lat = "",
  lng = "",
  from = "",
  to = ""
)

response <- VERB("GET", url, query = queryString, add_headers('x-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/protection?lat=&lng=&from=&to=")

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

request = Net::HTTP::Get.new(url)
request["x-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/protection') do |req|
  req.headers['x-access-token'] = ''
  req.params['lat'] = ''
  req.params['lng'] = ''
  req.params['from'] = ''
  req.params['to'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("lat", ""),
        ("lng", ""),
        ("from", ""),
        ("to", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/protection?lat=&lng=&from=&to=' \
  --header 'x-access-token: '

http GET '{{baseUrl}}/protection?lat=&lng=&from=&to=' \
  x-access-token:''

wget --quiet \
  --method GET \
  --header 'x-access-token: ' \
  --output-document \
  - '{{baseUrl}}/protection?lat=&lng=&from=&to='

import Foundation

let headers = ["x-access-token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/protection?lat=&lng=&from=&to=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()

GET Get hourly UV Index Forecast by location and date. Optional altitude, ozone level and datetime could be provided.

{{baseUrl}}/forecast

HEADERS

x-access-token

QUERY PARAMS

lat

lng

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/forecast?lat=&lng=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/forecast" {:headers {:x-access-token ""}
                                                    :query-params {:lat ""
                                                                   :lng ""}})

require "http/client"

url = "{{baseUrl}}/forecast?lat=&lng="
headers = HTTP::Headers{
  "x-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/forecast?lat=&lng="),
    Headers =
    {
        { "x-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/forecast?lat=&lng=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/forecast?lat=&lng="

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

	req.Header.Add("x-access-token", "")

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

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

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

}

GET /baseUrl/forecast?lat=&lng= HTTP/1.1
X-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/forecast?lat=&lng=")
  .setHeader("x-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/forecast?lat=&lng="))
    .header("x-access-token", "")
    .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}}/forecast?lat=&lng=")
  .get()
  .addHeader("x-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/forecast?lat=&lng=")
  .header("x-access-token", "")
  .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}}/forecast?lat=&lng=');
xhr.setRequestHeader('x-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/forecast',
  params: {lat: '', lng: ''},
  headers: {'x-access-token': ''}
};

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

const url = '{{baseUrl}}/forecast?lat=&lng=';
const options = {method: 'GET', headers: {'x-access-token': ''}};

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}}/forecast?lat=&lng=',
  method: 'GET',
  headers: {
    'x-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/forecast?lat=&lng=")
  .get()
  .addHeader("x-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/forecast?lat=&lng=',
  headers: {
    'x-access-token': ''
  }
};

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}}/forecast',
  qs: {lat: '', lng: ''},
  headers: {'x-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.query({
  lat: '',
  lng: ''
});

req.headers({
  'x-access-token': ''
});

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}}/forecast',
  params: {lat: '', lng: ''},
  headers: {'x-access-token': ''}
};

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

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

const url = '{{baseUrl}}/forecast?lat=&lng=';
const options = {method: 'GET', headers: {'x-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"x-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/forecast?lat=&lng="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/forecast?lat=&lng=" in
let headers = Header.add (Header.init ()) "x-access-token" "" in

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

 "{{baseUrl}}/forecast?lat=&lng=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-access-token: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/forecast?lat=&lng=', [
  'headers' => [
    'x-access-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/forecast');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lat' => '',
  'lng' => ''
]);

$request->setHeaders([
  'x-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/forecast');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lat' => '',
  'lng' => ''
]));

$request->setHeaders([
  'x-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/forecast?lat=&lng=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/forecast?lat=&lng=' -Method GET -Headers $headers

import http.client

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

headers = { 'x-access-token': "" }

conn.request("GET", "/baseUrl/forecast?lat=&lng=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/forecast"

querystring = {"lat":"","lng":""}

headers = {"x-access-token": ""}

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

print(response.json())

library(httr)

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

queryString <- list(
  lat = "",
  lng = ""
)

response <- VERB("GET", url, query = queryString, add_headers('x-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/forecast?lat=&lng=")

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

request = Net::HTTP::Get.new(url)
request["x-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/forecast') do |req|
  req.headers['x-access-token'] = ''
  req.params['lat'] = ''
  req.params['lng'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("lat", ""),
        ("lng", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/forecast?lat=&lng=' \
  --header 'x-access-token: '

http GET '{{baseUrl}}/forecast?lat=&lng=' \
  x-access-token:''

wget --quiet \
  --method GET \
  --header 'x-access-token: ' \
  --output-document \
  - '{{baseUrl}}/forecast?lat=&lng='

import Foundation

let headers = ["x-access-token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/forecast?lat=&lng=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()

GET Get real-time UV Index by location. Optional altitude, ozone level and datetime could be provided.

{{baseUrl}}/uv

HEADERS

x-access-token

QUERY PARAMS

lat

lng

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/uv?lat=&lng=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-access-token: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/uv" {:headers {:x-access-token ""}
                                              :query-params {:lat ""
                                                             :lng ""}})

require "http/client"

url = "{{baseUrl}}/uv?lat=&lng="
headers = HTTP::Headers{
  "x-access-token" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/uv?lat=&lng="),
    Headers =
    {
        { "x-access-token", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/uv?lat=&lng=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-access-token", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/uv?lat=&lng="

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

	req.Header.Add("x-access-token", "")

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

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

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

}

GET /baseUrl/uv?lat=&lng= HTTP/1.1
X-Access-Token: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/uv?lat=&lng=")
  .setHeader("x-access-token", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/uv?lat=&lng="))
    .header("x-access-token", "")
    .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}}/uv?lat=&lng=")
  .get()
  .addHeader("x-access-token", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/uv?lat=&lng=")
  .header("x-access-token", "")
  .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}}/uv?lat=&lng=');
xhr.setRequestHeader('x-access-token', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/uv',
  params: {lat: '', lng: ''},
  headers: {'x-access-token': ''}
};

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

const url = '{{baseUrl}}/uv?lat=&lng=';
const options = {method: 'GET', headers: {'x-access-token': ''}};

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}}/uv?lat=&lng=',
  method: 'GET',
  headers: {
    'x-access-token': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/uv?lat=&lng=")
  .get()
  .addHeader("x-access-token", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/uv?lat=&lng=',
  headers: {
    'x-access-token': ''
  }
};

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}}/uv',
  qs: {lat: '', lng: ''},
  headers: {'x-access-token': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.query({
  lat: '',
  lng: ''
});

req.headers({
  'x-access-token': ''
});

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}}/uv',
  params: {lat: '', lng: ''},
  headers: {'x-access-token': ''}
};

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

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

const url = '{{baseUrl}}/uv?lat=&lng=';
const options = {method: 'GET', headers: {'x-access-token': ''}};

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

#import 

NSDictionary *headers = @{ @"x-access-token": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/uv?lat=&lng="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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}}/uv?lat=&lng=" in
let headers = Header.add (Header.init ()) "x-access-token" "" in

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

 "{{baseUrl}}/uv?lat=&lng=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-access-token: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/uv?lat=&lng=', [
  'headers' => [
    'x-access-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/uv');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lat' => '',
  'lng' => ''
]);

$request->setHeaders([
  'x-access-token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/uv');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lat' => '',
  'lng' => ''
]));

$request->setHeaders([
  'x-access-token' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-access-token", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/uv?lat=&lng=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-access-token", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/uv?lat=&lng=' -Method GET -Headers $headers

import http.client

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

headers = { 'x-access-token': "" }

conn.request("GET", "/baseUrl/uv?lat=&lng=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/uv"

querystring = {"lat":"","lng":""}

headers = {"x-access-token": ""}

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

print(response.json())

library(httr)

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

queryString <- list(
  lat = "",
  lng = ""
)

response <- VERB("GET", url, query = queryString, add_headers('x-access-token' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/uv?lat=&lng=")

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

request = Net::HTTP::Get.new(url)
request["x-access-token"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/uv') do |req|
  req.headers['x-access-token'] = ''
  req.params['lat'] = ''
  req.params['lng'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("lat", ""),
        ("lng", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-access-token", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/uv?lat=&lng=' \
  --header 'x-access-token: '

http GET '{{baseUrl}}/uv?lat=&lng=' \
  x-access-token:''

wget --quiet \
  --method GET \
  --header 'x-access-token: ' \
  --output-document \
  - '{{baseUrl}}/uv?lat=&lng='

import Foundation

let headers = ["x-access-token": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/uv?lat=&lng=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()