GET YOUR_QUERY_PATH HTTP/1.1
Host: engine.earthos.ai
Authorization: Bearer YOUR_API_TOKEN

pip install earthos

myformula = EOVar('gfs.relative_humidity')/100.0
data = eo.get_region(north=90.0, south=-90.0, east=180.0, west=-180.0, formula=myformula)
data.show()

era5.wind_speed - era5.wind_speed[time: -1 day]

gfs.air_temperature - 
(
  era5.air_temperature[time: -1 year] +
  era5.air_temperature[time: -2 years] + 
  era5.air_temperature[time: -3 years] + 
) / 3.0

gfs.air_pressure @ [latitude: -12.4637, longitude:  130.8444] - 
gfs.air_pressure @ [latitude: -17.6509, longitude: -149.4260]

(
  gfs.air_pressure @ [latitude: -12.4637, longitude:  130.8444] - 
  gfs.air_pressure @ [latitude: -17.6509, longitude: -149.4260]
) 
  -
(
  gfs.air_pressure @ [latitude: -12.4637, longitude:  130.8444] - 
  gfs.air_pressure @ [latitude: -17.6509, longitude: -149.4260]
)[time: -1 year]

(  
    (
         (
            ( era5.soil_water_level @[altitude:10])[latitude: 2.3, longitude: 2.3] 
         )[time: -1 day]
    )@[longitude: -19]
)@[time: 129422832, latitude: 50.3, longitude: 22.9, altitude: 2]

from earthos import EarthOS
eo = EarthOS('YOUR_API_KEY')

formula = '(gfs.air_temperature * 9 / 5) + 32'
latitude = 37.7749
longitude = -122.4194
altitude = 2
time = 1675800900

value = eo.get_point(latitude, longitude, time, formula)

package main

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

func main() {
  apiKey := "YOUR_API_KEY"
  apiUrl := "https://engine.earthos.ai/point/"

  client := &http.Client{}
  req, err := http.NewRequest("GET", apiUrl, nil)
  if err != nil {
    fmt.Println("Error creating request:", err)
    return
  }

  req.Header.Add("Authorization", "Bearer "+apiKey)

  params := url.Values{}
  params.Set("formula", "(gfs.air_temperature * 9 / 5) + 32")
  params.Set("latitude", "37.7749")
  params.Set("longitude", "-122.4194")
  params.Set("altitude", "2")
  params.Set("time", "1675800900")

  req.URL.RawQuery = params.Encode()

  resp, err := client.Do(req)
  if err != nil {
    fmt.Println("Error sending request:", err)
    return
  }
  defer resp.Body.Close()

  b, err := io.ReadAll(resp.Body)

  fmt.Println(string(b))
}

library(httr)

api_key <- "YOUR_API_KEY"
url <- "https://engine.earthos.ai/point/"

headers <- c(
  Authorization = paste("Bearer", api_key)
)

params <- list(
  formula = "(gfs.air_temperature * 9 / 5) + 32",
  latitude = 37.7749,
  longitude = -122.4194,
  altitude = 2,
  time = 1675800900
)

response <- GET(url, add_headers(headers), query = params)

content(response, "parsed")

using HTTP

api_key = "YOUR_API_KEY"
url = "https://engine.earthos.ai/point/"

headers = [
    "Authorization" => "Bearer $api_key"
]

params = Dict(
    "formula" => "(gfs.air_temperature * 9 / 5) + 32",
    "latitude" => 37.7749,
    "longitude" => -122.4194,
    "altitude" => 2,
    "time" => 1675800900
)

response = HTTP.get(url, headers=headers, query=params)

const axios = require('axios');

const apiKey = 'YOUR_API_KEY';
const url = 'https://engine.earthos.ai/point/';

const headers = {
  Authorization: `Bearer ${apiKey}`
};

const params = {
  formula: '(gfs.air_temperature * 9 / 5) + 32',
  latitude: 37.7749,
  longitude: -122.4194,
  altitude: 2,
  time: 1675800900
};

axios.get(url, { headers, params })
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.log('Error:', error);
  });

{
  "engine": "Ecosophy Formula Engine v0.3.1", 
  "formula": "(gfs.air_temperature * 9 / 5) + 32", 
  "spacetime": {
    "latitude": 37.774899, 
    "longitude": -122.419403, 
    "altitude": 2, 
    "time": 1675800900
  }, 
  "error": {"type": "NoError", "msg": ""}, 
  "result": 49.785204
}

from earthos import EarthOS
eo = EarthOS('YOUR_API_KEY')
payload = {
    "defaults": {
        "formula": "gfs.air_temperature",
        "timestamp": 1679933282,
        "altitude": 2,
        "latitude": -20
    },
    "points": [
        {
            "id": "1",
            "latitude": 66.0,
            "longitude": 23.0
        },
        {
            "id": "2",
            "latitude": 67.0,
            "longitude": 22.0
        },
        {
            "id": "3",
            "latitude": 60.0,
            "longitude": 20.0
        }
    ]
}

response = eo.get_points(payload)
print(response)

library(httr)

api_key <- "YOUR_API_KEY"
url <- "https://engine.earthos.ai/points/"

payload <- list(
  defaults = list(
    formula = "gfs.air_temperature",
    timestamp = 1679933282,
    altitude = 2,
    latitude = -20
  ),
  points = list(
    list(
      id = "1",
      latitude = 66.0,
      longitude = 23.0
    ),
    list(
      id = "2",
      latitude = 67.0,
      longitude = 22.0
    ),
    list(
      id = "3",
      latitude = 60.0,
      longitude = 20.0
    )
  )
)

headers <- c(
  'Content-Type' = 'application/json',
  'Authorization' = paste("Bearer", api_key)
)

response <- POST(url, body = toJSON(payload), encode = "json", add_headers(headers))

content <- content(response, as = "text")
data <- fromJSON(content)

print(data)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    apiKey := "YOUR_API_KEY"
    url := "https://engine.earthos.ai/points/"

    payload := map[string]interface{}{
        "defaults": map[string]interface{}{
            "formula":   "gfs.air_temperature",
            "timestamp": 1679933282,
            "altitude":  2,
            "latitude":  -20,
        },
        "points": []map[string]interface{}{
            {
                "id":        "1",
                "latitude":  66.0,
                "longitude": 23.0,
            },
            {
                "id":        "2",
                "latitude":  67.0,
                "longitude": 22.0,
            },
            {
                "id":        "3",
                "latitude":  60.0,
                "longitude": 20.0,
            },
        },
    }

    jsonPayload, err := json.Marshal(payload)
    if err != nil {
        fmt.Println("Error marshaling payload:", err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonPayload))
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer "+apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    var data map[string]interface{}
    err = json.NewDecoder(resp.Body).Decode(&data)
    if err != nil {
        fmt.Println("Error decoding response:", err)
        return
    }

    fmt.Println(data)
}

using HTTP
using JSON

api_key = "YOUR_API_KEY"
url = "https://engine.earthos.ai/points/"

payload = Dict(
    "defaults" => Dict(
        "formula" => "gfs.air_temperature",
        "timestamp" => 1679933282,
        "altitude" => 2,
        "latitude" => -20
    ),
    "points" => [
        Dict("id" => "1", "latitude" => 66.0, "longitude" => 23.0),
        Dict("id" => "2", "latitude" => 67.0, "longitude" => 22.0),
        Dict("id" => "3", "latitude" => 60.0, "longitude" => 20.0)
    ]
)

headers = Dict(
    "Content-Type" => "application/json",
    "Authorization" => "Bearer $api_key"
)

response = HTTP.post(url, headers, JSON.json(payload))

data = JSON.parse(String(response.body))

println(data)

const axios = require('axios');

const apiKey = 'YOUR_API_KEY';
const url = 'https://engine.earthos.ai/points/';

const payload = {
  defaults: {
    formula: 'gfs.air_temperature',
    timestamp: 1679933282,
    altitude: 2,
    latitude: -20
  },
  points: [
    {
      id: '1',
      latitude: 66.0,
      longitude: 23.0
    },
    {
      id: '2',
      latitude: 67.0,
      longitude: 22.0
    },
    {
      id: '3',
      latitude: 60.0,
      longitude: 20.0
    }
  ]
};

const headers = {
  'Content-Type': 'application/json',
  'Authorization': `Bearer ${apiKey}`
};

axios.post(url, payload, { headers })
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.log('Error:', error);
  });

{
  "engine": "Ecosophy Formula Engine v0.3.1", 
  "queries": 3, 
  "errors": 0, 
  "points": [
    {
      "id": "1", 
      "value": -5.775804, 
      "formula": "gfs.air_temperature", 
      "spacetime": {
        "latitude": 66, 
        "longitude": 23, 
        "altitude": 2, 
        "time": 1679933282
      }, 
      "error": {"type": "NoError", "msg": ""}
    }, 
    {
      "id": "2", 
      "value": -7.202588, 
      "formula": "gfs.air_temperature", 
      "spacetime": {
        "latitude": 67, 
        "longitude": 22, 
        "altitude": 2, 
        "time": 1679933282
      }, 
      "error": {"type": "NoError", "msg": ""}
    }, 
    {
      "id": "3", 
      "value": -3.715742, 
      "formula": "gfs.air_temperature", 
      "spacetime": {
        "latitude": 60, 
        "longitude": 20, 
        "altitude": 2, 
        "time": 1679933282
      }, 
      "error": {"type": "NoError", "msg": ""}
    }
  ]
}

from earthos import EarthOS, EOColorScale
north = 30
south = -30
east = 60
west = -60
time = 1687266935
size_x = 800
size_y = 400
eo = EarthOS('YOUR_API_KEY')
region = eo.get_region(north, south, east, west, time, 'gfs.lwe_precipitation_sum', size_x, size_y)

cs = EOColorScale(...) # Apply a color scale
region.save("region.png", cs)

library(httr)

api_key <- "YOUR_API_KEY"
url <- "https://engine.earthos.ai/map/"

headers <- c('Authorization' = paste("Bearer", api_key))

params <- list(
  time = 1687266935,
  formula = "gfs.lwe_precipitation_sum",
  min = 0,
  max = 90,
  colors = "6f6f6fff,3c74a0ff,3ba1a1ff,3ba13dff,82a13bff,a1a13bff,a13b3bff,a13ba1ff,a8a8a8ff",
  offsets = "0,0.012,0.12,0.16,0.2,0.3,0.4,0.62,1",
  north = 30,
  south = -30,
  east = 60,
  west = -60,
  width = 600,
  height = 300
)

response <- GET(url, add_headers(headers), query = params)

writeBin(content(response, "raw"), "map.png")

package main

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

func main() {
    apiKey := "YOUR_API_KEY"
    url := "https://engine.earthos.ai/map/"

    client := &http.Client{}
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)

    q := req.URL.Query()
    q.Add("time", "1687266935")
    q.Add("formula", "gfs.lwe_precipitation_sum")
    q.Add("min", "0")
    q.Add("max", "90")
    q.Add("colors", "6f6f6fff,3c74a0ff,3ba1a1ff,3ba13dff,82a13bff,a1a13bff,a13b3bff,a13ba1ff,a8a8a8ff")
    q.Add("offsets", "0,0.012,0.12,0.16,0.2,0.3,0.4,0.62,1")
    q.Add("north", "30")
    q.Add("south", "-30")
    q.Add("east", "60")
    q.Add("west", "-60")
    q.Add("width", "800")
    q.Add("height", "400")
    req.URL.RawQuery = q.Encode()

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    err = ioutil.WriteFile("map.png", body, 0644)
    if err != nil {
        fmt.Println("Error writing file:", err)
        return
    }

    fmt.Println("Map saved as map.png")
}

using HTTP
using FileIO

api_key = "YOUR_API_KEY"
url = "https://engine.earthos.ai/map/"

headers = Dict("Authorization" => "Bearer $api_key")

params = Dict(
    "time" => 1687266935,
    "formula" => "gfs.lwe_precipitation_sum",
    "min" => 0,
    "max" => 90,
    "colors" => "6f6f6fff,3c74a0ff,3ba1a1ff,3ba13dff,82a13bff,a1a13bff,a13b3bff,a13ba1ff,a8a8a8ff",
    "offsets" => "0,0.012,0.12,0.16,0.2,0.3,0.4,0.62,1",
    "north" => 30,
    "south" => -30,
    "east" => 60,
    "west" => -60,
    "width" => 800,
    "height" => 400
)

response = HTTP.get(url, headers=headers, query=params)

filename = "map.png"
save(filename, response.body)

const axios = require('axios');
const fs = require('fs');

const apiKey = 'YOUR_API_KEY';
const url = 'https://engine.earthos.ai/map/';

const headers = {
  Authorization: `Bearer ${apiKey}`
};

const params = {
  time: 1687266935,
  formula: 'gfs.lwe_precipitation_sum',
  min: 0,
  max: 90,
  colors: '6f6f6fff,3c74a0ff,3ba1a1ff,3ba13dff,82a13bff,a1a13bff,a13b3bff,a13ba1ff,a8a8a8ff',
  offsets: '0,0.012,0.12,0.16,0.2,0.3,0.4,0.62,1',
  north: 30,
  south: -30,
  east: 60,
  west: -60,
  width: 800,
  height: 400
};

axios.get(url, { headers, params, responseType: 'arraybuffer' })
  .then(response => {
    fs.writeFileSync('map.png', response.data);
    console.log('Map saved as map.png');
  })
  .catch(error => {
    console.log('Error:', error);
  });

from earthos import EarthOS, EOColorScale

# Map tile coordinates to look up
x = 3
y = 2
z = 3

eo = EarthOS('YOUR_API_KEY')
tile = eo.get_tile(x, y, z, 1682290466, 'gfs.air_pressure')

# Apply a color scale
cs = EOColorScale(
    colors = [
        (0x08, 0x10, 0x30, 0xff),(0x00, 0x20, 0x60, 0xff),(0x00, 0x34, 0x92, 0xff),(0x00, 0x5a, 0x94, 0xff),(0x00, 0x75, 0x92, 0xff),(0x1a, 0x8c, 0x93, 0xff),(0x67, 0xa2, 0x9b, 0xff),(0x9b, 0xb7, 0xac, 0xff),(0xb6, 0xb6, 0xb6, 0xff),(0xb0, 0xae, 0x98, 0xff),(0xa7, 0x93, 0x6b, 0xff),(0xa3, 0x74, 0x43, 0xff),(0x9f, 0x51, 0x2c, 0xff),(0x8e, 0x2f, 0x39, 0xff),(0x6f, 0x18, 0x40, 0xff),(0x30, 0x08, 0x18, 0xff)],
    offsets=[0.0,0.27,0.42,0.47,0.52,0.56,0.59,0.61,0.62,0.64,0.66,0.68,0.72,0.76,0.81,1.0],
    min=750,
    max=1100
)

tile.save("tile.png", cs)

library(httr)

x <- 3
y <- 2
z <- 3

api_key <- "YOUR_API_KEY"
url <- sprintf("https://engine.earthos.ai/maps/%d/%d/%d/", x, y, z)

headers <- c('Authorization' = paste("Bearer", api_key))

params <- list(
  'time' = 1682290466,
  'formula' = 'gfs.air_pressure',
  'min' = 750,
  'max' = 1100,
  'colors' = '081030ff,002060ff,003492ff,005a94ff,007592ff,1a8c93ff,67a29bff,9bb7acff,b6b6b6ff,b0ae98ff,a7936bff,a37443ff,9f512cff,8e2f39ff,6f1840ff,300818ff',
  'offsets' = '0.0,0.2777777777777778,0.4222222222222222,0.4777777777777778,0.5277777777777778,0.5666666666666667,0.5944444444444444,0.6180555555555556,0.6291666666666667,0.6402777777777777,0.6611111111111111,0.6888888888888889,0.7222222222222222,0.7666666666666667,0.8111111111111111,1.0'
)

response <- GET(url, add_headers(headers), query = params)

writeBin(content(response, "raw"), "tile.png")

package main

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

func main() {
    x := 3
    y := 2
    z := 3

    apiKey := "YOUR_API_KEY"
    url := fmt.Sprintf("https://engine.earthos.ai/maps/%d/%d/%d/", x, y, z)

    headers := map[string]string{
        "Authorization": "Bearer " + apiKey,
    }

    params := map[string]string{
        "time":    "1682290466",
        "formula": "gfs.air_pressure",
        "min":     "750",
        "max":     "1100",
        "colors":  "081030ff,002060ff,003492ff,005a94ff,007592ff,1a8c93ff,67a29bff,9bb7acff,b6b6b6ff,b0ae98ff,a7936bff,a37443ff,9f512cff,8e2f39ff,6f1840ff,300818ff",
        "offsets": "0.0,0.2777777777777778,0.4222222222222222,0.4777777777777778,0.5277777777777778,0.5666666666666667,0.5944444444444444,0.6180555555555556,0.6291666666666667,0.6402777777777777,0.6611111111111111,0.6888888888888889,0.7222222222222222,0.7666666666666667,0.8111111111111111,1.0",
    }

    client := &http.Client{}
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Authorization", headers["Authorization"])

    q := req.URL.Query()
    for key, value := range params {
        q.Add(key, value)
    }
    req.URL.RawQuery = q.Encode()

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    err = ioutil.WriteFile("tile.png", body, 0644)
    if err != nil {
        fmt.Println("Error writing file:", err)
        return
    }

    fmt.Println("Tile saved as tile.png")
}

using HTTP
using FileIO

x = 3
y = 2
z = 3

api_key = "YOUR_API_KEY"
url = "https://engine.earthos.ai/maps/$x/$y/$z/"

headers = Dict("Authorization" => "Bearer $api_key")

params = Dict(
    "time" => 1682290466,
    "formula" => "gfs.air_pressure",
    "min" => 750,
    "max" => 1100,
    "colors" => "081030ff,002060ff,003492ff,005a94ff,007592ff,1a8c93ff,67a29bff,9bb7acff,b6b6b6ff,b0ae98ff,a7936bff,a37443ff,9f512cff,8e2f39ff,6f1840ff,300818ff",
    "offsets" => "0.0,0.2777777777777778,0.4222222222222222,0.4777777777777778,0.5277777777777778,0.5666666666666667,0.5944444444444444,0.6180555555555556,0.6291666666666667,0.6402777777777777,0.6611111111111111,0.6888888888888889,0.7222222222222222,0.7666666666666667,0.8111111111111111,1.0"
)

response = HTTP.get(url, headers=headers, params=params)

write("tile.png", response.body)

const axios = require('axios');
const fs = require('fs');

const x = 3;
const y = 2;
const z = 3;

const apiKey = 'YOUR_API_KEY';
const url = `https://engine.earthos.ai/maps/${x}/${y}/${z}/`;

const headers = {
  'Authorization': `Bearer ${apiKey}`
};

const params = {
  'time': 1682290466,
  'formula': 'gfs.air_pressure',
  'min': 750,
  'max': 1100,
  'colors': '081030ff,002060ff,003492ff,005a94ff,007592ff,1a8c93ff,67a29bff,9bb7acff,b6b6b6ff,b0ae98ff,a7936bff,a37443ff,9f512cff,8e2f39ff,6f1840ff,300818ff',
  'offsets': '0.0,0.2777777777777778,0.4222222222222222,0.4777777777777778,0.5277777777777778,0.5666666666666667,0.5944444444444444,0.6180555555555556,0.6291666666666667,0.6402777777777777,0.6611111111111111,0.6888888888888889,0.7222222222222222,0.7666666666666667,0.8111111111111111,1.0'
};

axios.get(url, { headers, params, responseType: 'arraybuffer' })
  .then(response => {
    fs.writeFileSync('tile.png', response.data);
    console.log('Tile saved as tile.png');
  })
  .catch(error => {
    console.log('Error:', error);
  });

from earthos import EarthOS
eo = EarthOS('YOUR_API_KEY')
vars = eo.get_variables()

library(httr)

api_key <- "YOUR_API_KEY"
url <- "https://engine.earthos.ai/variables/"

headers <- c("Authorization" = paste("Bearer", api_key))

response <- GET(url, add_headers(headers))

print(content(response, "parsed"))

package main

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

func main() {
    apiKey := "YOUR_API_KEY"
    url := "https://engine.earthos.ai/variables/"

    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", "Bearer " + apiKey)

    client := &http.Client{}
    resp, _ := client.Do(req)

    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)

    fmt.Println(string(body))
}

using HTTP

api_key = "YOUR_API_KEY"
url = "https://engine.earthos.ai/variables/"

headers = Dict("Authorization" => "Bearer $api_key")

response = HTTP.get(url, headers=headers)

println(String(response.body))

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

const api_key = 'YOUR_API_KEY';
const url = 'https://engine.earthos.ai/variables/';

const headers = {
  'Authorization': `Bearer ${api_key}`
};

fetch(url, { headers })
  .then(response => response.json())
  .then(data => console.log(data));

import requests

api_key = 'YOUR_API_KEY'
url = 'https://engine.earthos.ai/analyze/'

headers = {
    'Authorization': f'Bearer {api_key}'
}

params = {
    'formula': '$gfs.air_pressure@[lat: -12.4637, lon:  130.8444] - $gfs.air_pressure@[lat: -17.6509, lon: -149.4260]',
    'latitude': 64.3,
    'longitude': -22.3,
    'altitude': 2,
    'time': 1682290466
}

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

print(response.json())

{
    "engine": "Ecosophy Formula Engine v0.3.1",
    "formula": "$gfs.air_pressure@[lat: -12.4637, lon:  130.8444] - $gfs.air_pressure@[lat: -17.6509, lon: -149.4260]",
    "spacetime": {
        "latitude": 64.300003,
        "longitude": -22.299999,
        "altitude": 2,
        "time": 1682290466
    },
    "variables": [
        {
            "namespace": "gfs",
            "name": "air_pressure",
            "type": "SPATIOTEMPORAL",
            "source_type": "ES_DENSE",
            "description": "Air pressure in hPa."
        }
    ],
    "maps": [
        {
            "name": "gfs.air_pressure",
            "dhash": "a7aeba64d99f6dc115840c884dc89c134f91998efb1557332b07ac87ed74a4e4",
            "server": "data01.ecosophy.is",
            "format": 1,
            "time_start": 1682283600,
            "time_end": 1682287200,
            "north": 90,
            "south": -90,
            "east": 179.75,
            "west": -180,
            "altitude": 0
        },
    ],
    "parse_successful": true,
    "typecheck_successful": true,
    "error": {
        "type": "NoError",
        "msg": ""
    },
    "result": 21.619995
}