From e00bd51b306e695013ae2c399381953b6e1ca3e2 Mon Sep 17 00:00:00 2001
From: azul <fede.garza.ramirez@gmail.com>
Date: Tue, 2 Apr 2024 10:57:17 -0600
Subject: [PATCH] feat: replace TimeGPT class by NixtlaClient class (#276)

---
 .github/workflows/ci.yaml                     |   4 +-
 README.md                                     |   6 +-
 action_files/models_performance/main.py       |   6 +-
 ....ipynb => distributed.nixtla_client.ipynb} |  68 ++--
 .../1_getting_started_short.ipynb             | 102 +++---
 ...setting_up_your_authentication_token.ipynb |  47 +--
 nbs/docs/getting-started/3_azure_ai.ipynb     |  87 +++++
 nbs/index.ipynb                               |  20 +-
 nbs/mint.json                                 |   2 +-
 nbs/{timegpt.ipynb => nixtla_client.ipynb}    | 314 +++++++++++-------
 nbs/sidebar.yml                               |   2 +-
 nixtlats/__init__.py                          |   2 +-
 nixtlats/_modidx.py                           | 199 ++++++-----
 .../{timegpt.py => nixtla_client.py}          |  34 +-
 nixtlats/{timegpt.py => nixtla_client.py}     | 100 +++---
 15 files changed, 592 insertions(+), 401 deletions(-)
 rename nbs/{distributed.timegpt.ipynb => distributed.nixtla_client.ipynb} (94%)
 create mode 100644 nbs/docs/getting-started/3_azure_ai.ipynb
 rename nbs/{timegpt.ipynb => nixtla_client.ipynb} (91%)
 rename nixtlats/distributed/{timegpt.py => nixtla_client.py} (92%)
 rename nixtlats/{timegpt.py => nixtla_client.py} (95%)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8c93ae4f..ec97b730 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -56,7 +56,9 @@ jobs:
         run: pip install ./
 
       - name: Check import
-        run: python -c "from nixtlats import TimeGPT;"
+        run: |
+          python -c "from nixtlats import TimeGPT;"
+          python -c "from nixtlats import NixtlaClient;"
 
   run-tests:
     runs-on: ${{ matrix.os }}
diff --git a/README.md b/README.md
index a73916f5..f5e92f36 100644
--- a/README.md
+++ b/README.md
@@ -44,12 +44,12 @@ Get started with TimeGPT now:
 ```python
 df = pd.read_csv('https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/electricity-short.csv')
 
-from nixtlats import TimeGPT
-timegpt = TimeGPT(
+from nixtlats import NixtlaClient
+nixtla_client = NixtlaClient(
     # defaults to os.environ.get("NIXTLA_API_KEY")
     api_key = 'my_api_key_provided_by_nixtla'
 )
-fcst_df = timegpt.forecast(df, h=24, level=[80, 90])
+fcst_df = nixtla_client.forecast(df, h=24, level=[80, 90])
 ```
 
 ![](./nbs/img/forecast_readme.png)
diff --git a/action_files/models_performance/main.py b/action_files/models_performance/main.py
index 1d4c8f9d..b0a7e196 100644
--- a/action_files/models_performance/main.py
+++ b/action_files/models_performance/main.py
@@ -11,7 +11,7 @@
 from utilsforecast.evaluation import evaluate
 from utilsforecast.losses import mae, mape, mse
 
-from nixtlats import TimeGPT
+from nixtlats import NixtlaClient
 
 
 logger = logging.getLogger(__name__)
@@ -141,7 +141,7 @@ def evaluate_timegpt(self, model: str) -> Tuple[pd.DataFrame, pd.DataFrame]:
         init_time = time()
         # A: this sould be replaced with
         # cross validation
-        timegpt = TimeGPT()
+        timegpt = NixtlaClient()
         fcst_df = timegpt.forecast(
             df=self.df_train,
             X_df=self.df_test.drop(columns=self.target_col)
@@ -200,7 +200,7 @@ def evaluate_benchmark_performace(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
 
     def plot_and_save_forecasts(self, cv_df: pd.DataFrame, plot_dir: str) -> str:
         """Plot ans saves forecasts, returns the path of the plot"""
-        timegpt = TimeGPT()
+        timegpt = NixtlaClient()
         df = self.df.copy()
         df[self.time_col] = pd.to_datetime(df[self.time_col])
         if not self.has_id_col:
diff --git a/nbs/distributed.timegpt.ipynb b/nbs/distributed.nixtla_client.ipynb
similarity index 94%
rename from nbs/distributed.timegpt.ipynb
rename to nbs/distributed.nixtla_client.ipynb
index 72079935..db3c5113 100644
--- a/nbs/distributed.timegpt.ipynb
+++ b/nbs/distributed.nixtla_client.ipynb
@@ -6,7 +6,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#| default_exp distributed.timegpt"
+    "#| default_exp distributed.nixtla_client"
    ]
   },
   {
@@ -83,7 +83,7 @@
    "outputs": [],
    "source": [
     "#| export\n",
-    "class _DistributedTimeGPT:\n",
+    "class _DistributedNixtlaClient:\n",
     "\n",
     "    def __init__(\n",
     "            self, \n",
@@ -300,24 +300,24 @@
     "        )\n",
     "        return fcst_df\n",
     "    \n",
-    "    def _instantiate_timegpt(self):\n",
-    "        from nixtlats.timegpt import _TimeGPT\n",
-    "        timegpt = _TimeGPT(\n",
+    "    def _instantiate_nixtla_client(self):\n",
+    "        from nixtlats.nixtla_client import _NixtlaClient\n",
+    "        nixtla_client = _NixtlaClient(\n",
     "            api_key=self.api_key, \n",
     "            base_url=self.base_url,\n",
     "            max_retries=self.max_retries,\n",
     "            retry_interval=self.retry_interval,\n",
     "            max_wait_time=self.max_wait_time,\n",
     "        )\n",
-    "        return timegpt\n",
+    "        return nixtla_client\n",
     "\n",
     "    def _forecast(\n",
     "            self, \n",
     "            df: pd.DataFrame, \n",
     "            kwargs,\n",
     "        ) -> pd.DataFrame:\n",
-    "        timegpt = self._instantiate_timegpt()\n",
-    "        return timegpt._forecast(df=df, **kwargs)\n",
+    "        nixtla_client = self._instantiate_nixtla_client()\n",
+    "        return nixtla_client._forecast(df=df, **kwargs)\n",
     "\n",
     "    def _forecast_x(\n",
     "            self, \n",
@@ -325,24 +325,24 @@
     "            X_df: pd.DataFrame,\n",
     "            kwargs,\n",
     "        ) -> pd.DataFrame:\n",
-    "        timegpt = self._instantiate_timegpt()\n",
-    "        return timegpt._forecast(df=df, X_df=X_df, **kwargs)\n",
+    "        nixtla_client = self._instantiate_nixtla_client()\n",
+    "        return nixtla_client._forecast(df=df, X_df=X_df, **kwargs)\n",
     "\n",
     "    def _detect_anomalies(\n",
     "            self, \n",
     "            df: pd.DataFrame, \n",
     "            kwargs,\n",
     "        ) -> pd.DataFrame:\n",
-    "        timegpt = self._instantiate_timegpt()\n",
-    "        return timegpt._detect_anomalies(df=df, **kwargs)\n",
+    "        nixtla_client = self._instantiate_nixtla_client()\n",
+    "        return nixtla_client._detect_anomalies(df=df, **kwargs)\n",
     "\n",
     "    def _cross_validation(\n",
     "            self, \n",
     "            df: pd.DataFrame, \n",
     "            kwargs,\n",
     "        ) -> pd.DataFrame:\n",
-    "        timegpt = self._instantiate_timegpt()\n",
-    "        return timegpt._cross_validation(df=df, **kwargs)\n",
+    "        nixtla_client = self._instantiate_nixtla_client()\n",
+    "        return nixtla_client._cross_validation(df=df, **kwargs)\n",
     "    \n",
     "    @staticmethod\n",
     "    def _get_forecast_schema(id_col, time_col, level, quantiles, cv=False):\n",
@@ -400,7 +400,7 @@
     "        time_col: str = 'ds',\n",
     "        **fcst_kwargs,\n",
     "    ):\n",
-    "    fcst_df = distributed_timegpt.forecast(\n",
+    "    fcst_df = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=horizon,\n",
     "        id_col=id_col,\n",
@@ -442,7 +442,7 @@
     "        time_col: str = 'ds',\n",
     "        **fcst_kwargs,\n",
     "    ):\n",
-    "    fcst_df = distributed_timegpt.forecast(\n",
+    "    fcst_df = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=horizon, \n",
     "        num_partitions=1,\n",
@@ -452,7 +452,7 @@
     "        **fcst_kwargs\n",
     "    )\n",
     "    fcst_df = fa.as_pandas(fcst_df)\n",
-    "    fcst_df_2 = distributed_timegpt.forecast(\n",
+    "    fcst_df_2 = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=horizon, \n",
     "        num_partitions=1,\n",
@@ -485,7 +485,7 @@
     "        time_col: str = 'ds',\n",
     "        **fcst_kwargs,\n",
     "    ):\n",
-    "    fcst_df = distributed_timegpt.forecast(\n",
+    "    fcst_df = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=horizon, \n",
     "        num_partitions=1,\n",
@@ -494,7 +494,7 @@
     "        **fcst_kwargs\n",
     "    )\n",
     "    fcst_df = fa.as_pandas(fcst_df)\n",
-    "    fcst_df_2 = distributed_timegpt.forecast(\n",
+    "    fcst_df_2 = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=horizon, \n",
     "        num_partitions=2,\n",
@@ -523,7 +523,7 @@
     "        time_col: str = 'ds',\n",
     "        **fcst_kwargs,\n",
     "    ):\n",
-    "    fcst_df = distributed_timegpt.cross_validation(\n",
+    "    fcst_df = distributed_nixtla_client.cross_validation(\n",
     "        df=df, \n",
     "        h=horizon, \n",
     "        num_partitions=1,\n",
@@ -532,7 +532,7 @@
     "        **fcst_kwargs\n",
     "    )\n",
     "    fcst_df = fa.as_pandas(fcst_df)\n",
-    "    fcst_df_2 = distributed_timegpt.cross_validation(\n",
+    "    fcst_df_2 = distributed_nixtla_client.cross_validation(\n",
     "        df=df, \n",
     "        h=horizon, \n",
     "        num_partitions=2,\n",
@@ -592,7 +592,7 @@
     "        time_col: str = 'ds',\n",
     "        **fcst_kwargs,\n",
     "    ):\n",
-    "    fcst_df = distributed_timegpt.forecast(\n",
+    "    fcst_df = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        X_df=X_df,\n",
     "        h=horizon,\n",
@@ -610,7 +610,7 @@
     "        exp_cols.extend([f'TimeGPT-lo-{lv}' for lv in reversed(level)])\n",
     "        exp_cols.extend([f'TimeGPT-hi-{lv}' for lv in level])\n",
     "    test_eq(cols, exp_cols)\n",
-    "    fcst_df_2 = distributed_timegpt.forecast(\n",
+    "    fcst_df_2 = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=horizon,\n",
     "        id_col=id_col,\n",
@@ -640,7 +640,7 @@
     "        time_col: str = 'ds',\n",
     "        **fcst_kwargs,\n",
     "    ):\n",
-    "    fcst_df = distributed_timegpt.forecast(\n",
+    "    fcst_df = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        X_df=X_df,\n",
     "        h=horizon, \n",
@@ -650,7 +650,7 @@
     "        **fcst_kwargs\n",
     "    )\n",
     "    fcst_df = fa.as_pandas(fcst_df)\n",
-    "    fcst_df_2 = distributed_timegpt.forecast(\n",
+    "    fcst_df_2 = distributed_nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=horizon, \n",
     "        num_partitions=2,\n",
@@ -705,7 +705,7 @@
     "        time_col: str = 'ds',\n",
     "        **anomalies_kwargs,\n",
     "    ):\n",
-    "    anomalies_df = distributed_timegpt.detect_anomalies(\n",
+    "    anomalies_df = distributed_nixtla_client.detect_anomalies(\n",
     "        df=df, \n",
     "        id_col=id_col,\n",
     "        time_col=time_col,\n",
@@ -731,7 +731,7 @@
     "        time_col: str = 'ds',\n",
     "        **anomalies_kwargs,\n",
     "    ):\n",
-    "    anomalies_df = distributed_timegpt.detect_anomalies(\n",
+    "    anomalies_df = distributed_nixtla_client.detect_anomalies(\n",
     "        df=df, \n",
     "        num_partitions=1,\n",
     "        id_col=id_col,\n",
@@ -739,7 +739,7 @@
     "        **anomalies_kwargs\n",
     "    )\n",
     "    anomalies_df = fa.as_pandas(anomalies_df)\n",
-    "    anomalies_df_2 = distributed_timegpt.detect_anomalies(\n",
+    "    anomalies_df_2 = distributed_nixtla_client.detect_anomalies(\n",
     "        df=df, \n",
     "        num_partitions=2,\n",
     "        id_col=id_col,\n",
@@ -766,7 +766,7 @@
     "        time_col: str = 'ds',\n",
     "        **anomalies_kwargs,\n",
     "    ):\n",
-    "    anomalies_df = distributed_timegpt.detect_anomalies(\n",
+    "    anomalies_df = distributed_nixtla_client.detect_anomalies(\n",
     "        df=df, \n",
     "        num_partitions=1,\n",
     "        id_col=id_col,\n",
@@ -775,7 +775,7 @@
     "        **anomalies_kwargs\n",
     "    )\n",
     "    anomalies_df = fa.as_pandas(anomalies_df)\n",
-    "    anomalies_df_2 = distributed_timegpt.detect_anomalies(\n",
+    "    anomalies_df_2 = distributed_nixtla_client.detect_anomalies(\n",
     "        df=df, \n",
     "        num_partitions=1,\n",
     "        id_col=id_col,\n",
@@ -844,9 +844,9 @@
     "        assert all(col in df_qls.columns for col in exp_q_cols)\n",
     "        # test monotonicity of quantiles\n",
     "        df_qls.apply(lambda x: x.is_monotonic_increasing, axis=1).sum() == len(exp_q_cols)\n",
-    "    test_method_qls(distributed_timegpt.forecast)\n",
-    "    test_method_qls(distributed_timegpt.forecast, add_history=True)\n",
-    "    test_method_qls(distributed_timegpt.cross_validation)"
+    "    test_method_qls(distributed_nixtla_client.forecast)\n",
+    "    test_method_qls(distributed_nixtla_client.forecast, add_history=True)\n",
+    "    test_method_qls(distributed_nixtla_client.cross_validation)"
    ]
   },
   {
@@ -856,7 +856,7 @@
    "outputs": [],
    "source": [
     "#| hide\n",
-    "distributed_timegpt = _DistributedTimeGPT()"
+    "distributed_nixtla_client = _DistributedNixtlaClient()"
    ]
   },
   {
diff --git a/nbs/docs/getting-started/1_getting_started_short.ipynb b/nbs/docs/getting-started/1_getting_started_short.ipynb
index 74b63273..a4434ce4 100644
--- a/nbs/docs/getting-started/1_getting_started_short.ipynb
+++ b/nbs/docs/getting-started/1_getting_started_short.ipynb
@@ -118,7 +118,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from nixtlats import TimeGPT"
+    "from nixtlats import NixtlaClient"
    ]
   },
   {
@@ -126,7 +126,7 @@
    "id": "8b73a131-390e-46b9-847b-173f7d3c869a",
    "metadata": {},
    "source": [
-    "You can instantiate the `TimeGPT` class providing your credentials."
+    "You can instantiate the `NixtlaClient` class providing your credentials."
    ]
   },
   {
@@ -136,9 +136,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "timegpt = TimeGPT(\n",
-    "    # defaults to os.environ.get(\"TIMEGPT_TOKEN\")\n",
-    "    token = 'my_token_provided_by_nixtla'\n",
+    "nixtla_client = NixtlaClient(\n",
+    "    # defaults to os.environ.get(\"NIXTLA_API_KEY\")\n",
+    "    api_key = 'my_api_key_provided_by_nixtla'\n",
     ")"
    ]
   },
@@ -150,7 +150,7 @@
    "outputs": [],
    "source": [
     "#| hide\n",
-    "timegpt = TimeGPT()"
+    "nixtla_client = NixtlaClient()"
    ]
   },
   {
@@ -158,7 +158,7 @@
    "id": "8e7cea32-ade9-4b23-be93-9a4fbea7c6b2",
    "metadata": {},
    "source": [
-    "Check your token status with the `validate_token` method."
+    "Check your token status with the `validate_api_key` method."
    ]
   },
   {
@@ -171,7 +171,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:nixtlats.timegpt:Happy Forecasting! :), If you have questions or need support, please email ops@nixtla.io\n"
+      "INFO:nixtlats.nixtla_client:Happy Forecasting! :), If you have questions or need support, please email ops@nixtla.io\n"
      ]
     },
     {
@@ -186,7 +186,7 @@
     }
    ],
    "source": [
-    "timegpt.validate_token()"
+    "nixtla_client.validate_api_key()"
    ]
   },
   {
@@ -314,7 +314,7 @@
     }
    ],
    "source": [
-    "timegpt.plot(df, time_col='timestamp', target_col='value')"
+    "nixtla_client.plot(df, time_col='timestamp', target_col='value')"
    ]
   },
   {
@@ -355,9 +355,9 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:nixtlats.timegpt:Validating inputs...\n",
-      "INFO:nixtlats.timegpt:Preprocessing dataframes...\n",
-      "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n"
+      "INFO:nixtlats.nixtla_client:Validating inputs...\n",
+      "INFO:nixtlats.nixtla_client:Preprocessing dataframes...\n",
+      "INFO:nixtlats.nixtla_client:Calling Forecast Endpoint...\n"
      ]
     },
     {
@@ -389,17 +389,17 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>1961-01-01</td>\n",
-       "      <td>437.837921</td>\n",
+       "      <td>437.837952</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>1961-02-01</td>\n",
-       "      <td>426.062714</td>\n",
+       "      <td>426.062744</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>1961-03-01</td>\n",
-       "      <td>463.116547</td>\n",
+       "      <td>463.116577</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -417,9 +417,9 @@
       ],
       "text/plain": [
        "    timestamp     TimeGPT\n",
-       "0  1961-01-01  437.837921\n",
-       "1  1961-02-01  426.062714\n",
-       "2  1961-03-01  463.116547\n",
+       "0  1961-01-01  437.837952\n",
+       "1  1961-02-01  426.062744\n",
+       "2  1961-03-01  463.116577\n",
        "3  1961-04-01  478.244507\n",
        "4  1961-05-01  505.646484"
       ]
@@ -430,7 +430,7 @@
     }
    ],
    "source": [
-    "timegpt_fcst_df = timegpt.forecast(df=df, h=12, freq='MS', time_col='timestamp', target_col='value')\n",
+    "timegpt_fcst_df = nixtla_client.forecast(df=df, h=12, freq='MS', time_col='timestamp', target_col='value')\n",
     "timegpt_fcst_df.head()"
    ]
   },
@@ -442,7 +442,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 2400x350 with 1 Axes>"
       ]
@@ -453,7 +453,7 @@
     }
    ],
    "source": [
-    "timegpt.plot(df, timegpt_fcst_df, time_col='timestamp', target_col='value')"
+    "nixtla_client.plot(df, timegpt_fcst_df, time_col='timestamp', target_col='value')"
    ]
   },
   {
@@ -474,10 +474,10 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:nixtlats.timegpt:Validating inputs...\n",
-      "INFO:nixtlats.timegpt:Preprocessing dataframes...\n",
-      "WARNING:nixtlats.timegpt:The specified horizon \"h\" exceeds the model horizon. This may lead to less accurate forecasts. Please consider using a smaller horizon.\n",
-      "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n"
+      "INFO:nixtlats.nixtla_client:Validating inputs...\n",
+      "INFO:nixtlats.nixtla_client:Preprocessing dataframes...\n",
+      "WARNING:nixtlats.nixtla_client:The specified horizon \"h\" exceeds the model horizon. This may lead to less accurate forecasts. Please consider using a smaller horizon.\n",
+      "INFO:nixtlats.nixtla_client:Calling Forecast Endpoint...\n"
      ]
     },
     {
@@ -509,17 +509,17 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>1961-01-01</td>\n",
-       "      <td>437.837921</td>\n",
+       "      <td>437.837952</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>1961-02-01</td>\n",
-       "      <td>426.062714</td>\n",
+       "      <td>426.062744</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>1961-03-01</td>\n",
-       "      <td>463.116547</td>\n",
+       "      <td>463.116577</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -537,9 +537,9 @@
       ],
       "text/plain": [
        "    timestamp     TimeGPT\n",
-       "0  1961-01-01  437.837921\n",
-       "1  1961-02-01  426.062714\n",
-       "2  1961-03-01  463.116547\n",
+       "0  1961-01-01  437.837952\n",
+       "1  1961-02-01  426.062744\n",
+       "2  1961-03-01  463.116577\n",
        "3  1961-04-01  478.244507\n",
        "4  1961-05-01  505.646484"
       ]
@@ -550,7 +550,7 @@
     }
    ],
    "source": [
-    "timegpt_fcst_df = timegpt.forecast(df=df, h=36, time_col='timestamp', target_col='value', freq='MS')\n",
+    "timegpt_fcst_df = nixtla_client.forecast(df=df, h=36, time_col='timestamp', target_col='value', freq='MS')\n",
     "timegpt_fcst_df.head()"
    ]
   },
@@ -573,7 +573,7 @@
     }
    ],
    "source": [
-    "timegpt.plot(df, timegpt_fcst_df, time_col='timestamp', target_col='value')"
+    "nixtla_client.plot(df, timegpt_fcst_df, time_col='timestamp', target_col='value')"
    ]
   },
   {
@@ -594,9 +594,9 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:nixtlats.timegpt:Validating inputs...\n",
-      "INFO:nixtlats.timegpt:Preprocessing dataframes...\n",
-      "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n"
+      "INFO:nixtlats.nixtla_client:Validating inputs...\n",
+      "INFO:nixtlats.nixtla_client:Preprocessing dataframes...\n",
+      "INFO:nixtlats.nixtla_client:Calling Forecast Endpoint...\n"
      ]
     },
     {
@@ -612,8 +612,8 @@
     }
    ],
    "source": [
-    "timegpt_fcst_df = timegpt.forecast(df=df, h=6, time_col='timestamp', target_col='value', freq='MS')\n",
-    "timegpt.plot(df, timegpt_fcst_df, time_col='timestamp', target_col='value')"
+    "timegpt_fcst_df = nixtla_client.forecast(df=df, h=6, time_col='timestamp', target_col='value', freq='MS')\n",
+    "nixtla_client.plot(df, timegpt_fcst_df, time_col='timestamp', target_col='value')"
    ]
   },
   {
@@ -652,11 +652,11 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:nixtlats.timegpt:Validating inputs...\n",
-      "INFO:nixtlats.timegpt:Preprocessing dataframes...\n",
-      "INFO:nixtlats.timegpt:Inferred freq: MS\n",
-      "WARNING:nixtlats.timegpt:The specified horizon \"h\" exceeds the model horizon. This may lead to less accurate forecasts. Please consider using a smaller horizon.\n",
-      "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n"
+      "INFO:nixtlats.nixtla_client:Validating inputs...\n",
+      "INFO:nixtlats.nixtla_client:Preprocessing dataframes...\n",
+      "INFO:nixtlats.nixtla_client:Inferred freq: MS\n",
+      "WARNING:nixtlats.nixtla_client:The specified horizon \"h\" exceeds the model horizon. This may lead to less accurate forecasts. Please consider using a smaller horizon.\n",
+      "INFO:nixtlats.nixtla_client:Calling Forecast Endpoint...\n"
      ]
     },
     {
@@ -688,17 +688,17 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>1961-01-01</td>\n",
-       "      <td>437.837921</td>\n",
+       "      <td>437.837952</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>1961-02-01</td>\n",
-       "      <td>426.062714</td>\n",
+       "      <td>426.062744</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>1961-03-01</td>\n",
-       "      <td>463.116547</td>\n",
+       "      <td>463.116577</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
@@ -716,9 +716,9 @@
       ],
       "text/plain": [
        "    timestamp     TimeGPT\n",
-       "0  1961-01-01  437.837921\n",
-       "1  1961-02-01  426.062714\n",
-       "2  1961-03-01  463.116547\n",
+       "0  1961-01-01  437.837952\n",
+       "1  1961-02-01  426.062744\n",
+       "2  1961-03-01  463.116577\n",
        "3  1961-04-01  478.244507\n",
        "4  1961-05-01  505.646484"
       ]
@@ -731,7 +731,7 @@
    "source": [
     "df_time_index = df.set_index('timestamp')\n",
     "df_time_index.index = pd.DatetimeIndex(df_time_index.index, freq='MS')\n",
-    "timegpt.forecast(df=df, h=36, time_col='timestamp', target_col='value').head()"
+    "nixtla_client.forecast(df=df, h=36, time_col='timestamp', target_col='value').head()"
    ]
   }
  ],
diff --git a/nbs/docs/getting-started/2_setting_up_your_authentication_token.ipynb b/nbs/docs/getting-started/2_setting_up_your_authentication_token.ipynb
index 6b000e91..a49489b5 100644
--- a/nbs/docs/getting-started/2_setting_up_your_authentication_token.ipynb
+++ b/nbs/docs/getting-started/2_setting_up_your_authentication_token.ipynb
@@ -23,17 +23,26 @@
     "## 1. Direct copy and paste \n",
     "\n",
     "- **Step 1**: Copy the token found in the `API Keys` of your [dashboard]((https://dashboard.nixtla.io/)). \n",
-    "- **Step 2**: Instantiate the `TimeGPT` class by directly pasting your token into the code, as shown below:"
+    "- **Step 2**: Instantiate the `NixtlaClient` class by directly pasting your token into the code, as shown below:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ubuntu/projects/nixtla/nixtlats/nixtla_client.py:56: FutureWarning: `'token'` is deprecated; use `'api_key'` instead.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
-    "from nixtlats import TimeGPT \n",
-    "timegpt = TimeGPT(token = 'your token here')"
+    "from nixtlats import NixtlaClient \n",
+    "nixtla_client = NixtlaClient(token = 'your token here')"
    ]
   },
   {
@@ -54,8 +63,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "- **Step 1:** Store your token in an environment variable named `TIMEGPT_TOKEN`. This can be done for a session or permanently, depending on your preference.\n",
-    "- **Step 2:** When you instantiate the `TimeGPT` class, the SDK will automatically look for the `TIMEGPT_TOKEN` environment variable and use it to authenticate your requests."
+    "- **Step 1:** Store your token in an environment variable named `NIXTLA_API_KEY`. This can be done for a session or permanently, depending on your preference.\n",
+    "- **Step 2:** When you instantiate the `NixtlaClient` class, the SDK will automatically look for the `NIXTLA_API_KEY` environment variable and use it to authenticate your requests."
    ]
   },
   {
@@ -86,8 +95,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from nixtlats import TimeGPT\n",
-    "timegpt = TimeGPT()"
+    "from nixtlats import NixtlaClient\n",
+    "nixtla_client = NixtlaClient()"
    ]
   },
   {
@@ -95,7 +104,7 @@
    "metadata": {},
    "source": [
     "::: {.callout-important}\n",
-    "The environment variable must be named exactly `TIMEGPT_TOKEN`, with all capital letters and no deviations in spelling, for the SDK to recognize it.\n",
+    "The environment variable must be named exactly `NIXTLA_API_KEY`, with all capital letters and no deviations in spelling, for the SDK to recognize it.\n",
     "::: "
    ]
   },
@@ -111,10 +120,10 @@
    "metadata": {},
    "source": [
     "### a. From the Terminal\n",
-    "Use the `export` command to set `TIMEGPT_TOKEN`. \n",
+    "Use the `export` command to set `NIXTLA_API_KEY`. \n",
     "\n",
     "``` bash\n",
-    "export TIMEGPT_TOKEN=your_token\n",
+    "export NIXTLA_API_KEY=your_token\n",
     "```"
    ]
   },
@@ -128,7 +137,7 @@
     "\n",
     "``` bash\n",
     "# Inside a file named .env\n",
-    "TIMEGPT_TOKEN=your_token\n",
+    "NIXTLA_API_KEY=your_token\n",
     "```"
    ]
   },
@@ -136,7 +145,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Within Python:** If using a `.env` file, you can load the environment variable within your Python script. Use the `dotenv` package to load the `.env` file and then instantiate the `TimeGPT` class."
+    "**Within Python:** If using a `.env` file, you can load the environment variable within your Python script. Use the `dotenv` package to load the `.env` file and then instantiate the `NIXTLA_API_KEY` class."
    ]
   },
   {
@@ -148,8 +157,8 @@
     "from dotenv import load_dotenv\n",
     "load_dotenv()\n",
     "\n",
-    "from nixtlats import TimeGPT\n",
-    "timegpt = TimeGPT()"
+    "from nixtlats import NixtlaClient\n",
+    "nixtla_client = NixtlaClient()"
    ]
   },
   {
@@ -174,7 +183,7 @@
    "source": [
     "## Validate your token\n",
     "\n",
-    "You can always find your token in the `API Keys` section of your dashboard. To check the status of your token, use the [`validate_token` method](https://nixtlaverse.nixtla.io/nixtla/timegpt.html#timegpt-validate-token) of the `TimeGPT` class. This method will return `True` if the token is valid and `False` otherwise. "
+    "You can always find your token in the `API Keys` section of your dashboard. To check the status of your token, use the `validate_api_key` method of the `Nixtla` class. This method will return `True` if the token is valid and `False` otherwise. "
    ]
   },
   {
@@ -186,7 +195,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:nixtlats.timegpt:Happy Forecasting! :), If you have questions or need support, please email ops@nixtla.io\n"
+      "INFO:nixtlats.nixtla_client:Happy Forecasting! :), If you have questions or need support, please email ops@nixtla.io\n"
      ]
     },
     {
@@ -201,7 +210,7 @@
     }
    ],
    "source": [
-    "timegpt.validate_token()"
+    "nixtla_client.validate_api_key()"
    ]
   },
   {
@@ -220,5 +229,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/nbs/docs/getting-started/3_azure_ai.ipynb b/nbs/docs/getting-started/3_azure_ai.ipynb
new file mode 100644
index 00000000..931a7869
--- /dev/null
+++ b/nbs/docs/getting-started/3_azure_ai.ipynb
@@ -0,0 +1,87 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AzureAI (coming soon)\n",
+    "\n",
+    "> The foundational models for time series by Nixtla can be deployed on your Azure subscription. This page explains how to easily get started with TimeGEN deployed as an Azure AI endpoint. If you use the `nixtlats` library, it should be a drop-in replacement where you only need to change the client parameters (endpoint URL, API key, model name)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Deploying TimeGEN (coming soon)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using the model\n",
+    "\n",
+    "Once your model is deployed and provided that you have the relevant permissions, consuming it will basically be the same process as for a Nixtla endpoint.\n",
+    "\n",
+    "To run the examples below, you will need to define the following environment variables:\n",
+    "\n",
+    "- `AZURE_AI_NIXTLA_BASE_URL` is your api URL, should be of the form `https://your-endpoint.inference.ai.azure.com/`.\n",
+    "- `AZURE_AI_NIXTLA_API_KEY` is your authentication key."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## How to use"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Just import the library, set your credentials, and start forecasting in two lines of code!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```bash\n",
+    "pip install nixtlats\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "import os\n",
+    "from nixtlats import NixtlaClient\n",
+    "\n",
+    "base_url = os.environ[\"AZURE_AI_NIXTLA_BASE_URL\"]\n",
+    "api_key = os.environ[\"AZURE_AI_NIXTLA_API_KEY\"]\n",
+    "model = \"azureai\"\n",
+    "\n",
+    "nixtla_client = NixtlaClient(api_key=api_key, base_url=base_url)\n",
+    "nixtla_client.forecast(\n",
+    "    ...,\n",
+    "    model=model,\n",
+    ")\n",
+    "```"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/nbs/index.ipynb b/nbs/index.ipynb
index 70805828..75c08318 100644
--- a/nbs/index.ipynb
+++ b/nbs/index.ipynb
@@ -80,7 +80,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from nixtlats import TimeGPT"
+    "from nixtlats import NixtlaClient"
    ]
   },
   {
@@ -89,7 +89,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "timegpt = TimeGPT(\n",
+    "nixtla_client = NixtlaClient(\n",
     "    # defaults to os.environ.get(\"NIXTLA_API_KEY\")\n",
     "    api_key = 'my_api_key_provided_by_nixtla'\n",
     ")"
@@ -102,7 +102,7 @@
    "outputs": [],
    "source": [
     "#| hide\n",
-    "timegpt = TimeGPT()"
+    "nixtla_client = NixtlaClient()"
    ]
   },
   {
@@ -114,16 +114,16 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:nixtlats.timegpt:Validating inputs...\n",
-      "INFO:nixtlats.timegpt:Preprocessing dataframes...\n",
-      "INFO:nixtlats.timegpt:Inferred freq: H\n",
-      "INFO:nixtlats.timegpt:Restricting input...\n",
-      "INFO:nixtlats.timegpt:Calling Forecast Endpoint...\n"
+      "INFO:nixtlats.nixtla_client:Validating inputs...\n",
+      "INFO:nixtlats.nixtla_client:Preprocessing dataframes...\n",
+      "INFO:nixtlats.nixtla_client:Inferred freq: H\n",
+      "INFO:nixtlats.nixtla_client:Restricting input...\n",
+      "INFO:nixtlats.nixtla_client:Calling Forecast Endpoint...\n"
      ]
     }
    ],
    "source": [
-    "fcst_df = timegpt.forecast(df, h=24, level=[80, 90])"
+    "fcst_df = nixtla_client.forecast(df, h=24, level=[80, 90])"
    ]
   },
   {
@@ -144,7 +144,7 @@
     }
    ],
    "source": [
-    "timegpt.plot(df, fcst_df, level=[80, 90], max_insample_length=24 * 5)"
+    "nixtla_client.plot(df, fcst_df, level=[80, 90], max_insample_length=24 * 5)"
    ]
   }
  ],
diff --git a/nbs/mint.json b/nbs/mint.json
index 78a2b97f..d8032716 100644
--- a/nbs/mint.json
+++ b/nbs/mint.json
@@ -57,7 +57,7 @@
     },
     {
       "group": "API Reference",
-      "pages": ["timegpt.html", "date_features.html"]
+      "pages": ["nixtla_client.html", "date_features.html"]
     }
   ]
 }
diff --git a/nbs/timegpt.ipynb b/nbs/nixtla_client.ipynb
similarity index 91%
rename from nbs/timegpt.ipynb
rename to nbs/nixtla_client.ipynb
index bee0e2c2..9ce0b532 100644
--- a/nbs/timegpt.ipynb
+++ b/nbs/nixtla_client.ipynb
@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# TimeGPT"
+    "# Nixtla Client"
    ]
   },
   {
@@ -13,7 +13,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#| default_exp timegpt"
+    "#| default_exp nixtla_client"
    ]
   },
   {
@@ -223,7 +223,7 @@
    "outputs": [],
    "source": [
     "#| exporti\n",
-    "class _TimeGPTModel:\n",
+    "class _NixtlaClientModel:\n",
     "\n",
     "    def __init__(\n",
     "            self, \n",
@@ -833,9 +833,9 @@
    "outputs": [],
    "source": [
     "#| exporti\n",
-    "class _TimeGPT:\n",
+    "class _NixtlaClient:\n",
     "    \"\"\"\n",
-    "    A class used to interact with the TimeGPT API.\n",
+    "    A class used to interact with Nixtla API.\n",
     "    \"\"\"\n",
     "    @deprecated_token\n",
     "    @deprecated_environment\n",
@@ -848,12 +848,12 @@
     "            max_wait_time: int = 6 * 60,\n",
     "        ):\n",
     "        \"\"\"\n",
-    "        Constructs all the necessary attributes for the TimeGPT object.\n",
+    "        Constructs all the necessary attributes for the NixtlaClient object.\n",
     "\n",
     "        Parameters\n",
     "        ----------\n",
     "        api_key : str, (default=None)\n",
-    "            The authorization api_key interacts with the TimeGPT API.\n",
+    "            The authorization api_key interacts with the Nixtla API.\n",
     "            If not provided, it will be inferred by the NIXTLA_API_KEY environment variable.\n",
     "        base_url : str, (default=None)\n",
     "            Custom base_url. Pass only if provided.\n",
@@ -908,8 +908,11 @@
     "\n",
     "    def validate_api_key(self, log: bool = True) -> bool:\n",
     "        \"\"\"Returns True if your api_key is valid.\"\"\"\n",
-    "        validation = self.client.validate_token()\n",
     "        valid = False\n",
+    "        try:\n",
+    "            validation = self.client.validate_token()\n",
+    "        except:\n",
+    "            validation = dict()\n",
     "        if 'message' in validation:\n",
     "            if validation['message'] == 'success':\n",
     "                valid = True\n",
@@ -947,7 +950,7 @@
     "            raise Exception(\n",
     "                'API Key not valid, please email ops@nixtla.io'\n",
     "            )\n",
-    "        timegpt_model = _TimeGPTModel(\n",
+    "        nixtla_client_model = _NixtlaClientModel(\n",
     "            client=self.client,\n",
     "            h=h,\n",
     "            id_col=id_col,\n",
@@ -966,8 +969,8 @@
     "            retry_interval=self.retry_interval,\n",
     "            max_wait_time=self.max_wait_time,   \n",
     "        )\n",
-    "        fcst_df = timegpt_model.forecast(df=df, X_df=X_df, add_history=add_history)\n",
-    "        self.weights_x = timegpt_model.weights_x\n",
+    "        fcst_df = nixtla_client_model.forecast(df=df, X_df=X_df, add_history=add_history)\n",
+    "        self.weights_x = nixtla_client_model.weights_x\n",
     "        return fcst_df\n",
     "\n",
     "    @validate_model_parameter\n",
@@ -991,7 +994,7 @@
     "            raise Exception(\n",
     "                'API Key not valid, please email ops@nixtla.io'\n",
     "            )\n",
-    "        timegpt_model = _TimeGPTModel(\n",
+    "        nixtla_client_model = _NixtlaClientModel(\n",
     "            client=self.client,\n",
     "            h=None,\n",
     "            id_col=id_col,\n",
@@ -1007,8 +1010,8 @@
     "            retry_interval=self.retry_interval,\n",
     "            max_wait_time=self.max_wait_time,\n",
     "        )\n",
-    "        anomalies_df = timegpt_model.detect_anomalies(df=df)\n",
-    "        self.weights_x = timegpt_model.weights_x\n",
+    "        anomalies_df = nixtla_client_model.detect_anomalies(df=df)\n",
+    "        self.weights_x = nixtla_client_model.weights_x\n",
     "        return anomalies_df\n",
     "\n",
     "    @validate_model_parameter\n",
@@ -1038,7 +1041,7 @@
     "            raise Exception(\n",
     "                'API Key not valid, please email ops@nixtla.io'\n",
     "            )\n",
-    "        timegpt_model = _TimeGPTModel(\n",
+    "        nixtla_client_model = _NixtlaClientModel(\n",
     "            client=self.client,\n",
     "            h=h,\n",
     "            id_col=id_col,\n",
@@ -1057,8 +1060,8 @@
     "            retry_interval=self.retry_interval,\n",
     "            max_wait_time=self.max_wait_time,\n",
     "        )\n",
-    "        cv_df = timegpt_model.cross_validation(df=df, n_windows=n_windows, step_size=step_size)\n",
-    "        self.weights_x = timegpt_model.weights_x\n",
+    "        cv_df = nixtla_client_model.cross_validation(df=df, n_windows=n_windows, step_size=step_size)\n",
+    "        self.weights_x = nixtla_client_model.weights_x\n",
     "        return cv_df\n",
     "    \n",
     "    def plot(\n",
@@ -1178,18 +1181,18 @@
    "outputs": [],
    "source": [
     "#| exporti\n",
-    "class TimeGPT(_TimeGPT):\n",
+    "class NixtlaClient(_NixtlaClient):\n",
     "\n",
-    "    def _instantiate_distributed_timegpt(self):\n",
-    "        from nixtlats.distributed.timegpt import _DistributedTimeGPT\n",
-    "        dist_timegpt = _DistributedTimeGPT(\n",
+    "    def _instantiate_distributed_nixtla_client(self):\n",
+    "        from nixtlats.distributed.nixtla_client import _DistributedNixtlaClient\n",
+    "        dist_nixtla_client = _DistributedNixtlaClient(\n",
     "            api_key=self.client._client_wrapper._token,\n",
     "            base_url=self.client._client_wrapper._base_url,\n",
     "            max_retries=self.max_retries,\n",
     "            retry_interval=self.retry_interval,\n",
     "            max_wait_time=self.max_wait_time,\n",
     "        )\n",
-    "        return dist_timegpt\n",
+    "        return dist_nixtla_client\n",
     "\n",
     "    @deprecated_fewshot_loss\n",
     "    @deprecated_fewshot_steps\n",
@@ -1312,8 +1315,8 @@
     "                num_partitions=num_partitions,\n",
     "            )\n",
     "        else:\n",
-    "            dist_timegpt = self._instantiate_distributed_timegpt()\n",
-    "            return dist_timegpt.forecast(\n",
+    "            dist_nixtla_client = self._instantiate_distributed_nixtla_client()\n",
+    "            return dist_nixtla_client.forecast(\n",
     "                df=df,\n",
     "                h=h,\n",
     "                freq=freq,    \n",
@@ -1422,8 +1425,8 @@
     "                num_partitions=num_partitions,\n",
     "            )\n",
     "        else:\n",
-    "            dist_timegpt = self._instantiate_distributed_timegpt()\n",
-    "            return dist_timegpt.detect_anomalies(\n",
+    "            dist_nixtla_client = self._instantiate_distributed_nixtla_client()\n",
+    "            return dist_nixtla_client.detect_anomalies(\n",
     "                df=df,\n",
     "                freq=freq,    \n",
     "                id_col=id_col,\n",
@@ -1558,8 +1561,8 @@
     "                num_partitions=num_partitions,\n",
     "            )\n",
     "        else:\n",
-    "            dist_timegpt = self._instantiate_distributed_timegpt()\n",
-    "            return dist_timegpt.cross_validation(\n",
+    "            dist_nixtla_client = self._instantiate_distributed_nixtla_client()\n",
+    "            return dist_nixtla_client.cross_validation(\n",
     "                df=df,\n",
     "                h=h,\n",
     "                freq=freq,    \n",
@@ -1587,7 +1590,52 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "show_doc(TimeGPT.__init__, title_level=3, name='TimeGPT')"
+    "#| exporti\n",
+    "class TimeGPT(NixtlaClient):\n",
+    "    \"\"\"\n",
+    "    Class `TimeGPT` is deprecated; use `NixtlaClient` instead.\n",
+    "\n",
+    "    This class is deprecated and may be removed in future releases.\n",
+    "    Please use `NixtlaClient` instead.\n",
+    "\n",
+    "    \"\"\"\n",
+    "    def __init__(self, *args, **kwargs):\n",
+    "        super().__init__(*args, **kwargs)\n",
+    "        warnings.warn(\n",
+    "            \"Class `TimeGPT` is deprecated; use `NixtlaClient` instead.\", \n",
+    "            FutureWarning,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide \n",
+    "# test warns timegpt deprecation\n",
+    "test_warns(\n",
+    "    lambda: TimeGPT(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_doc(NixtlaClient.__init__, title_level=2, name='NixtlaClient')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_doc(TimeGPT, title_level=4)"
    ]
   },
   {
@@ -1622,7 +1670,7 @@
     "# test api_key fail\n",
     "with delete_env_var('NIXTLA_API_KEY'), delete_env_var('TIMEGPT_TOKEN'):\n",
     "    test_fail(\n",
-    "        lambda: TimeGPT(),\n",
+    "        lambda: NixtlaClient(),\n",
     "        contains='NIXTLA_API_KEY',\n",
     "    )"
    ]
@@ -1634,7 +1682,7 @@
    "outputs": [],
    "source": [
     "#| hide\n",
-    "timegpt = TimeGPT()"
+    "nixtla_client = NixtlaClient()"
    ]
   },
   {
@@ -1646,13 +1694,13 @@
     "#| hide\n",
     "#test token and environment deprecation\n",
     "test_warns(\n",
-    "    lambda: TimeGPT(token='token'),\n",
+    "    lambda: NixtlaClient(token='token'),\n",
     ")\n",
     "test_warns(\n",
-    "    lambda: TimeGPT(environment='token'),\n",
+    "    lambda: NixtlaClient(environment='token'),\n",
     ")\n",
     "test_warns(\n",
-    "    lambda: TimeGPT(token='token', environment='token'),\n",
+    "    lambda: NixtlaClient(token='token', environment='token'),\n",
     ")"
    ]
   },
@@ -1662,7 +1710,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "show_doc(TimeGPT.validate_api_key, title_level=2, name='TimeGPT.validate_api_key')"
+    "show_doc(NixtlaClient.validate_api_key, title_level=2, name='NixtlaClient.validate_api_key')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "show_doc(NixtlaClient.validate_token, title_level=4, name='NixtlaClient.validate_token')"
    ]
   },
   {
@@ -1672,7 +1729,7 @@
    "outputs": [],
    "source": [
     "#| hide\n",
-    "timegpt.validate_api_key()"
+    "nixtla_client.validate_api_key()"
    ]
   },
   {
@@ -1684,8 +1741,14 @@
     "#| hide\n",
     "# test validate_token deprecation\n",
     "test_eq(\n",
-    "    timegpt.validate_api_key(),\n",
-    "    timegpt.validate_token(),\n",
+    "    nixtla_client.validate_api_key(),\n",
+    "    nixtla_client.validate_token(),\n",
+    ")\n",
+    "\n",
+    "_nixtla_client = NixtlaClient(api_key=\"invalid\")\n",
+    "test_eq(\n",
+    "    _nixtla_client.validate_api_key(),\n",
+    "    _nixtla_client.validate_token(),\n",
     ")"
    ]
   },
@@ -1696,11 +1759,11 @@
    "outputs": [],
    "source": [
     "#| hide\n",
-    "_timegpt = TimeGPT(\n",
+    "_nixtla_client = NixtlaClient(\n",
     "    api_key=os.environ['NIXTLA_API_KEY_CUSTOM'], \n",
     "    base_url=os.environ['NIXTLA_BASE_URL_CUSTOM'],\n",
     ")\n",
-    "_timegpt.validate_api_key()"
+    "_nixtla_client.validate_api_key()"
    ]
   },
   {
@@ -1733,7 +1796,7 @@
     "#| hide\n",
     "# test TIMEGPT_TOKEN deprecation\n",
     "with delete_env_var(\"TIMEGPT_TOKEN\"), delete_env_var(\"NIXTLA_API_KEY\"), add_env_var(\"TIMEGPT_TOKEN\", \"token\"):\n",
-    "    test_warns(lambda: TimeGPT())"
+    "    test_warns(lambda: NixtlaClient())"
    ]
   },
   {
@@ -1744,7 +1807,7 @@
    "source": [
     "#| hide\n",
     "test_fail(\n",
-    "    lambda: TimeGPT(api_key='transphobic').forecast(df=pd.DataFrame(), h=None, validate_api_key=True),\n",
+    "    lambda: NixtlaClient(api_key='transphobic').forecast(df=pd.DataFrame(), h=None, validate_api_key=True),\n",
     "    contains='nixtla'\n",
     ")"
    ]
@@ -1758,7 +1821,7 @@
     "#| hide\n",
     "# test input_size\n",
     "test_eq(\n",
-    "    timegpt.client.model_params(request=SingleSeriesForecast(freq='D'))['data']['detail'],\n",
+    "    nixtla_client.client.model_params(request=SingleSeriesForecast(freq='D'))['data']['detail'],\n",
     "    {'input_size': 28, 'horizon': 7},\n",
     ")"
    ]
@@ -1792,18 +1855,18 @@
     "df_test = df.copy()\n",
     "df_test.columns = [\"ds\", \"y\"]\n",
     "test_warns(\n",
-    "    lambda: timegpt.forecast(df_test, finetune_steps=2, h=12, model=\"short-horizon\"),\n",
+    "    lambda: nixtla_client.forecast(df_test, finetune_steps=2, h=12, model=\"short-horizon\"),\n",
     ")\n",
     "test_warns(\n",
-    "    lambda: timegpt.forecast(df_test, finetune_steps=2, h=12, model=\"long-horizon\"),\n",
+    "    lambda: nixtla_client.forecast(df_test, finetune_steps=2, h=12, model=\"long-horizon\"),\n",
     ")\n",
     "pd.testing.assert_frame_equal(\n",
-    "    timegpt.forecast(df_test, h=12, model=\"short-horizon\"),\n",
-    "    timegpt.forecast(df_test, h=12),\n",
+    "    nixtla_client.forecast(df_test, h=12, model=\"short-horizon\"),\n",
+    "    nixtla_client.forecast(df_test, h=12),\n",
     ")\n",
     "pd.testing.assert_frame_equal(\n",
-    "    timegpt.forecast(df_test, h=12, model=\"timegpt-1-long-horizon\"),\n",
-    "    timegpt.forecast(df_test, h=12, model=\"long-horizon\"),\n",
+    "    nixtla_client.forecast(df_test, h=12, model=\"timegpt-1-long-horizon\"),\n",
+    "    nixtla_client.forecast(df_test, h=12, model=\"long-horizon\"),\n",
     ")"
    ]
   },
@@ -1816,20 +1879,20 @@
     "#| hide\n",
     "# test fewshot deprecation\n",
     "test_warns(\n",
-    "    lambda: timegpt.forecast(df_test, fewshot_steps=2, h=12),\n",
+    "    lambda: nixtla_client.forecast(df_test, fewshot_steps=2, h=12),\n",
     ")\n",
     "test_warns(\n",
-    "    lambda: timegpt.forecast(df_test, fewshot_steps=2, finetune_loss=\"mse\", h=12),\n",
+    "    lambda: nixtla_client.forecast(df_test, fewshot_steps=2, finetune_loss=\"mse\", h=12),\n",
     ")\n",
     "pd.testing.assert_frame_equal(\n",
-    "    timegpt.forecast(df_test, fewshot_steps=2, h=12),\n",
-    "    timegpt.forecast(df_test, finetune_steps=2, h=12),\n",
+    "    nixtla_client.forecast(df_test, fewshot_steps=2, h=12),\n",
+    "    nixtla_client.forecast(df_test, finetune_steps=2, h=12),\n",
     "    atol=1,\n",
     "    rtol=0,\n",
     ")\n",
     "pd.testing.assert_frame_equal(\n",
-    "    timegpt.forecast(df_test, fewshot_steps=2, fewshot_loss=\"mse\", h=12),\n",
-    "    timegpt.forecast(df_test, finetune_steps=2, finetune_loss=\"mse\", h=12),\n",
+    "    nixtla_client.forecast(df_test, fewshot_steps=2, fewshot_loss=\"mse\", h=12),\n",
+    "    nixtla_client.forecast(df_test, finetune_steps=2, finetune_loss=\"mse\", h=12),\n",
     "    atol=1,\n",
     "    rtol=0,\n",
     ")\n"
@@ -1857,7 +1920,7 @@
     "# and different ends\n",
     "test_series = generate_series(n_series=2, min_length=5, max_length=20)\n",
     "h = 12\n",
-    "fcst_test_series = timegpt.forecast(test_series, h=12, date_features=['dayofweek'])\n",
+    "fcst_test_series = nixtla_client.forecast(test_series, h=12, date_features=['dayofweek'])\n",
     "uids = test_series['unique_id']\n",
     "for uid in uids:\n",
     "    test_eq(\n",
@@ -1875,7 +1938,7 @@
     "#| hide\n",
     "# test quantiles\n",
     "test_fail(\n",
-    "    lambda: timegpt.forecast(\n",
+    "    lambda: nixtla_client.forecast(\n",
     "        df=df, \n",
     "        h=12, \n",
     "        time_col='timestamp', \n",
@@ -1899,9 +1962,9 @@
     "    assert all(col in df_qls.columns for col in exp_q_cols)\n",
     "    # test monotonicity of quantiles\n",
     "    df_qls.apply(lambda x: x.is_monotonic_increasing, axis=1).sum() == len(exp_q_cols)\n",
-    "test_method_qls(timegpt.forecast)\n",
-    "test_method_qls(timegpt.forecast, add_history=True)\n",
-    "test_method_qls(timegpt.cross_validation)"
+    "test_method_qls(nixtla_client.forecast)\n",
+    "test_method_qls(nixtla_client.forecast, add_history=True)\n",
+    "test_method_qls(nixtla_client.cross_validation)"
    ]
   },
   {
@@ -1942,20 +2005,20 @@
     "    )\n",
     "    min_size = df_freq.groupby('unique_id').size().min()\n",
     "    test_num_partitions_same_results(\n",
-    "        timegpt.detect_anomalies,\n",
+    "        nixtla_client.detect_anomalies,\n",
     "        level=98,\n",
     "        df=df_freq,\n",
     "        num_partitions=2,\n",
     "    )\n",
     "    test_num_partitions_same_results(\n",
-    "        timegpt.cross_validation,\n",
+    "        nixtla_client.cross_validation,\n",
     "        h=7,\n",
     "        n_windows=2,\n",
     "        df=df_freq,\n",
     "        num_partitions=2,\n",
     "    )\n",
     "    test_num_partitions_same_results(\n",
-    "        timegpt.forecast,\n",
+    "        nixtla_client.forecast,\n",
     "        df=df_freq,\n",
     "        h=7,\n",
     "        add_history=True,\n",
@@ -1995,7 +2058,7 @@
    "source": [
     "#| hide\n",
     "def test_retry_behavior(side_effect, max_retries=5, retry_interval=5, max_wait_time=40, should_retry=True, sleep_seconds=5):\n",
-    "    mock_timegpt = TimeGPT(\n",
+    "    mock_nixtla_client = NixtlaClient(\n",
     "        max_retries=max_retries, \n",
     "        retry_interval=retry_interval, \n",
     "        max_wait_time=max_wait_time,\n",
@@ -2003,7 +2066,7 @@
     "    init_time = time()\n",
     "    with patch('nixtlats.client.Nixtla.forecast_multi_series', side_effect=side_effect):\n",
     "        test_fail(\n",
-    "            lambda: mock_timegpt.forecast(df=df, h=12, time_col='timestamp', target_col='value'),\n",
+    "            lambda: mock_nixtla_client.forecast(df=df, h=12, time_col='timestamp', target_col='value'),\n",
     "        )\n",
     "    total_mock_time = time() - init_time\n",
     "    if should_retry:\n",
@@ -2103,18 +2166,18 @@
     "# test pass dataframe with index\n",
     "df_ds_index = df.set_index('timestamp')\n",
     "df_ds_index.index = pd.DatetimeIndex(df_ds_index.index, freq='MS')\n",
-    "fcst_inferred_df_index = timegpt.forecast(df_ds_index, h=10, time_col='timestamp', target_col='value')\n",
-    "anom_inferred_df_index = timegpt.detect_anomalies(df_ds_index, time_col='timestamp', target_col='value')\n",
-    "fcst_inferred_df = timegpt.forecast(df, h=10, time_col='timestamp', target_col='value')\n",
-    "anom_inferred_df = timegpt.detect_anomalies(df, time_col='timestamp', target_col='value')\n",
+    "fcst_inferred_df_index = nixtla_client.forecast(df_ds_index, h=10, time_col='timestamp', target_col='value')\n",
+    "anom_inferred_df_index = nixtla_client.detect_anomalies(df_ds_index, time_col='timestamp', target_col='value')\n",
+    "fcst_inferred_df = nixtla_client.forecast(df, h=10, time_col='timestamp', target_col='value')\n",
+    "anom_inferred_df = nixtla_client.detect_anomalies(df, time_col='timestamp', target_col='value')\n",
     "pd.testing.assert_frame_equal(fcst_inferred_df_index, fcst_inferred_df)\n",
     "pd.testing.assert_frame_equal(anom_inferred_df_index, anom_inferred_df)\n",
     "for freq in ['Y', 'W-MON', 'Q-DEC', 'H']:\n",
     "    df_ds_index.index = pd.date_range(end='2023-01-01', periods=len(df), freq=freq)\n",
     "    df_ds_index.index.name = 'timestamp'\n",
     "    df_test = df_ds_index.reset_index()\n",
-    "    fcst_inferred_df_index = timegpt.forecast(df_ds_index, h=10, time_col='timestamp', target_col='value')\n",
-    "    fcst_inferred_df = timegpt.forecast(df_test, h=10, time_col='timestamp', target_col='value')\n",
+    "    fcst_inferred_df_index = nixtla_client.forecast(df_ds_index, h=10, time_col='timestamp', target_col='value')\n",
+    "    fcst_inferred_df = nixtla_client.forecast(df_test, h=10, time_col='timestamp', target_col='value')\n",
     "    pd.testing.assert_frame_equal(fcst_inferred_df_index, fcst_inferred_df)"
    ]
   },
@@ -2124,7 +2187,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "show_doc(TimeGPT.plot, name='TimeGPT.plot', title_level=2)"
+    "show_doc(NixtlaClient.plot, name='NixtlaClient.plot', title_level=2)"
    ]
   },
   {
@@ -2134,7 +2197,7 @@
    "outputs": [],
    "source": [
     "#| hide\n",
-    "timegpt.plot(df, time_col='timestamp', target_col='value', engine='plotly')"
+    "nixtla_client.plot(df, time_col='timestamp', target_col='value', engine='plotly')"
    ]
   },
   {
@@ -2143,7 +2206,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "show_doc(TimeGPT.forecast, title_level=2)"
+    "show_doc(NixtlaClient.forecast, title_level=2)"
    ]
   },
   {
@@ -2158,9 +2221,9 @@
     "# (add_history)\n",
     "\n",
     "def test_equal_fcsts_add_history(**kwargs):\n",
-    "    fcst_no_rest_df = timegpt.forecast(**kwargs, add_history=True)\n",
+    "    fcst_no_rest_df = nixtla_client.forecast(**kwargs, add_history=True)\n",
     "    fcst_no_rest_df = fcst_no_rest_df.groupby('unique_id').tail(kwargs['h']).reset_index(drop=True)\n",
-    "    fcst_rest_df = timegpt.forecast(**kwargs)\n",
+    "    fcst_rest_df = nixtla_client.forecast(**kwargs)\n",
     "    pd.testing.assert_frame_equal(\n",
     "        fcst_no_rest_df,\n",
     "        fcst_rest_df,\n",
@@ -2199,7 +2262,7 @@
    "source": [
     "#| hide\n",
     "#test same results custom url\n",
-    "timegpt_custom = TimeGPT(\n",
+    "nixtla_client_custom = NixtlaClient(\n",
     "    api_key=os.environ['NIXTLA_API_KEY_CUSTOM'], \n",
     "    base_url=os.environ['NIXTLA_BASE_URL_CUSTOM'],\n",
     ")\n",
@@ -2212,8 +2275,8 @@
     "    time_col='timestamp', \n",
     "    target_col='value',\n",
     ")\n",
-    "fcst_df = timegpt.forecast(**fcst_kwargs)\n",
-    "fcst_df_custom = timegpt_custom.forecast(**fcst_kwargs)\n",
+    "fcst_df = nixtla_client.forecast(**fcst_kwargs)\n",
+    "fcst_df_custom = nixtla_client_custom.forecast(**fcst_kwargs)\n",
     "pd.testing.assert_frame_equal(\n",
     "    fcst_df,\n",
     "    fcst_df_custom,\n",
@@ -2225,8 +2288,8 @@
     "    time_col='timestamp', \n",
     "    target_col='value',\n",
     ")\n",
-    "anomalies_df = timegpt.detect_anomalies(**anomalies_kwargs)\n",
-    "anomalies_df_custom = timegpt.detect_anomalies(**anomalies_kwargs)\n",
+    "anomalies_df = nixtla_client.detect_anomalies(**anomalies_kwargs)\n",
+    "anomalies_df_custom = nixtla_client_custom.detect_anomalies(**anomalies_kwargs)\n",
     "pd.testing.assert_frame_equal(\n",
     "    anomalies_df,\n",
     "    anomalies_df_custom,\n",
@@ -2242,9 +2305,9 @@
     "#| hide\n",
     "# test different results for different models\n",
     "fcst_kwargs['model'] = 'timegpt-1'\n",
-    "fcst_timegpt_1 = timegpt.forecast(**fcst_kwargs)\n",
+    "fcst_timegpt_1 = nixtla_client.forecast(**fcst_kwargs)\n",
     "fcst_kwargs['model'] = 'timegpt-1-long-horizon'\n",
-    "fcst_timegpt_long = timegpt.forecast(**fcst_kwargs)\n",
+    "fcst_timegpt_long = nixtla_client.forecast(**fcst_kwargs)\n",
     "test_fail(\n",
     "    lambda: pd.testing.assert_frame_equal(fcst_timegpt_1[['TimeGPT']], fcst_timegpt_long[['TimeGPT']]),\n",
     "    contains='(column name=\"TimeGPT\") are different'\n",
@@ -2261,9 +2324,9 @@
     "# test different results for different models\n",
     "# anomalies\n",
     "anomalies_kwargs['model'] = 'timegpt-1'\n",
-    "anomalies_timegpt_1 = timegpt.detect_anomalies(**anomalies_kwargs)\n",
+    "anomalies_timegpt_1 = nixtla_client.detect_anomalies(**anomalies_kwargs)\n",
     "anomalies_kwargs['model'] = 'timegpt-1-long-horizon'\n",
-    "anomalies_timegpt_long = timegpt.detect_anomalies(**anomalies_kwargs)\n",
+    "anomalies_timegpt_long = nixtla_client.detect_anomalies(**anomalies_kwargs)\n",
     "test_fail(\n",
     "    lambda: pd.testing.assert_frame_equal(anomalies_timegpt_1[['TimeGPT']], anomalies_timegpt_long[['TimeGPT']]),\n",
     "    contains='(column name=\"TimeGPT\") are different'\n",
@@ -2280,7 +2343,7 @@
     "# test unsupported model\n",
     "fcst_kwargs['model'] = 'a-model'\n",
     "test_fail(\n",
-    "    lambda: timegpt.forecast(**fcst_kwargs),\n",
+    "    lambda: nixtla_client.forecast(**fcst_kwargs),\n",
     "    contains='unsupported model',\n",
     ")"
    ]
@@ -2295,7 +2358,7 @@
     "# test unsupported model\n",
     "anomalies_kwargs['model'] = 'my-awesome-model'\n",
     "test_fail(\n",
-    "    lambda: timegpt.detect_anomalies(**anomalies_kwargs),\n",
+    "    lambda: nixtla_client.detect_anomalies(**anomalies_kwargs),\n",
     "    contains='unsupported model',\n",
     ")"
    ]
@@ -2312,7 +2375,7 @@
     "df_.insert(0, 'unique_id', 'AirPassengers')\n",
     "df_actual_future = df_.tail(12)[['unique_id', 'ds']]\n",
     "df_history = df_.drop(df_actual_future.index)\n",
-    "df_future = _TimeGPTModel(client=timegpt.client, h=12, freq='MS').make_future_dataframe(df_history)\n",
+    "df_future = _NixtlaClientModel(client=nixtla_client.client, h=12, freq='MS').make_future_dataframe(df_history)\n",
     "pd.testing.assert_frame_equal(\n",
     "    df_actual_future.reset_index(drop=True),\n",
     "    df_future,\n",
@@ -2328,8 +2391,8 @@
     "#| hide\n",
     "# test add date features\n",
     "date_features = ['year', 'month']\n",
-    "df_date_features, future_df = _TimeGPTModel(\n",
-    "    client=timegpt.client,\n",
+    "df_date_features, future_df = _NixtlaClientModel(\n",
+    "    client=nixtla_client.client,\n",
     "    h=12, \n",
     "    freq='MS', \n",
     "    date_features=date_features,\n",
@@ -2345,7 +2408,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "show_doc(TimeGPT.cross_validation, title_level=2)"
+    "show_doc(NixtlaClient.cross_validation, title_level=2)"
    ]
   },
   {
@@ -2389,11 +2452,11 @@
     "for hyp in hyps:\n",
     "    main_logger.info(f'Hyperparameters: {hyp}')\n",
     "    main_logger.info('\\n\\nPerforming forecast\\n')\n",
-    "    fcst_test = timegpt.forecast(df_train.merge(df_ex_.drop(columns='y')), h=12, X_df=x_df_test, **hyp)\n",
+    "    fcst_test = nixtla_client.forecast(df_train.merge(df_ex_.drop(columns='y')), h=12, X_df=x_df_test, **hyp)\n",
     "    fcst_test = df_test[['unique_id', 'ds', 'y']].merge(fcst_test)\n",
     "    fcst_test = fcst_test.sort_values(['unique_id', 'ds']).reset_index(drop=True)\n",
     "    main_logger.info('\\n\\nPerforming Cross validation\\n')\n",
-    "    fcst_cv = timegpt.cross_validation(df_ex_, h=12, **hyp)\n",
+    "    fcst_cv = nixtla_client.cross_validation(df_ex_, h=12, **hyp)\n",
     "    fcst_cv = fcst_cv.sort_values(['unique_id', 'ds']).reset_index(drop=True)\n",
     "    main_logger.info('\\n\\nVerify difference\\n')\n",
     "    pd.testing.assert_frame_equal(\n",
@@ -2411,10 +2474,10 @@
    "source": [
     "#| hide\n",
     "for hyp in hyps:\n",
-    "    fcst_test = timegpt.forecast(df_train, h=12, **hyp)\n",
+    "    fcst_test = nixtla_client.forecast(df_train, h=12, **hyp)\n",
     "    fcst_test = df_test[['unique_id', 'ds', 'y']].merge(fcst_test)\n",
     "    fcst_test = fcst_test.sort_values(['unique_id', 'ds']).reset_index(drop=True)\n",
-    "    fcst_cv = timegpt.cross_validation(df_, h=12, **hyp)\n",
+    "    fcst_cv = nixtla_client.cross_validation(df_, h=12, **hyp)\n",
     "    fcst_cv = fcst_cv.sort_values(['unique_id', 'ds']).reset_index(drop=True)\n",
     "    pd.testing.assert_frame_equal(\n",
     "        fcst_test,\n",
@@ -2431,10 +2494,10 @@
    "source": [
     "#| hide\n",
     "for hyp in hyps:\n",
-    "    fcst_test = timegpt.forecast(df_train, h=12, **hyp)\n",
+    "    fcst_test = nixtla_client.forecast(df_train, h=12, **hyp)\n",
     "    fcst_test.insert(2, 'y', df_test['y'].values)\n",
     "    fcst_test = fcst_test.sort_values(['unique_id', 'ds']).reset_index(drop=True)\n",
-    "    fcst_cv = timegpt.cross_validation(df_, h=12, **hyp)\n",
+    "    fcst_cv = nixtla_client.cross_validation(df_, h=12, **hyp)\n",
     "    fcst_cv = fcst_cv.sort_values(['unique_id', 'ds']).reset_index(drop=True)\n",
     "    pd.testing.assert_frame_equal(\n",
     "        fcst_test,\n",
@@ -2464,8 +2527,8 @@
     "date_features = [SpecialDates({'first_dates': ['2021-01-1'], 'second_dates': ['2021-01-01']})]\n",
     "df_daily = df_.copy()\n",
     "df_daily['ds'] = pd.date_range(end='2021-01-01', periods=len(df_daily))\n",
-    "df_date_features, future_df = _TimeGPTModel(\n",
-    "    client=timegpt.client,\n",
+    "df_date_features, future_df = _NixtlaClientModel(\n",
+    "    client=nixtla_client.client,\n",
     "    h=12, \n",
     "    freq='D', \n",
     "    date_features=date_features,\n",
@@ -2485,8 +2548,8 @@
     "# test add date features one hot encoded\n",
     "date_features = ['year', 'month']\n",
     "date_features_to_one_hot = ['month']\n",
-    "df_date_features, future_df = _TimeGPTModel(\n",
-    "    client=timegpt.client,\n",
+    "df_date_features, future_df = _NixtlaClientModel(\n",
+    "    client=nixtla_client.client,\n",
     "    h=12, \n",
     "    freq='D', \n",
     "    date_features=date_features,\n",
@@ -2504,8 +2567,8 @@
     "# test future dataframe for multiple series\n",
     "df_ = pd.read_csv('https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/electricity-short-with-ex-vars.csv')\n",
     "df_actual_future = pd.read_csv('https://raw.githubusercontent.com/Nixtla/transfer-learning-time-series/main/datasets/electricity-short-future-ex-vars.csv')\n",
-    "df_future = _TimeGPTModel(\n",
-    "        client=timegpt.client, \n",
+    "df_future = _NixtlaClientModel(\n",
+    "        client=nixtla_client.client, \n",
     "        h=24, \n",
     "        freq='H',\n",
     "    ).make_future_dataframe(df_[['unique_id', 'ds', 'y']])\n",
@@ -2524,10 +2587,10 @@
     "# test pass dataframe with index\n",
     "df_ds_index = df_.set_index('ds')[['unique_id', 'y']]\n",
     "df_ds_index.index = pd.DatetimeIndex(df_ds_index.index)\n",
-    "fcst_inferred_df_index = timegpt.forecast(df_ds_index, h=10)\n",
-    "anom_inferred_df_index = timegpt.detect_anomalies(df_ds_index)\n",
-    "fcst_inferred_df = timegpt.forecast(df_[['ds', 'unique_id', 'y']], h=10)\n",
-    "anom_inferred_df = timegpt.detect_anomalies(df_[['ds', 'unique_id', 'y']])\n",
+    "fcst_inferred_df_index = nixtla_client.forecast(df_ds_index, h=10)\n",
+    "anom_inferred_df_index = nixtla_client.detect_anomalies(df_ds_index)\n",
+    "fcst_inferred_df = nixtla_client.forecast(df_[['ds', 'unique_id', 'y']], h=10)\n",
+    "anom_inferred_df = nixtla_client.detect_anomalies(df_[['ds', 'unique_id', 'y']])\n",
     "pd.testing.assert_frame_equal(fcst_inferred_df_index, fcst_inferred_df, atol=1e-3)\n",
     "pd.testing.assert_frame_equal(anom_inferred_df_index, anom_inferred_df, atol=1e-3)\n",
     "df_ds_index = df_ds_index.groupby('unique_id').tail(80)\n",
@@ -2536,9 +2599,9 @@
     "        df_ds_index['unique_id'].nunique() * [pd.date_range(end='2023-01-01', periods=80, freq=freq)]\n",
     "    )\n",
     "    df_ds_index.index.name = 'ds'\n",
-    "    fcst_inferred_df_index = timegpt.forecast(df_ds_index, h=10)\n",
+    "    fcst_inferred_df_index = nixtla_client.forecast(df_ds_index, h=10)\n",
     "    df_test = df_ds_index.reset_index()\n",
-    "    fcst_inferred_df = timegpt.forecast(df_test, h=10)\n",
+    "    fcst_inferred_df = nixtla_client.forecast(df_test, h=10)\n",
     "    pd.testing.assert_frame_equal(fcst_inferred_df_index, fcst_inferred_df, atol=1e-3)"
    ]
   },
@@ -2552,8 +2615,8 @@
     "# test add date features with exogenous variables \n",
     "# and multiple series\n",
     "date_features = ['year', 'month']\n",
-    "df_date_features, future_df = _TimeGPTModel(\n",
-    "    client=timegpt.client,\n",
+    "df_date_features, future_df = _NixtlaClientModel(\n",
+    "    client=nixtla_client.client,\n",
     "    h=24, \n",
     "    freq='H', \n",
     "    date_features=date_features,\n",
@@ -2581,8 +2644,8 @@
     "# test add date features one hot with exogenous variables \n",
     "# and multiple series\n",
     "date_features = ['month', 'day']\n",
-    "df_date_features, future_df = _TimeGPTModel(\n",
-    "    client=timegpt.client,\n",
+    "df_date_features, future_df = _NixtlaClientModel(\n",
+    "    client=nixtla_client.client,\n",
     "    h=24, \n",
     "    freq='H', \n",
     "    date_features=date_features,\n",
@@ -2606,7 +2669,7 @@
    "source": [
     "#| hide\n",
     "# test warning horizon too long\n",
-    "timegpt.forecast(df=df.tail(3), h=100, time_col='timestamp', target_col='value')"
+    "nixtla_client.forecast(df=df.tail(3), h=100, time_col='timestamp', target_col='value')"
    ]
   },
   {
@@ -2618,7 +2681,7 @@
     "#| hide \n",
     "# test short horizon with add_history\n",
     "test_fail(\n",
-    "    lambda: timegpt.forecast(df=df.tail(3), h=12, time_col='timestamp', target_col='value', add_history=True),\n",
+    "    lambda: nixtla_client.forecast(df=df.tail(3), h=12, time_col='timestamp', target_col='value', add_history=True),\n",
     "    contains='be sure'\n",
     ")"
    ]
@@ -2632,7 +2695,7 @@
     "#| hide \n",
     "# test short horizon with finetunning\n",
     "test_fail(\n",
-    "    lambda: timegpt.forecast(df=df.tail(3), h=12, time_col='timestamp', target_col='value', finetune_steps=10, finetune_loss='mae'),\n",
+    "    lambda: nixtla_client.forecast(df=df.tail(3), h=12, time_col='timestamp', target_col='value', finetune_steps=10, finetune_loss='mae'),\n",
     "    contains='be sure'\n",
     ")"
    ]
@@ -2646,7 +2709,7 @@
     "#| hide \n",
     "# test short horizon with level\n",
     "test_fail(\n",
-    "    lambda: timegpt.forecast(df=df.tail(3), h=12, time_col='timestamp', target_col='value', level=[80, 90]),\n",
+    "    lambda: nixtla_client.forecast(df=df.tail(3), h=12, time_col='timestamp', target_col='value', level=[80, 90]),\n",
     "    contains='be sure'\n",
     ")"
    ]
@@ -2660,8 +2723,8 @@
     "#| hide\n",
     "# test custom url\n",
     "# same results\n",
-    "_timegpt_fcst_df = _timegpt.forecast(df=df, h=12, time_col='timestamp', target_col='value')\n",
-    "timegpt_fcst_df = timegpt.forecast(df=df, h=12, time_col='timestamp', target_col='value')\n",
+    "_timegpt_fcst_df = _nixtla_client.forecast(df=df, h=12, time_col='timestamp', target_col='value')\n",
+    "timegpt_fcst_df = nixtla_client.forecast(df=df, h=12, time_col='timestamp', target_col='value')\n",
     "pd.testing.assert_frame_equal(\n",
     "    _timegpt_fcst_df,\n",
     "    timegpt_fcst_df,\n",
@@ -2683,9 +2746,9 @@
     "df_test.drop(columns=\"timestamp\", inplace=True)\n",
     "\n",
     "# Using user_provided time_col and freq\n",
-    "timegpt_anomalies_df_1 = timegpt.detect_anomalies(df, time_col='timestamp', target_col='value', freq= 'M')\n",
+    "timegpt_anomalies_df_1 = nixtla_client.detect_anomalies(df, time_col='timestamp', target_col='value', freq= 'M')\n",
     "# Infer time_col and freq from index\n",
-    "timegpt_anomalies_df_2 = timegpt.detect_anomalies(df_test, time_col='timestamp', target_col='value')\n",
+    "timegpt_anomalies_df_2 = nixtla_client.detect_anomalies(df_test, time_col='timestamp', target_col='value')\n",
     "\n",
     "pd.testing.assert_frame_equal(\n",
     "    timegpt_anomalies_df_1,\n",
@@ -2699,15 +2762,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "show_doc(TimeGPT.detect_anomalies, title_level=2)"
+    "show_doc(NixtlaClient.detect_anomalies, title_level=2)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/nbs/sidebar.yml b/nbs/sidebar.yml
index d88dcf15..d3016d7d 100644
--- a/nbs/sidebar.yml
+++ b/nbs/sidebar.yml
@@ -15,5 +15,5 @@ website:
         contents: docs/misc/*
       - section: "API Reference"
         contents: 
-        - timegpt.ipynb
+        - nixtla_client.ipynb
         - date_features.ipynb
diff --git a/nixtlats/__init__.py b/nixtlats/__init__.py
index 4e610bce..b26fbc0e 100644
--- a/nixtlats/__init__.py
+++ b/nixtlats/__init__.py
@@ -1,3 +1,3 @@
 __version__ = "0.2.0"
 __all__ = ["TimeGPT"]
-from .timegpt import TimeGPT
+from .nixtla_client import NixtlaClient, TimeGPT
diff --git a/nixtlats/_modidx.py b/nixtlats/_modidx.py
index ab25a6b4..d76a9389 100644
--- a/nixtlats/_modidx.py
+++ b/nixtlats/_modidx.py
@@ -31,99 +31,114 @@
                                                                                      'nixtlats/date_features.py'),
                                         'nixtlats.date_features._transform_dict_holidays': ( 'date_features.html#_transform_dict_holidays',
                                                                                              'nixtlats/date_features.py')},
-            'nixtlats.distributed.timegpt': { 'nixtlats.distributed.timegpt._DistributedTimeGPT': ( 'distributed.timegpt.html#_distributedtimegpt',
-                                                                                                    'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT.__init__': ( 'distributed.timegpt.html#_distributedtimegpt.__init__',
-                                                                                                             'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._cross_validation': ( 'distributed.timegpt.html#_distributedtimegpt._cross_validation',
-                                                                                                                      'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._detect_anomalies': ( 'distributed.timegpt.html#_distributedtimegpt._detect_anomalies',
-                                                                                                                      'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._distribute_method': ( 'distributed.timegpt.html#_distributedtimegpt._distribute_method',
-                                                                                                                       'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._forecast': ( 'distributed.timegpt.html#_distributedtimegpt._forecast',
-                                                                                                              'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._forecast_x': ( 'distributed.timegpt.html#_distributedtimegpt._forecast_x',
-                                                                                                                'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._get_anomalies_schema': ( 'distributed.timegpt.html#_distributedtimegpt._get_anomalies_schema',
-                                                                                                                          'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._get_forecast_schema': ( 'distributed.timegpt.html#_distributedtimegpt._get_forecast_schema',
-                                                                                                                         'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT._instantiate_timegpt': ( 'distributed.timegpt.html#_distributedtimegpt._instantiate_timegpt',
-                                                                                                                         'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT.cross_validation': ( 'distributed.timegpt.html#_distributedtimegpt.cross_validation',
-                                                                                                                     'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT.detect_anomalies': ( 'distributed.timegpt.html#_distributedtimegpt.detect_anomalies',
-                                                                                                                     'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._DistributedTimeGPT.forecast': ( 'distributed.timegpt.html#_distributedtimegpt.forecast',
-                                                                                                             'nixtlats/distributed/timegpt.py'),
-                                              'nixtlats.distributed.timegpt._cotransform': ( 'distributed.timegpt.html#_cotransform',
-                                                                                             'nixtlats/distributed/timegpt.py')},
+            'nixtlats.distributed.nixtla_client': { 'nixtlats.distributed.nixtla_client._DistributedNixtlaClient': ( 'distributed.nixtla_client.html#_distributednixtlaclient',
+                                                                                                                     'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient.__init__': ( 'distributed.nixtla_client.html#_distributednixtlaclient.__init__',
+                                                                                                                              'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._cross_validation': ( 'distributed.nixtla_client.html#_distributednixtlaclient._cross_validation',
+                                                                                                                                       'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._detect_anomalies': ( 'distributed.nixtla_client.html#_distributednixtlaclient._detect_anomalies',
+                                                                                                                                       'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._distribute_method': ( 'distributed.nixtla_client.html#_distributednixtlaclient._distribute_method',
+                                                                                                                                        'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._forecast': ( 'distributed.nixtla_client.html#_distributednixtlaclient._forecast',
+                                                                                                                               'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._forecast_x': ( 'distributed.nixtla_client.html#_distributednixtlaclient._forecast_x',
+                                                                                                                                 'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._get_anomalies_schema': ( 'distributed.nixtla_client.html#_distributednixtlaclient._get_anomalies_schema',
+                                                                                                                                           'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._get_forecast_schema': ( 'distributed.nixtla_client.html#_distributednixtlaclient._get_forecast_schema',
+                                                                                                                                          'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient._instantiate_nixtla_client': ( 'distributed.nixtla_client.html#_distributednixtlaclient._instantiate_nixtla_client',
+                                                                                                                                                'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient.cross_validation': ( 'distributed.nixtla_client.html#_distributednixtlaclient.cross_validation',
+                                                                                                                                      'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient.detect_anomalies': ( 'distributed.nixtla_client.html#_distributednixtlaclient.detect_anomalies',
+                                                                                                                                      'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._DistributedNixtlaClient.forecast': ( 'distributed.nixtla_client.html#_distributednixtlaclient.forecast',
+                                                                                                                              'nixtlats/distributed/nixtla_client.py'),
+                                                    'nixtlats.distributed.nixtla_client._cotransform': ( 'distributed.nixtla_client.html#_cotransform',
+                                                                                                         'nixtlats/distributed/nixtla_client.py')},
             'nixtlats.errors.unprocessable_entity_error': {},
-            'nixtlats.timegpt': { 'nixtlats.timegpt.TimeGPT': ('timegpt.html#timegpt', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.TimeGPT._instantiate_distributed_timegpt': ( 'timegpt.html#timegpt._instantiate_distributed_timegpt',
-                                                                                                 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.TimeGPT.cross_validation': ( 'timegpt.html#timegpt.cross_validation',
-                                                                                 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.TimeGPT.detect_anomalies': ( 'timegpt.html#timegpt.detect_anomalies',
-                                                                                 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.TimeGPT.forecast': ('timegpt.html#timegpt.forecast', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT': ('timegpt.html#_timegpt', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT.__init__': ('timegpt.html#_timegpt.__init__', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT._cross_validation': ( 'timegpt.html#_timegpt._cross_validation',
-                                                                                   'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT._detect_anomalies': ( 'timegpt.html#_timegpt._detect_anomalies',
-                                                                                   'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT._forecast': ('timegpt.html#_timegpt._forecast', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT.plot': ('timegpt.html#_timegpt.plot', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT.validate_api_key': ( 'timegpt.html#_timegpt.validate_api_key',
-                                                                                  'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPT.validate_token': ( 'timegpt.html#_timegpt.validate_token',
-                                                                                'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel': ('timegpt.html#_timegptmodel', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.__init__': ('timegpt.html#_timegptmodel.__init__', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel._call_api': ( 'timegpt.html#_timegptmodel._call_api',
-                                                                                'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel._prepare_level_and_quantiles': ( 'timegpt.html#_timegptmodel._prepare_level_and_quantiles',
-                                                                                                   'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel._retry_strategy': ( 'timegpt.html#_timegptmodel._retry_strategy',
-                                                                                      'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.add_date_features': ( 'timegpt.html#_timegptmodel.add_date_features',
-                                                                                        'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.compute_date_feature': ( 'timegpt.html#_timegptmodel.compute_date_feature',
-                                                                                           'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.cross_validation': ( 'timegpt.html#_timegptmodel.cross_validation',
-                                                                                       'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.dataframes_to_dict': ( 'timegpt.html#_timegptmodel.dataframes_to_dict',
-                                                                                         'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.detect_anomalies': ( 'timegpt.html#_timegptmodel.detect_anomalies',
-                                                                                       'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.forecast': ('timegpt.html#_timegptmodel.forecast', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.infer_freq': ( 'timegpt.html#_timegptmodel.infer_freq',
-                                                                                 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.make_future_dataframe': ( 'timegpt.html#_timegptmodel.make_future_dataframe',
-                                                                                            'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.preprocess_X_df': ( 'timegpt.html#_timegptmodel.preprocess_x_df',
-                                                                                      'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.preprocess_dataframes': ( 'timegpt.html#_timegptmodel.preprocess_dataframes',
-                                                                                            'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.resample_dataframe': ( 'timegpt.html#_timegptmodel.resample_dataframe',
-                                                                                         'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.set_model_params': ( 'timegpt.html#_timegptmodel.set_model_params',
-                                                                                       'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.transform_inputs': ( 'timegpt.html#_timegptmodel.transform_inputs',
-                                                                                       'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.transform_outputs': ( 'timegpt.html#_timegptmodel.transform_outputs',
-                                                                                        'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt._TimeGPTModel.validate_input_size': ( 'timegpt.html#_timegptmodel.validate_input_size',
-                                                                                          'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.deprecated_argument': ('timegpt.html#deprecated_argument', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.deprecated_method': ('timegpt.html#deprecated_method', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.partition_by_uid': ('timegpt.html#partition_by_uid', 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.remove_unused_categories': ( 'timegpt.html#remove_unused_categories',
-                                                                                 'nixtlats/timegpt.py'),
-                                  'nixtlats.timegpt.validate_model_parameter': ( 'timegpt.html#validate_model_parameter',
-                                                                                 'nixtlats/timegpt.py')},
+            'nixtlats.nixtla_client': { 'nixtlats.nixtla_client.NixtlaClient': ( 'nixtla_client.html#nixtlaclient',
+                                                                                 'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.NixtlaClient._instantiate_distributed_nixtla_client': ( 'nixtla_client.html#nixtlaclient._instantiate_distributed_nixtla_client',
+                                                                                                                        'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.NixtlaClient.cross_validation': ( 'nixtla_client.html#nixtlaclient.cross_validation',
+                                                                                                  'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.NixtlaClient.detect_anomalies': ( 'nixtla_client.html#nixtlaclient.detect_anomalies',
+                                                                                                  'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.NixtlaClient.forecast': ( 'nixtla_client.html#nixtlaclient.forecast',
+                                                                                          'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.TimeGPT': ('nixtla_client.html#timegpt', 'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.TimeGPT.__init__': ( 'nixtla_client.html#timegpt.__init__',
+                                                                                     'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient': ( 'nixtla_client.html#_nixtlaclient',
+                                                                                  'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient.__init__': ( 'nixtla_client.html#_nixtlaclient.__init__',
+                                                                                           'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient._cross_validation': ( 'nixtla_client.html#_nixtlaclient._cross_validation',
+                                                                                                    'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient._detect_anomalies': ( 'nixtla_client.html#_nixtlaclient._detect_anomalies',
+                                                                                                    'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient._forecast': ( 'nixtla_client.html#_nixtlaclient._forecast',
+                                                                                            'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient.plot': ( 'nixtla_client.html#_nixtlaclient.plot',
+                                                                                       'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient.validate_api_key': ( 'nixtla_client.html#_nixtlaclient.validate_api_key',
+                                                                                                   'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClient.validate_token': ( 'nixtla_client.html#_nixtlaclient.validate_token',
+                                                                                                 'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel': ( 'nixtla_client.html#_nixtlaclientmodel',
+                                                                                       'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.__init__': ( 'nixtla_client.html#_nixtlaclientmodel.__init__',
+                                                                                                'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel._call_api': ( 'nixtla_client.html#_nixtlaclientmodel._call_api',
+                                                                                                 'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel._prepare_level_and_quantiles': ( 'nixtla_client.html#_nixtlaclientmodel._prepare_level_and_quantiles',
+                                                                                                                    'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel._retry_strategy': ( 'nixtla_client.html#_nixtlaclientmodel._retry_strategy',
+                                                                                                       'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.add_date_features': ( 'nixtla_client.html#_nixtlaclientmodel.add_date_features',
+                                                                                                         'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.compute_date_feature': ( 'nixtla_client.html#_nixtlaclientmodel.compute_date_feature',
+                                                                                                            'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.cross_validation': ( 'nixtla_client.html#_nixtlaclientmodel.cross_validation',
+                                                                                                        'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.dataframes_to_dict': ( 'nixtla_client.html#_nixtlaclientmodel.dataframes_to_dict',
+                                                                                                          'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.detect_anomalies': ( 'nixtla_client.html#_nixtlaclientmodel.detect_anomalies',
+                                                                                                        'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.forecast': ( 'nixtla_client.html#_nixtlaclientmodel.forecast',
+                                                                                                'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.infer_freq': ( 'nixtla_client.html#_nixtlaclientmodel.infer_freq',
+                                                                                                  'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.make_future_dataframe': ( 'nixtla_client.html#_nixtlaclientmodel.make_future_dataframe',
+                                                                                                             'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.preprocess_X_df': ( 'nixtla_client.html#_nixtlaclientmodel.preprocess_x_df',
+                                                                                                       'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.preprocess_dataframes': ( 'nixtla_client.html#_nixtlaclientmodel.preprocess_dataframes',
+                                                                                                             'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.resample_dataframe': ( 'nixtla_client.html#_nixtlaclientmodel.resample_dataframe',
+                                                                                                          'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.set_model_params': ( 'nixtla_client.html#_nixtlaclientmodel.set_model_params',
+                                                                                                        'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.transform_inputs': ( 'nixtla_client.html#_nixtlaclientmodel.transform_inputs',
+                                                                                                        'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.transform_outputs': ( 'nixtla_client.html#_nixtlaclientmodel.transform_outputs',
+                                                                                                         'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client._NixtlaClientModel.validate_input_size': ( 'nixtla_client.html#_nixtlaclientmodel.validate_input_size',
+                                                                                                           'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.deprecated_argument': ( 'nixtla_client.html#deprecated_argument',
+                                                                                        'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.deprecated_method': ( 'nixtla_client.html#deprecated_method',
+                                                                                      'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.partition_by_uid': ( 'nixtla_client.html#partition_by_uid',
+                                                                                     'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.remove_unused_categories': ( 'nixtla_client.html#remove_unused_categories',
+                                                                                             'nixtlats/nixtla_client.py'),
+                                        'nixtlats.nixtla_client.validate_model_parameter': ( 'nixtla_client.html#validate_model_parameter',
+                                                                                             'nixtlats/nixtla_client.py')},
             'nixtlats.types.http_validation_error': {},
             'nixtlats.types.multi_series_anomaly': {},
             'nixtlats.types.multi_series_anomaly_model': {},
diff --git a/nixtlats/distributed/timegpt.py b/nixtlats/distributed/nixtla_client.py
similarity index 92%
rename from nixtlats/distributed/timegpt.py
rename to nixtlats/distributed/nixtla_client.py
index 23a038e5..172bfac7 100644
--- a/nixtlats/distributed/timegpt.py
+++ b/nixtlats/distributed/nixtla_client.py
@@ -1,9 +1,9 @@
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../../nbs/distributed.timegpt.ipynb.
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../../nbs/distributed.nixtla_client.ipynb.
 
 # %% auto 0
 __all__ = []
 
-# %% ../../nbs/distributed.timegpt.ipynb 2
+# %% ../../nbs/distributed.nixtla_client.ipynb 2
 from typing import Any, Callable, Dict, List, Optional, Union
 
 import numpy as np
@@ -16,7 +16,7 @@
 from fugue.execution.factory import make_execution_engine
 from triad import Schema
 
-# %% ../../nbs/distributed.timegpt.ipynb 3
+# %% ../../nbs/distributed.nixtla_client.ipynb 3
 def _cotransform(
     df1: Any,
     df2: Any,
@@ -45,8 +45,8 @@ def _cotransform(
         return result
     return result.as_pandas() if result.is_local else result.native  # type:ignore
 
-# %% ../../nbs/distributed.timegpt.ipynb 4
-class _DistributedTimeGPT:
+# %% ../../nbs/distributed.nixtla_client.ipynb 4
+class _DistributedNixtlaClient:
 
     def __init__(
         self,
@@ -265,25 +265,25 @@ def cross_validation(
         )
         return fcst_df
 
-    def _instantiate_timegpt(self):
-        from nixtlats.timegpt import _TimeGPT
+    def _instantiate_nixtla_client(self):
+        from nixtlats.nixtla_client import _NixtlaClient
 
-        timegpt = _TimeGPT(
+        nixtla_client = _NixtlaClient(
             api_key=self.api_key,
             base_url=self.base_url,
             max_retries=self.max_retries,
             retry_interval=self.retry_interval,
             max_wait_time=self.max_wait_time,
         )
-        return timegpt
+        return nixtla_client
 
     def _forecast(
         self,
         df: pd.DataFrame,
         kwargs,
     ) -> pd.DataFrame:
-        timegpt = self._instantiate_timegpt()
-        return timegpt._forecast(df=df, **kwargs)
+        nixtla_client = self._instantiate_nixtla_client()
+        return nixtla_client._forecast(df=df, **kwargs)
 
     def _forecast_x(
         self,
@@ -291,24 +291,24 @@ def _forecast_x(
         X_df: pd.DataFrame,
         kwargs,
     ) -> pd.DataFrame:
-        timegpt = self._instantiate_timegpt()
-        return timegpt._forecast(df=df, X_df=X_df, **kwargs)
+        nixtla_client = self._instantiate_nixtla_client()
+        return nixtla_client._forecast(df=df, X_df=X_df, **kwargs)
 
     def _detect_anomalies(
         self,
         df: pd.DataFrame,
         kwargs,
     ) -> pd.DataFrame:
-        timegpt = self._instantiate_timegpt()
-        return timegpt._detect_anomalies(df=df, **kwargs)
+        nixtla_client = self._instantiate_nixtla_client()
+        return nixtla_client._detect_anomalies(df=df, **kwargs)
 
     def _cross_validation(
         self,
         df: pd.DataFrame,
         kwargs,
     ) -> pd.DataFrame:
-        timegpt = self._instantiate_timegpt()
-        return timegpt._cross_validation(df=df, **kwargs)
+        nixtla_client = self._instantiate_nixtla_client()
+        return nixtla_client._cross_validation(df=df, **kwargs)
 
     @staticmethod
     def _get_forecast_schema(id_col, time_col, level, quantiles, cv=False):
diff --git a/nixtlats/timegpt.py b/nixtlats/nixtla_client.py
similarity index 95%
rename from nixtlats/timegpt.py
rename to nixtlats/nixtla_client.py
index 5ea0dc86..8317eb4f 100644
--- a/nixtlats/timegpt.py
+++ b/nixtlats/nixtla_client.py
@@ -1,9 +1,9 @@
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/timegpt.ipynb.
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/nixtla_client.ipynb.
 
 # %% auto 0
 __all__ = ['main_logger', 'httpx_logger']
 
-# %% ../nbs/timegpt.ipynb 3
+# %% ../nbs/nixtla_client.ipynb 3
 import functools
 import inspect
 import json
@@ -47,7 +47,7 @@
 httpx_logger = logging.getLogger("httpx")
 httpx_logger.setLevel(logging.ERROR)
 
-# %% ../nbs/timegpt.ipynb 5
+# %% ../nbs/nixtla_client.ipynb 5
 def deprecated_argument(old_name, new_name):
     def decorator(func):
         @functools.wraps(func)
@@ -66,7 +66,7 @@ def wrapper(*args, **kwargs):
 
     return decorator
 
-# %% ../nbs/timegpt.ipynb 6
+# %% ../nbs/nixtla_client.ipynb 6
 def deprecated_method(new_method):
     def decorator(func):
         @functools.wraps(func)
@@ -83,16 +83,16 @@ def wrapper(self, *args, **kwargs):
 
     return decorator
 
-# %% ../nbs/timegpt.ipynb 7
+# %% ../nbs/nixtla_client.ipynb 7
 deprecated_fewshot_steps = deprecated_argument("fewshot_steps", "finetune_steps")
 deprecated_fewshot_loss = deprecated_argument("fewshot_loss", "finetune_loss")
 deprecated_token = deprecated_argument("token", "api_key")
 deprecated_environment = deprecated_argument("environment", "base_url")
 
-# %% ../nbs/timegpt.ipynb 8
+# %% ../nbs/nixtla_client.ipynb 8
 use_validate_api_key = deprecated_method(new_method="validate_api_key")
 
-# %% ../nbs/timegpt.ipynb 9
+# %% ../nbs/nixtla_client.ipynb 9
 date_features_by_freq = {
     # Daily frequencies
     "B": ["year", "month", "day", "weekday"],
@@ -141,8 +141,8 @@ def wrapper(self, *args, **kwargs):
     "N": [],
 }
 
-# %% ../nbs/timegpt.ipynb 10
-class _TimeGPTModel:
+# %% ../nbs/nixtla_client.ipynb 10
+class _NixtlaClientModel:
 
     def __init__(
         self,
@@ -709,7 +709,7 @@ def cross_validation(
         fcst_cv_df = self.transform_outputs(fcst_cv_df)
         return fcst_cv_df
 
-# %% ../nbs/timegpt.ipynb 11
+# %% ../nbs/nixtla_client.ipynb 11
 def validate_model_parameter(func):
     def wrapper(self, *args, **kwargs):
         if "model" in kwargs:
@@ -734,7 +734,7 @@ def wrapper(self, *args, **kwargs):
 
     return wrapper
 
-# %% ../nbs/timegpt.ipynb 12
+# %% ../nbs/nixtla_client.ipynb 12
 def remove_unused_categories(df: pd.DataFrame, col: str):
     """Check if col exists in df and if it is a category column.
     In that case, it removes the unused levels."""
@@ -744,7 +744,7 @@ def remove_unused_categories(df: pd.DataFrame, col: str):
             df[col] = df[col].cat.remove_unused_categories()
     return df
 
-# %% ../nbs/timegpt.ipynb 13
+# %% ../nbs/nixtla_client.ipynb 13
 def partition_by_uid(func):
     def wrapper(self, num_partitions, **kwargs):
         if num_partitions is None or num_partitions == 1:
@@ -772,10 +772,10 @@ def wrapper(self, num_partitions, **kwargs):
 
     return wrapper
 
-# %% ../nbs/timegpt.ipynb 14
-class _TimeGPT:
+# %% ../nbs/nixtla_client.ipynb 14
+class _NixtlaClient:
     """
-    A class used to interact with the TimeGPT API.
+    A class used to interact with Nixtla API.
     """
 
     @deprecated_token
@@ -789,12 +789,12 @@ def __init__(
         max_wait_time: int = 6 * 60,
     ):
         """
-        Constructs all the necessary attributes for the TimeGPT object.
+        Constructs all the necessary attributes for the NixtlaClient object.
 
         Parameters
         ----------
         api_key : str, (default=None)
-            The authorization api_key interacts with the TimeGPT API.
+            The authorization api_key interacts with the Nixtla API.
             If not provided, it will be inferred by the NIXTLA_API_KEY environment variable.
         base_url : str, (default=None)
             Custom base_url. Pass only if provided.
@@ -849,8 +849,11 @@ def validate_token(self):
 
     def validate_api_key(self, log: bool = True) -> bool:
         """Returns True if your api_key is valid."""
-        validation = self.client.validate_token()
         valid = False
+        try:
+            validation = self.client.validate_token()
+        except:
+            validation = dict()
         if "message" in validation:
             if validation["message"] == "success":
                 valid = True
@@ -886,7 +889,7 @@ def _forecast(
     ):
         if validate_api_key and not self.validate_api_key(log=False):
             raise Exception("API Key not valid, please email ops@nixtla.io")
-        timegpt_model = _TimeGPTModel(
+        nixtla_client_model = _NixtlaClientModel(
             client=self.client,
             h=h,
             id_col=id_col,
@@ -905,8 +908,10 @@ def _forecast(
             retry_interval=self.retry_interval,
             max_wait_time=self.max_wait_time,
         )
-        fcst_df = timegpt_model.forecast(df=df, X_df=X_df, add_history=add_history)
-        self.weights_x = timegpt_model.weights_x
+        fcst_df = nixtla_client_model.forecast(
+            df=df, X_df=X_df, add_history=add_history
+        )
+        self.weights_x = nixtla_client_model.weights_x
         return fcst_df
 
     @validate_model_parameter
@@ -928,7 +933,7 @@ def _detect_anomalies(
     ):
         if validate_api_key and not self.validate_api_key(log=False):
             raise Exception("API Key not valid, please email ops@nixtla.io")
-        timegpt_model = _TimeGPTModel(
+        nixtla_client_model = _NixtlaClientModel(
             client=self.client,
             h=None,
             id_col=id_col,
@@ -944,8 +949,8 @@ def _detect_anomalies(
             retry_interval=self.retry_interval,
             max_wait_time=self.max_wait_time,
         )
-        anomalies_df = timegpt_model.detect_anomalies(df=df)
-        self.weights_x = timegpt_model.weights_x
+        anomalies_df = nixtla_client_model.detect_anomalies(df=df)
+        self.weights_x = nixtla_client_model.weights_x
         return anomalies_df
 
     @validate_model_parameter
@@ -973,7 +978,7 @@ def _cross_validation(
     ):
         if validate_api_key and not self.validate_api_key(log=False):
             raise Exception("API Key not valid, please email ops@nixtla.io")
-        timegpt_model = _TimeGPTModel(
+        nixtla_client_model = _NixtlaClientModel(
             client=self.client,
             h=h,
             id_col=id_col,
@@ -992,10 +997,10 @@ def _cross_validation(
             retry_interval=self.retry_interval,
             max_wait_time=self.max_wait_time,
         )
-        cv_df = timegpt_model.cross_validation(
+        cv_df = nixtla_client_model.cross_validation(
             df=df, n_windows=n_windows, step_size=step_size
         )
-        self.weights_x = timegpt_model.weights_x
+        self.weights_x = nixtla_client_model.weights_x
         return cv_df
 
     def plot(
@@ -1107,20 +1112,20 @@ def plot(
             target_col=target_col,
         )
 
-# %% ../nbs/timegpt.ipynb 15
-class TimeGPT(_TimeGPT):
+# %% ../nbs/nixtla_client.ipynb 15
+class NixtlaClient(_NixtlaClient):
 
-    def _instantiate_distributed_timegpt(self):
-        from nixtlats.distributed.timegpt import _DistributedTimeGPT
+    def _instantiate_distributed_nixtla_client(self):
+        from nixtlats.distributed.nixtla_client import _DistributedNixtlaClient
 
-        dist_timegpt = _DistributedTimeGPT(
+        dist_nixtla_client = _DistributedNixtlaClient(
             api_key=self.client._client_wrapper._token,
             base_url=self.client._client_wrapper._base_url,
             max_retries=self.max_retries,
             retry_interval=self.retry_interval,
             max_wait_time=self.max_wait_time,
         )
-        return dist_timegpt
+        return dist_nixtla_client
 
     @deprecated_fewshot_loss
     @deprecated_fewshot_steps
@@ -1243,8 +1248,8 @@ def forecast(
                 num_partitions=num_partitions,
             )
         else:
-            dist_timegpt = self._instantiate_distributed_timegpt()
-            return dist_timegpt.forecast(
+            dist_nixtla_client = self._instantiate_distributed_nixtla_client()
+            return dist_nixtla_client.forecast(
                 df=df,
                 h=h,
                 freq=freq,
@@ -1353,8 +1358,8 @@ def detect_anomalies(
                 num_partitions=num_partitions,
             )
         else:
-            dist_timegpt = self._instantiate_distributed_timegpt()
-            return dist_timegpt.detect_anomalies(
+            dist_nixtla_client = self._instantiate_distributed_nixtla_client()
+            return dist_nixtla_client.detect_anomalies(
                 df=df,
                 freq=freq,
                 id_col=id_col,
@@ -1489,8 +1494,8 @@ def cross_validation(
                 num_partitions=num_partitions,
             )
         else:
-            dist_timegpt = self._instantiate_distributed_timegpt()
-            return dist_timegpt.cross_validation(
+            dist_nixtla_client = self._instantiate_distributed_nixtla_client()
+            return dist_nixtla_client.cross_validation(
                 df=df,
                 h=h,
                 freq=freq,
@@ -1510,3 +1515,20 @@ def cross_validation(
                 n_windows=n_windows,
                 step_size=step_size,
             )
+
+# %% ../nbs/nixtla_client.ipynb 16
+class TimeGPT(NixtlaClient):
+    """
+    Class `TimeGPT` is deprecated; use `NixtlaClient` instead.
+
+    This class is deprecated and may be removed in future releases.
+    Please use `NixtlaClient` instead.
+
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        warnings.warn(
+            "Class `TimeGPT` is deprecated; use `NixtlaClient` instead.",
+            FutureWarning,
+        )