Request a Forecast

Request Time Series Forecast

curl --request POST \
  --url https://api.nolano.ai/forecast \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "series": [
    {
      "timestamps": [
        "2023-01-01T00:00:00",
        "2023-01-02T00:00:00",
        "2023-01-03T00:00:00"
      ],
      "values": [
        100.5,
        102.3,
        98.7
      ]
    }
  ],
  "forecast_horizon": 12,
  "data_frequency": "Daily",
  "forecast_frequency": "Daily",
  "confidence": 0.95
}
'

import requests

url = "https://api.nolano.ai/forecast"

payload = {
    "series": [
        {
            "timestamps": ["2023-01-01T00:00:00", "2023-01-02T00:00:00", "2023-01-03T00:00:00"],
            "values": [100.5, 102.3, 98.7]
        }
    ],
    "forecast_horizon": 12,
    "data_frequency": "Daily",
    "forecast_frequency": "Daily",
    "confidence": 0.95
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    series: [
      {
        timestamps: ['2023-01-01T00:00:00', '2023-01-02T00:00:00', '2023-01-03T00:00:00'],
        values: [100.5, 102.3, 98.7]
      }
    ],
    forecast_horizon: 12,
    data_frequency: 'Daily',
    forecast_frequency: 'Daily',
    confidence: 0.95
  })
};

fetch('https://api.nolano.ai/forecast', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.nolano.ai/forecast",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'series' => [
        [
                'timestamps' => [
                                '2023-01-01T00:00:00',
                                '2023-01-02T00:00:00',
                                '2023-01-03T00:00:00'
                ],
                'values' => [
                                100.5,
                                102.3,
                                98.7
                ]
        ]
    ],
    'forecast_horizon' => 12,
    'data_frequency' => 'Daily',
    'forecast_frequency' => 'Daily',
    'confidence' => 0.95
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://api.nolano.ai/forecast"

	payload := strings.NewReader("{\n  \"series\": [\n    {\n      \"timestamps\": [\n        \"2023-01-01T00:00:00\",\n        \"2023-01-02T00:00:00\",\n        \"2023-01-03T00:00:00\"\n      ],\n      \"values\": [\n        100.5,\n        102.3,\n        98.7\n      ]\n    }\n  ],\n  \"forecast_horizon\": 12,\n  \"data_frequency\": \"Daily\",\n  \"forecast_frequency\": \"Daily\",\n  \"confidence\": 0.95\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.nolano.ai/forecast")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"series\": [\n    {\n      \"timestamps\": [\n        \"2023-01-01T00:00:00\",\n        \"2023-01-02T00:00:00\",\n        \"2023-01-03T00:00:00\"\n      ],\n      \"values\": [\n        100.5,\n        102.3,\n        98.7\n      ]\n    }\n  ],\n  \"forecast_horizon\": 12,\n  \"data_frequency\": \"Daily\",\n  \"forecast_frequency\": \"Daily\",\n  \"confidence\": 0.95\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.nolano.ai/forecast")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"series\": [\n    {\n      \"timestamps\": [\n        \"2023-01-01T00:00:00\",\n        \"2023-01-02T00:00:00\",\n        \"2023-01-03T00:00:00\"\n      ],\n      \"values\": [\n        100.5,\n        102.3,\n        98.7\n      ]\n    }\n  ],\n  \"forecast_horizon\": 12,\n  \"data_frequency\": \"Daily\",\n  \"forecast_frequency\": \"Daily\",\n  \"confidence\": 0.95\n}"

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

{
  "forecast_timestamps": [
    "2024-01-01T00:00:00",
    "2024-01-02T00:00:00"
  ],
  "lower_bound": [
    145.2,
    146.8
  ],
  "median": [
    150,
    151.5
  ],
  "upper_bound": [
    154.8,
    156.2
  ]
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

POST

forecast

Request Time Series Forecast

curl --request POST \
  --url https://api.nolano.ai/forecast \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "series": [
    {
      "timestamps": [
        "2023-01-01T00:00:00",
        "2023-01-02T00:00:00",
        "2023-01-03T00:00:00"
      ],
      "values": [
        100.5,
        102.3,
        98.7
      ]
    }
  ],
  "forecast_horizon": 12,
  "data_frequency": "Daily",
  "forecast_frequency": "Daily",
  "confidence": 0.95
}
'

import requests

url = "https://api.nolano.ai/forecast"

payload = {
    "series": [
        {
            "timestamps": ["2023-01-01T00:00:00", "2023-01-02T00:00:00", "2023-01-03T00:00:00"],
            "values": [100.5, 102.3, 98.7]
        }
    ],
    "forecast_horizon": 12,
    "data_frequency": "Daily",
    "forecast_frequency": "Daily",
    "confidence": 0.95
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    series: [
      {
        timestamps: ['2023-01-01T00:00:00', '2023-01-02T00:00:00', '2023-01-03T00:00:00'],
        values: [100.5, 102.3, 98.7]
      }
    ],
    forecast_horizon: 12,
    data_frequency: 'Daily',
    forecast_frequency: 'Daily',
    confidence: 0.95
  })
};

fetch('https://api.nolano.ai/forecast', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.nolano.ai/forecast",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'series' => [
        [
                'timestamps' => [
                                '2023-01-01T00:00:00',
                                '2023-01-02T00:00:00',
                                '2023-01-03T00:00:00'
                ],
                'values' => [
                                100.5,
                                102.3,
                                98.7
                ]
        ]
    ],
    'forecast_horizon' => 12,
    'data_frequency' => 'Daily',
    'forecast_frequency' => 'Daily',
    'confidence' => 0.95
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://api.nolano.ai/forecast"

	payload := strings.NewReader("{\n  \"series\": [\n    {\n      \"timestamps\": [\n        \"2023-01-01T00:00:00\",\n        \"2023-01-02T00:00:00\",\n        \"2023-01-03T00:00:00\"\n      ],\n      \"values\": [\n        100.5,\n        102.3,\n        98.7\n      ]\n    }\n  ],\n  \"forecast_horizon\": 12,\n  \"data_frequency\": \"Daily\",\n  \"forecast_frequency\": \"Daily\",\n  \"confidence\": 0.95\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.nolano.ai/forecast")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"series\": [\n    {\n      \"timestamps\": [\n        \"2023-01-01T00:00:00\",\n        \"2023-01-02T00:00:00\",\n        \"2023-01-03T00:00:00\"\n      ],\n      \"values\": [\n        100.5,\n        102.3,\n        98.7\n      ]\n    }\n  ],\n  \"forecast_horizon\": 12,\n  \"data_frequency\": \"Daily\",\n  \"forecast_frequency\": \"Daily\",\n  \"confidence\": 0.95\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.nolano.ai/forecast")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"series\": [\n    {\n      \"timestamps\": [\n        \"2023-01-01T00:00:00\",\n        \"2023-01-02T00:00:00\",\n        \"2023-01-03T00:00:00\"\n      ],\n      \"values\": [\n        100.5,\n        102.3,\n        98.7\n      ]\n    }\n  ],\n  \"forecast_horizon\": 12,\n  \"data_frequency\": \"Daily\",\n  \"forecast_frequency\": \"Daily\",\n  \"confidence\": 0.95\n}"

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

{
  "forecast_timestamps": [
    "2024-01-01T00:00:00",
    "2024-01-02T00:00:00"
  ],
  "lower_bound": [
    145.2,
    146.8
  ],
  "median": [
    150,
    151.5
  ],
  "upper_bound": [
    154.8,
    156.2
  ]
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

{
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Validation failed for one or more fields",
    "details": {
      "field": "forecast_horizon",
      "issue": "Must be between 1 and 100",
      "provided": 150
    }
  }
}

Generate predictions for your time series data using state-of-the-art foundation models. This endpoint supports univariate forecasting with multiple model options optimized for different use cases.

Processing Time: Forecasts typically complete in 2-10 seconds depending on data size and model complexity.

Available Models

Choose the best model for your forecasting needs. Each model is optimized for specific use cases and data characteristics:

Model ID	Description	Best For
`forecast-model-1`	General-purpose foundation model (TOTO)	Most time series patterns
`forecast-model-2`	Trend-focused model	Data with strong trends
`forecast-model-3`	Seasonal model	Seasonal patterns
`forecast-model-4`	Volatility model	High-variance data

For detailed model information and performance characteristics, see our Supported Models page.

Example Requests

curl --location 'https://api.nolano.ai/forecast' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ak_your_api_key_here' \
--header 'X-Model-Id: forecast-model-1' \
--data '{
  "series": [
    {
      "timestamps": [
        "2023-01-01T00:00:00",
        "2023-01-02T00:00:00",
        "2023-01-03T00:00:00",
        "2023-01-04T00:00:00",
        "2023-01-05T00:00:00"
      ],
      "values": [100, 102, 98, 105, 103]
    }
  ],
  "forecast_horizon": 7,
  "data_frequency": "Daily",
  "forecast_frequency": "Daily",
  "confidence": 0.95
}'

import requests
import pandas as pd
import json

# Sample time series data
data = {
    'date': pd.date_range('2023-01-01', periods=30, freq='D'),
    'sales': [100 + i * 2 + (i % 7) * 5 for i in range(30)]
}
df = pd.DataFrame(data)

request_payload = {
    "series": [{
        "timestamps": df['date'].dt.strftime('%Y-%m-%dT%H:%M:%S').tolist(),
        "values": df['sales'].tolist()
    }],
    "forecast_horizon": 7,
    "data_frequency": "Daily", 
    "forecast_frequency": "Daily",
    "confidence": 0.95
}

response = requests.post(
    "https://api.nolano.ai/forecast",
    headers={
        'Content-Type': 'application/json',
        'Authorization': "Bearer ak_your_api_key_here",
        'X-Model-Id': 'forecast-model-1'
    },
    json=request_payload
)

if response.status_code == 200:
    forecast = response.json()
    print("Forecast successful!")
    print(f"Predicted values: {forecast['median']}")
else:
    print(f"Error: {response.status_code}")
    print(response.json())

const axios = require('axios');

const forecastData = {
  series: [{
    timestamps: [
      "2023-01-01T00:00:00",
      "2023-01-02T00:00:00", 
      "2023-01-03T00:00:00",
      "2023-01-04T00:00:00",
      "2023-01-05T00:00:00"
    ],
    values: [100, 102, 98, 105, 103]
  }],
  forecast_horizon: 7,
  data_frequency: "Daily",
  forecast_frequency: "Daily",
  confidence: 0.95
};

axios.post('https://api.nolano.ai/forecast', forecastData, {
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer ak_your_api_key_here',
    'X-Model-Id': 'forecast-model-1'
  }
})
.then(response => {
  console.log('Forecast successful!');
  console.log('Predicted values:', response.data.median);
})
.catch(error => {
  console.error('Error:', error.response?.data || error.message);
});

Response Format

The API returns forecast data with prediction intervals:

Example Response

{
  "forecast_timestamps": [
    "2024-01-01T00:00:00",
    "2024-01-02T00:00:00", 
    "2024-01-03T00:00:00"
  ],
  "lower_bound": [145.2, 146.8, 148.1],
  "median": [150.0, 151.5, 153.2],
  "upper_bound": [154.8, 156.2, 158.3]
}

Data Requirements

Minimum data points: 10 historical observations
Maximum forecast horizon: 100 periods
Supported frequencies: Seconds, Minutes, Hours, Daily, Weekly, Monthly, Quarterly, Yearly
Data format: Chronologically ordered timestamps with corresponding numerical values

Error Handling

The API returns structured error responses with specific error codes:

UNAUTHORIZED - Invalid or missing API key
INVALID_REQUEST - Validation failed for request parameters
DATA_VALIDATION_ERROR - Issues with time series data format
RATE_LIMIT_EXCEEDED - API rate limit exceeded
INTERNAL_ERROR - Unexpected server error

Always check the HTTP status code and parse the error object for detailed information about failures.

Authorizations

Authorization

string

header

required

API key authentication. Include your API key with 'Bearer' prefix.

Headers

X-Model-Id

enum<string>

default:forecast-model-1

Model ID to use for forecasting

Available options:

forecast-model-1,

forecast-model-2,

forecast-model-3,

forecast-model-4

Body

application/json

series

object[]

required

Array containing one time series object

Required array length: 1 element

Show child attributes

forecast_horizon

integer

required

Number of future periods to predict

Required range: 1 <= x <= 100

Example:

12

data_frequency

enum<string>

required

Frequency of input timestamps

Available options:

Seconds,

Minutes,

Hours,

Daily,

Weekly,

Monthly,

Quarterly,

Yearly

Example:

"Daily"

forecast_frequency

enum<string>

required

Desired frequency for forecast output (must match data_frequency)

Available options:

Seconds,

Minutes,

Hours,

Daily,

Weekly,

Monthly,

Quarterly,

Yearly

Example:

"Daily"

confidence

number

default:0.95

Confidence level for prediction intervals

Required range: 0.1 <= x <= 0.99

Example:

0.95

Response

Forecast generated successfully

forecast_timestamps

string<date-time>[]

required

Timestamps for forecasted periods

Example:

[
  "2024-01-01T00:00:00",
  "2024-01-02T00:00:00"
]

lower_bound

number<float>[]

required

Lower bounds of prediction intervals

Example:

[145.2, 146.8]

median

number<float>[]

required

Point forecasts (median predictions)

Example:

[150, 151.5]

upper_bound

number<float>[]

required

Upper bounds of prediction intervals

Example:

[154.8, 156.2]

Overview

Authentication

Forecasting

Available Models

Example Requests

Response Format

Data Requirements

Error Handling

Authorizations

Headers

Body

Response

​Available Models

​Example Requests

​Response Format

​Data Requirements

​Error Handling

Authorizations

Headers

Body

Response

Available Models

Example Requests

Response Format

Data Requirements

Error Handling