Time series forecasting predicts future values by learning patterns from past data. It is widely used in sales, finance, energy, web traffic, inventory planning, and business decision-making. But a lot has changed since the advent of advance ML models.

Forecasting has moved from traditional statistical models to neural and foundation-model approaches. Tools like Prophet, NeuralProphet, TimeGPT, and Chronos reflect this shift, each balancing accuracy, scalability, explainability, and production needs differently. In this article, we will compare these tools and understand where each one fits best in the time forecasting spectrum.

Choosing a forecasting tool is not only about finding the most accurate model. In real projects, teams also need to think about explainability, scalability, speed, cost, and deployment needs. Some forecasts must be simple enough for business users to understand, while others must handle thousands of time series quickly. Prophet, NeuralProphet, TimeGPT, and Chronos solve different forecasting problems. Prophet focuses on clarity and interpretability, NeuralProphet adds lag-based learning, TimeGPT reduces setup through an API, and Chronos supports open-weight foundation-model forecasting. 

Hands-On Implementation Approach

Before testing the forecasting tools, the required libraries must be installed. Prophet and NeuralProphet are used for local model training, TimeGPT needs the Nixtla SDK and an API key, and Chronos can be used through the Chronos forecasting package or AutoGluon.  

# These are the libraries required for using all of the tools covered in this article
pip install prophet
pip install neuralprophet
pip install nixtla
pip install chronos-forecasting
pip install autogluon.timeseries 

These commands install the main packages required to run for Prophet, NeuralProphet, TimeGPT, and Chronos. 

Prophet

Prophet is a simple, explainable, open-source forecasting tool developed by Facebook. It works well for business data with trends, seasonality, holidays, and recurring events, making it useful for sales, demand, and web traffic forecasting.

Prophet requires two columns: ds for the date or timestamp and y for the target value. Once trained, it can generate future forecasts with uncertainty intervals, making it a strong baseline before trying NeuralProphet, TimeGPT, or Chronos.

Prophet Workflow Diagram

Prophet Code

import pandas as pd
from prophet import Prophet

df = pd.DataFrame({
    "ds": pd.date_range("2024-01-01", periods=200, freq="D"),
    "y": range(200),
})

model = Prophet()
model.fit(df)

future = model.make_future_dataframe(periods=30)
forecast = model.predict(future)

print(forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail())

This code creates a simple daily time series dataset using Pandas. The ds column contains dates, and the y column contains the values to forecast. The Prophet model is then initialized and trained using the historical data. After training, make_future_dataframe() creates dates for the next 30 days. The predict() function generates the forecast. The output includes that, which is the predicted value, along with yhat_lower and yhat_upper, which show the uncertainty range. 

NeuralProphet

After Prophet, the next model to discuss is NeuralProphet because it builds on the same idea but adds more flexibility. NeuralProphet keeps the familiar Prophet-style structure of trend and seasonality, but it also adds neural network features such as autoregression, lagged values, covariates, and PyTorch-based training. This makes it useful when recent past values have a strong effect on future values. For example, in web traffic, electricity demand, or sales forecasting, the last few days or hours may strongly influence the next prediction. 

NeuralProphet is a good choice when Prophet is too simple but the team still wants a model that is easier to understand than a fully black-box deep learning model. It acts as a bridge between traditional explainable forecasting and neural forecasting. Like Prophet, it uses ds for dates and y for target values, but it gives more room to capture short-term patterns and lag behavior. 

NeuralProphet Workflow Diagram

NeuralProphet Code

import pandas as pd
import torch
from neuralprophet import NeuralProphet, configure
import torch.serialization
import torch.nn as nn
import torch.optim as optim

# Patch torch.load to use weights_only=False
# This helps with NeuralProphet compatibility.
_original_torch_load = torch.load


def _patched_torch_load(*args, **kwargs):
    kwargs.setdefault("weights_only", False)
    return _original_torch_load(*args, **kwargs)


torch.load = _patched_torch_load

df = pd.DataFrame({
    "ds": pd.date_range("2024-01-01", periods=200, freq="D"),
    "y": range(200),
})

model = NeuralProphet()

metrics = model.fit(df, freq="D")

future = model.make_future_dataframe(df, periods=30)
forecast = model.predict(future)

print(forecast[["ds", "yhat1"]].tail())

This code creates a daily time series dataset with four columns: ds (dates), y (target values), temperature (lagged regressor), and promo (future regressor). 

The model is initialized with n_lags=7 to use the past 7 days as autoregressive inputs and n_forecasts=3 to predict 3 steps ahead simultaneously. add_lagged_regressor("temperature") adds a covariate whose future values are unknown, while add_future_regressor("promo") adds one whose future values are known in advance and must be manually supplied in the future dataframe before calling predict(). 

After fitting, the output contains three forecast columns — yhat1, yhat2, and yhat3 — representing predictions 1, 2, and 3 days ahead respectively. 

TimeGPT

After Prophet and NeuralProphet, TimeGPT is the next forecasting tool to consider. Developed by Nixtla, it is a managed foundation model accessed through an API, so it does not require local training for each task.

TimeGPT is useful for fast forecasting, zero-shot use cases, multiple time series, exogenous variables, and probabilistic forecasts. Its simplicity is the main advantage, but teams should consider privacy, cost, governance, and vendor dependency because it is closed source and API-based.

TimeGPT Workflow Diagram

TimeGPT Code

import os

import pandas as pd
from nixtla import NixtlaClient

df = pd.DataFrame({
    "ds": pd.date_range("2024-01-01", periods=200, freq="D"),
    "y": range(200),
})

client = NixtlaClient(api_key=os.environ["NIXTLA_API_KEY"])

forecast = client.forecast(
    df=df,
    h=30,
    time_col="ds",
    target_col="y",
)

# print(forecast.tail())

This code creates a simple daily time series dataset with two columns: ds and y. The ds column contains the dates, and the y column contains the values to forecast. The NixtlaClient is initialized using an API key stored in the environment variable NIXTLA_API_KEY. 

The forecast() sends the data to TimeGPT and asks for a 30-step forecast using h=30. The arguments time_col="ds" and target_col="y" tell TimeGPT which column contains time values and which column contains the target values. The output contains the future forecasted values returned by the API. 

Chronos

Chronos is an open-weight foundation model from Amazon Science that offers more deployment control than closed APIs like TimeGPT. It treats forecasting like language modeling by converting time series values into tokens and predicting future values from those patterns.

It is useful for teams that want zero-shot forecasting with self-hosting, local testing, or cloud deployment. The family includes Chronos, Chronos-Bolt for faster and more memory-efficient forecasting, and Chronos-2 for multivariate and covariate-aware forecasting.

Chronos Workflow Diagram

Chronos Code

import torch
from chronos import BaseChronosPipeline

context = torch.tensor(list(range(200)), dtype=torch.float32)

pipeline = BaseChronosPipeline.from_pretrained(
    "amazon/chronos-bolt-small",
    device_map="cpu",
)

samples = pipeline.predict(
    context=context,
    prediction_length=30,
    num_samples=20,
)

median_forecast = torch.median(samples, dim=0).values

# print(median_forecast)

This code creates a simple historical time series using PyTorch. The context variable stores the past values that Chronos will use to forecast the future. The BaseChronosPipeline.from_pretrained() loads a pretrained Chronos-Bolt model. In this example, the model runs on CPU. 

The predict() function generates multiple possible future paths. The prediction_length=30 argument means the model forecasts the next 30 time steps, and num_samples=20 means it creates 20 possible forecast samples. Finally, the median forecast is calculated from those samples. This is useful because Chronos produces probabilistic forecasts rather than only one fixed prediction. 

Modeling Approaches and Feature Support

Prophet and NeuralProphet train on the user’s historical data as local forecasting models. Prophet uses trend, seasonality, holidays, and regressors, while NeuralProphet adds autoregression and neural components.

TimeGPT and Chronos use a foundation-model approach. TimeGPT works through a managed transformer API, while Chronos uses open-weight models that tokenize time series values. In general, Prophet and NeuralProphet are easier to explain, while TimeGPT and Chronos are stronger for zero-shot and probabilistic forecasting.

Modeling Approach Diagram

Feature Comparison Table

• Prophet is best when the forecast must be clearly explained. 
• NeuralProphet is best when the data has strong short-term patterns. 
• TimeGPT is best when teams want fast results without managing training infrastructure. 
• Chronos is best when teams want open-weight foundation-model forecasting with control over deployment. 

Note: TimeGPT and Chronos require paid API keys. This makes Prophet and NeuralProphet the go-to choice for working on time series forecasting for free.

Benchmarks and Performance

Benchmark results for Prophet, NeuralProphet, TimeGPT, and Chronos should be read carefully because they are not always tested under the same conditions. A fair comparison needs the same dataset, forecast horizon, train-test split, tuning process, and metrics.

Prophet is a strong explainable baseline, while NeuralProphet can help when short-term lag patterns matter. TimeGPT is useful for fast managed zero-shot forecasting, and Chronos-Bolt is a strong open foundation-model option. Still, teams should benchmark all models on their own data before choosing one for production.

Benchmark Diagram

Performance Comparison Table

Scalability and Latency

Scalability and latency matter because production forecasting often requires many forecasts at once. Prophet is reliable for small to medium workloads but can slow down across many individual series. NeuralProphet supports PyTorch and GPUs but still needs training and tuning. TimeGPT reduces local engineering through a managed API, while Chronos offers local or cloud deployment control. Chronos-Bolt is best when faster, memory-efficient forecasting is needed.

Production Considerations

For production, a forecasting model must fit the team’s deployment needs, not just predict well. Prophet is easy to debug and explain, while NeuralProphet adds flexibility but needs more tuning. TimeGPT is simple to adopt through an API, but raises cost, privacy, governance, and vendor-dependency concerns. Chronos supports open-weight self-hosting but requires more infrastructure planning. A good setup often pairs one transparent baseline with one advanced model.

Conclusion

Time series forecasting now spans explainable tools like Prophet, flexible neural models like NeuralProphet, managed APIs like TimeGPT, and open-weight foundation models like Chronos. There is no universal best choice.

Teams should compare models on their own data and choose based on accuracy, explainability, deployment needs, and business goals.