---
title: "Stop, start, and restart an instance"
description: "Stop a TIR Instance to end plan billing, start it again, restart it for a fresh container, and open its app with Launch App."
content_type: "how-to"
product: "tir-instance"
platform: "TIR"
url: "/tir/tir-instance/how-to/stop-start-and-restart-an-instance/"
topic: ["power-and-lifecycle"]
---

# Stop, start, and restart an instance

Stop an hourly instance between work sessions, and its plan stops being billed while its
workspace waits for you. Start it again to carry on where you left off, or restart it to get a fresh
container in one step. While it runs, you open its app with **Launch App**.

## Before you begin

- An instance in a TIR project. See [Create an
  instance](/tir/tir-instance/how-to/create-an-instance/).
- Permission to update instances in the project. Every project role except **MEMBER** has it, and a
  **MEMBER** needs a policy that allows updates.

Every action is in the instance's actions menu, on its row in **Manage Instances** and on its
details page. The details page also has **Start** and **Stop** buttons next to the app button.

Whichever action you take, files in the workspace at `/home/jovyan` and data on mounted datasets and
file systems are kept. Packages you installed yourself are lost, so install them again afterwards.
For the full picture, see [Where your files
live](/tir/tir-instance/concepts/where-your-files-live/).

## How an instance moves between statuses

```mermaid
stateDiagram-v2
    state "Saving Image" as SavingImage
    [*] --> Waiting: Create
    Waiting --> Running: Container ready
    Running --> Stopping: Stop Instance
    Waiting --> Stopping: Stop Instance
    Stopping --> Stopped
    Stopped --> Waiting: Start Instance
    Running --> Waiting: Restart Instance
    Running --> SavingImage: Save Image
    SavingImage --> Running: Image saved
```

An instance's status says where it is:

| Status           | What it means                                                                                                    |
| ---------------- | ---------------------------------------------------------------------------------------------------------------- |
| **Waiting**      | The container is starting: TIR is finding a host, the host is downloading the image, or the image is starting up |
| **Running**      | The container is up, and you can open the app and connect over SSH                                               |
| **Stopping**     | A stop is in progress                                                                                            |
| **Stopped**      | The container is gone, and the workspace waits for the next start                                                |
| **Saving Image** | TIR is saving an image of the instance, and other actions wait until it finishes                                 |
| **Pending**      | The instance is waiting for capacity, which is rare                                                              |
| **Error**        | The container is gone, and only support can recover the instance                                                 |

**Stop Instance** moves a **Running** or **Waiting** instance to **Stopping** and then **Stopped**.
**Start Instance** takes a **Stopped** instance back through **Waiting** to **Running**. **Restart
Instance** sends a **Running** instance back to **Waiting** until its new container is ready. After
a save, the instance shows **Running** again on its own.

## Open the instance's app

**Launch App** opens the instance's app, JupyterLab, ComfyUI, or FramePack depending on the image,
in a new browser tab. You find it in the actions menu, at the top of the instance's page, and
under **App URL** in **Manage Instances**.

The app opens only while the instance is **Running**. An image with no app, such as a Base OS
image, has no **App URL**, so connect to that instance over SSH instead. See [Connect to an instance over
SSH](/tir/tir-instance/how-to/connect-to-an-instance-over-ssh/).

If your browser blocks the new tab, allow pop-ups for TIR and select **Launch App** again.

## Stop an instance

You can stop an hourly instance, or an instance on a private cluster, while it is **Running** or
**Waiting**. A committed instance runs for its whole term, and its plan is already paid for that term,
so its menu has no **Stop Instance**. See [Billing
options](/tir/tir-instance/concepts/billing-options/).

If your instance's plan includes local NVMe storage, shown as **Local NVMe Storage** under **Plan
Details** on the **Overview** tab, it is mounted at `/mnt/local`. Stopping the instance deletes
everything in it, and the stop dialog warns you about it. Copy anything you need into
`/home/jovyan` before you stop the instance. A private cluster's local volume is kept when you
stop.

1. In the instance's actions menu, select **Stop Instance**.
2. Tick the box that confirms you want to stop the instance, and select **Stop**.

The instance shows **Stopping**, then **Stopped**.

Plan billing stops once the instance stops. Workspace above 30 GB is still billed until
you delete the instance, and datasets, SFS, PFS, and reserved IPs are billed by their own products.
See [pricing](https://www.e2enetworks.com/pricing).

A Python virtual environment or conda environment that you create under `/home/jovyan` is kept with
the rest of the workspace. Activate it by its path, or from a start script, after each start.

The instance gives back its floating public IP and its egress IP, which is the address its outbound
traffic comes from. On start, it gets addresses from E2E's pool, which can be different ones. A
reserved IP keeps its address. See [Manage IP addresses on an
instance](/tir/tir-instance/how-to/manage-ip-addresses-on-an-instance/).

## Start an instance

**Start Instance** is available when the instance is **Stopped**. Select it, then confirm. Plan
billing starts again when it reaches **Running**, and its start scripts run each time it
starts.

TIR checks your credit and its capacity before it starts the instance:

- On a prepaid account, your balance must cover at least one hour of the instance's plan.
- When the plan is out of capacity, the start is refused with "Inventory temporarily
  unavailable. Please try again after some time." Try again later, or [change the plan of the
  instance](/tir/tir-instance/how-to/change-the-plan-of-an-instance/) to one that is in stock. A
  plan change on a stopped instance also starts it.

TIR checks a public image again at each start, and starts the instance only while the image is
still valid. For a custom or public image, TIR asks the registry for the image at each start and
downloads only what the host is missing. A large image can keep the instance on **Waiting**
for longer.

If the start is refused or the instance stays on **Waiting**, see [Troubleshooting TIR
Instances](/tir/tir-instance/troubleshooting/tir-instance/), which covers a Spot Instance that TIR
took back and what keeps an instance waiting.

## Restart an instance

A restart replaces the instance's container with a fresh one from its image. Use it to get a clean
container, free GPU memory held by leftover processes, or run your start scripts again after
you change one. **Restart Instance** is available while the instance is **Running** or **Waiting**, on
hourly and committed instances alike. To bring back a stopped instance, start it instead.

A restart ends every process in the instance at once, so save your work to `/home/jovyan` first.

1. In the instance's actions menu, select **Restart Instance**.
2. Confirm the restart. The dialog reminds you to install your own packages again afterwards.

Once the new container is ready, the instance is **Running** again. After the restart:

- Files in `/home/jovyan`, mounted datasets and file systems, and `/mnt/local` are kept.
- Everything else in the container returns to the image's contents, including packages you
  installed.
- The instance's start scripts run again.
- An hourly plan's billing pauses while the instance shows **Waiting** and starts again when it is
  **Running**. The workspace is billed throughout.

To keep packages across restarts, install them from a start script, save the instance as an image,
or use a custom image that has them. See [Run start scripts on an
instance](/tir/tir-instance/how-to/run-start-scripts-on-an-instance/) and [Save an instance as an
image](/tir/tir-instance/how-to/save-an-instance-as-an-image/).

## When an instance restarts on its own

TIR replaces the container, with the same result as a restart, when:

- The instance runs out of memory.
- The instance fills its ephemeral storage: the space outside `/home/jovyan` and its mounts, whose
  size the plan sets and whose contents are lost on restart.
- You change the mounts or the image of a running instance. A plan change, made on a stopped
  instance, starts it on a new container in the same way.

To find out why an instance restarted, look at **Instances Event** and **Logs** while it is running,
and at **Ephemeral Storage** and **RAM Utilization** on **Monitoring**. An alert on ephemeral
storage or memory use warns you before the instance runs out. See [Monitor an
instance](/tir/tir-instance/how-to/monitor-an-instance/) and [Troubleshooting TIR
Instances](/tir/tir-instance/troubleshooting/tir-instance/).

To give a stopped instance a different plan, see [Change the plan of an
instance](/tir/tir-instance/how-to/change-the-plan-of-an-instance/). When you are finished with the
instance, [delete it](/tir/tir-instance/how-to/delete-an-instance/) to stop billing for its
workspace too.

These actions are also available through the TIR API's [Start-Stop/Attach-Detach
ReserveIp](/api/tir/operations/put-notebooks-instance-id-actions/) operation.