> ## Documentation Index
> Fetch the complete documentation index at: https://nixtla.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# SDK Reference
***
source
## NixtlaClient
> ```text theme={null}
> NixtlaClient (api_key:Optional[str]=None, base_url:Optional[str]=None,
> timeout:Optional[int]=60, max_retries:int=6,
> retry_interval:int=10, max_wait_time:int=360)
> ```
*Client to interact with the Nixtla API.*
| | **Type** | **Default** | **Details** |
| --------------- | -------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| api\_key | Optional | None | The authorization api\_key interacts with the Nixtla API.
If not provided, will use the NIXTLA\_API\_KEY environment variable. |
| base\_url | Optional | None | Custom base\_url.
If not provided, will use the NIXTLA\_BASE\_URL environment variable. |
| timeout | Optional | 60 | Request timeout in seconds. Set this to `None` to disable it. |
| max\_retries | int | 6 | The maximum number of attempts to make when calling the API before giving up.
It defines how many times the client will retry the API call if it fails.
Default value is 6, indicating the client will attempt the API call up to 6 times in total |
| retry\_interval | int | 10 | The interval in seconds between consecutive retry attempts.
This is the waiting period before the client tries to call the API again after a failed attempt.
Default value is 10 seconds, meaning the client waits for 10 seconds between retries. |
| max\_wait\_time | int | 360 | The maximum total time in seconds that the client will spend on all retry attempts before giving up.
This sets an upper limit on the cumulative waiting time for all retry attempts.
If this time is exceeded, the client will stop retrying and raise an exception.
Default value is 360 seconds, meaning the client will cease retrying if the total time
spent on retries exceeds 360 seconds.
The client throws a ReadTimeout error after 60 seconds of inactivity. If you want to
catch these errors, use max\_wait\_time >> 60. |
***
source
## NixtlaClient.validate\_api\_key
> ```text theme={null}
> NixtlaClient.validate_api_key (log:bool=True)
> ```
*Check API key status.*
| | **Type** | **Default** | **Details** |
| ----------- | -------- | ----------- | ----------------------------- |
| log | bool | True | Show the endpoint’s response. |
| **Returns** | **bool** | | **Whether API key is valid.** |
***
source
## NixtlaClient.forecast
> ```text theme={null}
> NixtlaClient.forecast (df:~AnyDFType, h:typing.Annotated[int,Gt(gt=0)],
> freq:Union[str,int,pandas._libs.tslibs.offsets.Bas
> eOffset,NoneType]=None, id_col:str='unique_id',
> time_col:str='ds', target_col:str='y',
> X_df:Optional[~AnyDFType]=None,
> level:Optional[list[Union[int,float]]]=None,
> quantiles:Optional[list[float]]=None,
> finetune_steps:typing.Annotated[int,Ge(ge=0)]=0,
> finetune_depth:Literal[1,2,3,4,5]=1, finetune_loss
> :Literal['default','mae','mse','rmse','mape','smap
> e']='default',
> finetuned_model_id:Optional[str]=None,
> clean_ex_first:bool=True,
> hist_exog_list:Optional[list[str]]=None,
> validate_api_key:bool=False,
> add_history:bool=False, date_features:Union[bool,l
> ist[Union[str,Callable]]]=False, date_features_to_
> one_hot:Union[bool,list[str]]=False, model:Literal
> ['azureai','timegpt-1','timegpt-1-long-
> horizon']='timegpt-1', num_partitions:Optional[Ann
> otated[int,Gt(gt=0)]]=None,
> feature_contributions:bool=False)
> ```
*Forecast your time series using TimeGPT.*
| | **Type** | **Default** | **Details** |
| ---------------------------- | ------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| df | AnyDFType | | The DataFrame on which the function will operate. Expected to contain at least the following columns:
- time\_col:
Column name in `df` that contains the time indices of the time series. This is typically a datetime
column with regular intervals, e.g., hourly, daily, monthly data points.
- target\_col:
Column name in `df` that contains the target variable of the time series, i.e., the variable we
wish to predict or analyze.
Additionally, you can pass multiple time series (stacked in the dataframe) considering an additional column:
- id\_col:
Column name in `df` that identifies unique time series. Each unique value in this column
corresponds to a unique time series. |
| h | Annotated | | Forecast horizon. |
| freq | Union | None | Frequency of the timestamps. If `None`, it will be inferred automatically.
See [pandas’ available frequencies](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases). |
| id\_col | str | unique\_id | Column that identifies each series. |
| time\_col | str | ds | Column that identifies each timestep, its values can be timestamps or integers. |
| target\_col | str | y | Column that contains the target. |
| X\_df | Optional | None | DataFrame with \[`unique_id`, `ds`] columns and `df`’s future exogenous. |
| level | Optional | None | Confidence levels between 0 and 100 for prediction intervals. |
| quantiles | Optional | None | Quantiles to forecast, list between (0, 1).
`level` and `quantiles` should not be used simultaneously.
The output dataframe will have the quantile columns
formatted as TimeGPT-q-(100 \* q) for each q.
100 \* q represents percentiles but we choose this notation
to avoid having dots in column names. |
| finetune\_steps | Annotated | 0 | Number of steps used to finetune learning TimeGPT in the
new data. |
| finetune\_depth | Literal | 1 | The depth of the finetuning. Uses a scale from 1 to 5, where 1 means little finetuning,
and 5 means that the entire model is finetuned. |
| finetune\_loss | Literal | default | Loss function to use for finetuning. Options are: `default`, `mae`, `mse`, `rmse`, `mape`, and `smape`. |
| finetuned\_model\_id | Optional | None | ID of previously fine-tuned model to use. |
| clean\_ex\_first | bool | True | Clean exogenous signal before making forecasts using TimeGPT. |
| hist\_exog\_list | Optional | None | Column names of the historical exogenous features. |
| validate\_api\_key | bool | False | If True, validates api\_key before sending requests. |
| add\_history | bool | False | Return fitted values of the model. |
| date\_features | Union | False | Features computed from the dates.
Can be pandas date attributes or functions that will take the dates as input.
If True automatically adds most used date features for the
frequency of `df`. |
| date\_features\_to\_one\_hot | Union | False | Apply one-hot encoding to these date features.
If `date_features=True`, then all date features are
one-hot encoded by default. |
| model | Literal | timegpt-1 | Model to use as a string. Options are: `timegpt-1`, and `timegpt-1-long-horizon`.
We recommend using `timegpt-1-long-horizon` for forecasting
if you want to predict more than one seasonal
period given the frequency of your data. |
| num\_partitions | Optional | None | Number of partitions to use.
If None, the number of partitions will be equal
to the available parallel resources in distributed environments. |
| feature\_contributions | bool | False | |
| **Returns** | **AnyDFType** | | **DataFrame with TimeGPT forecasts for point predictions and probabilistic
predictions (if level is not None).** |
***
source
## NixtlaClient.cross\_validation
> ```text theme={null}
> NixtlaClient.cross_validation (df:~AnyDFType,
> h:typing.Annotated[int,Gt(gt=0)], freq:Uni
> on[str,int,pandas._libs.tslibs.offsets.Bas
> eOffset,NoneType]=None,
> id_col:str='unique_id', time_col:str='ds',
> target_col:str='y', level:Optional[list[Un
> ion[int,float]]]=None,
> quantiles:Optional[list[float]]=None,
> validate_api_key:bool=False, n_windows:typ
> ing.Annotated[int,Gt(gt=0)]=1, step_size:O
> ptional[Annotated[int,Gt(gt=0)]]=None, fin
> etune_steps:typing.Annotated[int,Ge(ge=0)]
> =0, finetune_depth:Literal[1,2,3,4,5]=1, f
> inetune_loss:Literal['default','mae','mse'
> ,'rmse','mape','smape']='default',
> finetuned_model_id:Optional[str]=None,
> refit:bool=True, clean_ex_first:bool=True,
> hist_exog_list:Optional[list[str]]=None,
> date_features:Union[bool,list[str]]=False,
> date_features_to_one_hot:Union[bool,list[s
> tr]]=False, model:Literal['azureai','timeg
> pt-1','timegpt-1-long-
> horizon']='timegpt-1', num_partitions:Opti
> onal[Annotated[int,Gt(gt=0)]]=None)
> ```
*Perform cross validation in your time series using TimeGPT.*
| | **Type** | **Default** | **Details** |
| ---------------------------- | ------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| df | AnyDFType | | The DataFrame on which the function will operate. Expected to contain at least the following columns:
- time\_col:
Column name in `df` that contains the time indices of the time series. This is typically a datetime
column with regular intervals, e.g., hourly, daily, monthly data points.
- target\_col:
Column name in `df` that contains the target variable of the time series, i.e., the variable we
wish to predict or analyze.
Additionally, you can pass multiple time series (stacked in the dataframe) considering an additional column:
- id\_col:
Column name in `df` that identifies unique time series. Each unique value in this column
corresponds to a unique time series. |
| h | Annotated | | Forecast horizon. |
| freq | Union | None | Frequency of the timestamps. If `None`, it will be inferred automatically.
See [pandas’ available frequencies](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases). |
| id\_col | str | unique\_id | Column that identifies each series. |
| time\_col | str | ds | Column that identifies each timestep, its values can be timestamps or integers. |
| target\_col | str | y | Column that contains the target. |
| level | Optional | None | Confidence level between 0 and 100 for prediction intervals. |
| quantiles | Optional | None | Quantiles to forecast, list between (0, 1).
`level` and `quantiles` should not be used simultaneously.
The output dataframe will have the quantile columns
formatted as TimeGPT-q-(100 \* q) for each q.
100 \* q represents percentiles but we choose this notation
to avoid having dots in column names. |
| validate\_api\_key | bool | False | If True, validates api\_key before sending requests. |
| n\_windows | Annotated | 1 | Number of windows to evaluate. |
| step\_size | Optional | None | Step size between each cross validation window. If None it will be equal to `h`. |
| finetune\_steps | Annotated | 0 | Number of steps used to finetune TimeGPT in the
new data. |
| finetune\_depth | Literal | 1 | The depth of the finetuning. Uses a scale from 1 to 5, where 1 means little finetuning,
and 5 means that the entire model is finetuned. |
| finetune\_loss | Literal | default | Loss function to use for finetuning. Options are: `default`, `mae`, `mse`, `rmse`, `mape`, and `smape`. |
| finetuned\_model\_id | Optional | None | ID of previously fine-tuned model to use. |
| refit | bool | True | Fine-tune the model in each window. If `False`, only fine-tunes on the first window.
Only used if `finetune_steps` > 0. |
| clean\_ex\_first | bool | True | Clean exogenous signal before making forecasts using TimeGPT. |
| hist\_exog\_list | Optional | None | Column names of the historical exogenous features. |
| date\_features | Union | False | Features computed from the dates.
Can be pandas date attributes or functions that will take the dates as input.
If True automatically adds most used date features for the
frequency of `df`. |
| date\_features\_to\_one\_hot | Union | False | Apply one-hot encoding to these date features.
If `date_features=True`, then all date features are
one-hot encoded by default. |
| model | Literal | timegpt-1 | Model to use as a string. Options are: `timegpt-1`, and `timegpt-1-long-horizon`.
We recommend using `timegpt-1-long-horizon` for forecasting
if you want to predict more than one seasonal
period given the frequency of your data. |
| num\_partitions | Optional | None | Number of partitions to use.
If None, the number of partitions will be equal
to the available parallel resources in distributed environments. |
| **Returns** | **AnyDFType** | | **DataFrame with cross validation forecasts.** |
***
source
## NixtlaClient.detect\_anomalies
> ```text theme={null}
> NixtlaClient.detect_anomalies (df:~AnyDFType,
> freq:Union[str,int,pandas._libs.tslibs.off
> sets.BaseOffset,NoneType]=None,
> id_col:str='unique_id', time_col:str='ds',
> target_col:str='y',
> level:Union[int,float]=99,
> finetuned_model_id:Optional[str]=None,
> clean_ex_first:bool=True,
> validate_api_key:bool=False,
> date_features:Union[bool,list[str]]=False,
> date_features_to_one_hot:Union[bool,list[s
> tr]]=False, model:Literal['azureai','timeg
> pt-1','timegpt-1-long-
> horizon']='timegpt-1', num_partitions:Opti
> onal[Annotated[int,Gt(gt=0)]]=None)
> ```
*Detect anomalies in your time series using TimeGPT.*
| | **Type** | **Default** | **Details** |
| ---------------------------- | ------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| df | AnyDFType | | The DataFrame on which the function will operate. Expected to contain at least the following columns:
- time\_col:
Column name in `df` that contains the time indices of the time series. This is typically a datetime
column with regular intervals, e.g., hourly, daily, monthly data points.
- target\_col:
Column name in `df` that contains the target variable of the time series, i.e., the variable we
wish to predict or analyze.
Additionally, you can pass multiple time series (stacked in the dataframe) considering an additional column:
- id\_col:
Column name in `df` that identifies unique time series. Each unique value in this column
corresponds to a unique time series. |
| freq | Union | None | Frequency of the timestamps. If `None`, it will be inferred automatically.
See [pandas’ available frequencies](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases). |
| id\_col | str | unique\_id | Column that identifies each series. |
| time\_col | str | ds | Column that identifies each timestep, its values can be timestamps or integers. |
| target\_col | str | y | Column that contains the target. |
| level | Union | 99 | Confidence level between 0 and 100 for detecting the anomalies. |
| finetuned\_model\_id | Optional | None | ID of previously fine-tuned model to use. |
| clean\_ex\_first | bool | True | Clean exogenous signal before making forecasts
using TimeGPT. |
| validate\_api\_key | bool | False | If True, validates api\_key before sending requests. |
| date\_features | Union | False | Features computed from the dates.
Can be pandas date attributes or functions that will take the dates as input.
If True automatically adds most used date features for the
frequency of `df`. |
| date\_features\_to\_one\_hot | Union | False | Apply one-hot encoding to these date features.
If `date_features=True`, then all date features are
one-hot encoded by default. |
| model | Literal | timegpt-1 | Model to use as a string. Options are: `timegpt-1`, and `timegpt-1-long-horizon`.
We recommend using `timegpt-1-long-horizon` for forecasting
if you want to predict more than one seasonal
period given the frequency of your data. |
| num\_partitions | Optional | None | Number of partitions to use.
If None, the number of partitions will be equal
to the available parallel resources in distributed environments. |
| **Returns** | **AnyDFType** | | **DataFrame with anomalies flagged by TimeGPT.** |
***
source
## NixtlaClient.usage
> ```text theme={null}
> NixtlaClient.usage ()
> ```
*Query consumed requests and limits*
***
source
## NixtlaClient.finetune
> ```text theme={null}
> NixtlaClient.finetune
> (df:Union[pandas.core.frame.DataFrame,polars.dataf
> rame.frame.DataFrame], freq:Union[str,int,pandas._
> libs.tslibs.offsets.BaseOffset,NoneType]=None,
> id_col:str='unique_id', time_col:str='ds',
> target_col:str='y',
> finetune_steps:typing.Annotated[int,Ge(ge=0)]=10,
> finetune_depth:Literal[1,2,3,4,5]=1, finetune_loss
> :Literal['default','mae','mse','rmse','mape','smap
> e']='default', output_model_id:Optional[str]=None,
> finetuned_model_id:Optional[str]=None, model:Liter
> al['azureai','timegpt-1','timegpt-1-long-
> horizon']='timegpt-1')
> ```
*Fine-tune TimeGPT to your series.*
| | **Type** | **Default** | **Details** |
| -------------------- | --------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| df | Union | | The DataFrame on which the function will operate. Expected to contain at least the following columns:
- time\_col:
Column name in `df` that contains the time indices of the time series. This is typically a datetime
column with regular intervals, e.g., hourly, daily, monthly data points.
- target\_col:
Column name in `df` that contains the target variable of the time series, i.e., the variable we
wish to predict or analyze.
Additionally, you can pass multiple time series (stacked in the dataframe) considering an additional column:
- id\_col:
Column name in `df` that identifies unique time series. Each unique value in this column
corresponds to a unique time series. |
| freq | Union | None | Frequency of the timestamps. If `None`, it will be inferred automatically.
See [pandas’ available frequencies](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases). |
| id\_col | str | unique\_id | Column that identifies each series. |
| time\_col | str | ds | Column that identifies each timestep, its values can be timestamps or integers. |
| target\_col | str | y | Column that contains the target. |
| finetune\_steps | Annotated | 10 | Number of steps used to finetune learning TimeGPT in the new data. |
| finetune\_depth | Literal | 1 | The depth of the finetuning. Uses a scale from 1 to 5, where 1 means little finetuning,
and 5 means that the entire model is finetuned. |
| finetune\_loss | Literal | default | Loss function to use for finetuning. Options are: `default`, `mae`, `mse`, `rmse`, `mape`, and `smape`. |
| output\_model\_id | Optional | None | ID to assign to the fine-tuned model. If `None`, an UUID is used. |
| finetuned\_model\_id | Optional | None | ID of previously fine-tuned model to use as base. |
| model | Literal | timegpt-1 | Model to use as a string. Options are: `timegpt-1`, and `timegpt-1-long-horizon`.
We recommend using `timegpt-1-long-horizon` for forecasting
if you want to predict more than one seasonal
period given the frequency of your data. |
| **Returns** | **str** | | **ID of the fine-tuned model** |
***
source
## NixtlaClient.finetuned\_models
> ```text theme={null}
> NixtlaClient.finetuned_models (as_df:bool=False)
> ```
*List fine-tuned models*
| | **Type** | **Default** | **Details** |
| ----------- | --------- | ----------- | -------------------------------------------------- |
| as\_df | bool | False | Return the fine-tuned models as a pandas dataframe |
| **Returns** | **Union** | | **List of available fine-tuned models.** |
***
source
## NixtlaClient.finetuned\_model
> ```text theme={null}
> NixtlaClient.finetuned_model (finetuned_model_id:str)
> ```
*Get fine-tuned model metadata*
| | **Type** | **Details** |
| -------------------- | ------------------ | ------------------------------------------------ |
| finetuned\_model\_id | str | ID of the fine-tuned model to get metadata from. |
| **Returns** | **FinetunedModel** | **Fine-tuned model metadata.** |
***
source
## NixtlaClient.delete\_finetuned\_model
> ```text theme={null}
> NixtlaClient.delete_finetuned_model (finetuned_model_id:str)
> ```
*Delete a previously fine-tuned model*
| | **Type** | **Details** |
| -------------------- | -------- | ----------------------------------------- |
| finetuned\_model\_id | str | ID of the fine-tuned model to be deleted. |
| **Returns** | **bool** | **Whether delete was successful.** |
***
source
## NixtlaClient.plot
> ```text theme={null}
> NixtlaClient.plot (df:Union[pandas.core.frame.DataFrame,polars.dataframe.
> frame.DataFrame,NoneType]=None, forecasts_df:Union[pan
> das.core.frame.DataFrame,polars.dataframe.frame.DataFr
> ame,NoneType]=None, id_col:str='unique_id',
> time_col:str='ds', target_col:str='y', unique_ids:Unio
> n[list[str],NoneType,numpy.ndarray]=None,
> plot_random:bool=True, max_ids:int=8,
> models:Optional[list[str]]=None,
> level:Optional[list[Union[int,float]]]=None,
> max_insample_length:Optional[int]=None,
> plot_anomalies:bool=False,
> engine:Literal['matplotlib','plotly','plotly-
> resampler']='matplotlib',
> resampler_kwargs:Optional[dict]=None, ax:Union[Forward
> Ref('plt.Axes'),numpy.ndarray,ForwardRef('plotly.graph
> _objects.Figure'),NoneType]=None)
> ```
*Plot forecasts and insample values.*
| | **Type** | **Default** | **Details** |
| --------------------- | -------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| df | Union | None | The DataFrame on which the function will operate. Expected to contain at least the following columns:
- time\_col:
Column name in `df` that contains the time indices of the time series. This is typically a datetime
column with regular intervals, e.g., hourly, daily, monthly data points.
- target\_col:
Column name in `df` that contains the target variable of the time series, i.e., the variable we
wish to predict or analyze.
Additionally, you can pass multiple time series (stacked in the dataframe) considering an additional column:
- id\_col:
Column name in `df` that identifies unique time series. Each unique value in this column
corresponds to a unique time series. |
| forecasts\_df | Union | None | DataFrame with columns \[`unique_id`, `ds`] and models. |
| id\_col | str | unique\_id | Column that identifies each series. |
| time\_col | str | ds | Column that identifies each timestep, its values can be timestamps or integers. |
| target\_col | str | y | Column that contains the target. |
| unique\_ids | Union | None | Time Series to plot.
If None, time series are selected randomly. |
| plot\_random | bool | True | Select time series to plot randomly. |
| max\_ids | int | 8 | Maximum number of ids to plot. |
| models | Optional | None | list of models to plot. |
| level | Optional | None | list of prediction intervals to plot if paseed. |
| max\_insample\_length | Optional | None | Max number of train/insample observations to be plotted. |
| plot\_anomalies | bool | False | Plot anomalies for each prediction interval. |
| engine | Literal | matplotlib | Library used to plot. ‘matplotlib’, ‘plotly’ or ‘plotly-resampler’. |
| resampler\_kwargs | Optional | None | Kwargs to be passed to plotly-resampler constructor.
For further custumization (“show\_dash”) call the method,
store the plotting object and add the extra arguments to
its `show_dash` method. |
| ax | Union | None | Object where plots will be added. |