> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/daytonaio/daytona/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Create your first Daytona sandbox in under 5 minutes

Get started with Daytona by creating and running your first sandbox. This guide will walk you through the complete process from setup to execution.

## Prerequisites

Before you begin, make sure you have:

* A Daytona account ([sign up here](https://app.daytona.io))
* An API key ([create one](https://app.daytona.io/dashboard/keys))
* Python, Node.js, Go, or Ruby installed

## Create your first sandbox

<Steps>
  <Step title="Install the SDK">
    Choose your preferred language and install the Daytona SDK:

    <CodeGroup>
      ```bash pip theme={null}
      pip install daytona
      ```

      ```bash npm theme={null}
      npm install @daytonaio/sdk
      ```

      ```bash yarn theme={null}
      yarn add @daytonaio/sdk
      ```

      ```bash go theme={null}
      go get github.com/daytonaio/daytona/libs/sdk-go
      ```

      ```bash gem theme={null}
      gem install daytona
      ```
    </CodeGroup>
  </Step>

  <Step title="Set your API key">
    Set your API key as an environment variable:

    <CodeGroup>
      ```bash bash theme={null}
      export DAYTONA_API_KEY="your-api-key-here"
      ```

      ```powershell powershell theme={null}
      $env:DAYTONA_API_KEY="your-api-key-here"
      ```
    </CodeGroup>

    <Tip>
      You can also pass the API key directly in your code. See the [authentication guide](/authentication) for more options.
    </Tip>
  </Step>

  <Step title="Create and run a sandbox">
    Create a simple program that creates a sandbox and runs code inside it:

    <Tabs>
      <Tab title="Python">
        ```python theme={null}
        from daytona import Daytona

        # Initialize the Daytona client
        daytona = Daytona()

        # Create the sandbox
        sandbox = daytona.create()

        # Run code securely inside the sandbox
        response = sandbox.process.code_run('print("Sum of 3 and 4 is", 3 + 4)')
        print(response.result)

        # Clean up
        daytona.delete(sandbox)
        ```
      </Tab>

      <Tab title="TypeScript">
        ```typescript theme={null}
        import { Daytona } from '@daytonaio/sdk'

        async function main() {
          // Initialize the Daytona client
          const daytona = new Daytona()

          let sandbox
          try {
            // Create the sandbox
            sandbox = await daytona.create()

            // Run code securely inside the sandbox
            const response = await sandbox.process.codeRun(
              'console.log("Sum of 3 and 4 is", 3 + 4)'
            )
            console.log(response.result)
          } finally {
            if (sandbox) await daytona.delete(sandbox)
          }
        }

        main().catch(console.error)
        ```
      </Tab>

      <Tab title="Go">
        ```go theme={null}
        package main

        import (
          "context"
          "fmt"
          "log"

          "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
          "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
        )

        func main() {
          // Initialize the Daytona client
          client, err := daytona.NewClient()
          if err != nil {
            log.Fatal(err)
          }

          ctx := context.Background()

          // Create the sandbox
          params := types.SnapshotParams{
            SandboxBaseParams: types.SandboxBaseParams{
              Language: types.CodeLanguagePython,
            },
          }

          sandbox, _, err := client.Create(ctx, params)
          if err != nil {
            log.Fatal(err)
          }
          defer sandbox.Delete(ctx)

          // Run code securely inside the sandbox
          response, err := sandbox.Process.ExecuteCommand(
            ctx,
            `python3 -c "print('Sum of 3 and 4 is', 3 + 4)"`,
          )
          if err != nil {
            log.Fatal(err)
          }

          fmt.Println(response.Result)
        }
        ```
      </Tab>

      <Tab title="Ruby">
        ```ruby theme={null}
        require 'daytona'

        # Initialize the Daytona client
        daytona = Daytona::Client.new

        begin
          # Create the sandbox
          sandbox = daytona.create

          # Run code securely inside the sandbox
          response = sandbox.process.code_run('puts "Sum of 3 and 4 is #{3 + 4}"')
          puts response.result
        ensure
          # Clean up
          daytona.delete(sandbox) if sandbox
        end
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Run your program">
    Execute your program and you'll see the output:

    ```
    Sum of 3 and 4 is 7
    ```

    <Check>
      **Congratulations!** You've successfully created your first Daytona sandbox and executed code inside it.
    </Check>
  </Step>
</Steps>

## What just happened?

Let's break down what your program did:

1. **Initialized the client** - Connected to the Daytona API using your API key
2. **Created a sandbox** - Launched an isolated execution environment in under 90ms
3. **Executed code** - Ran Python code safely inside the sandbox
4. **Retrieved output** - Got the results back to your application
5. **Cleaned up** - Deleted the sandbox to free up resources

## Next steps

<CardGroup cols={2}>
  <Card title="Explore file operations" icon="folder" href="/features/filesystem-operations">
    Upload, download, and manage files in your sandbox
  </Card>

  <Card title="Git operations" icon="git" href="/features/git-operations">
    Clone repositories and manage Git workflows
  </Card>

  <Card title="Process management" icon="terminal" href="/features/process-execution">
    Execute commands and manage processes
  </Card>

  <Card title="Language Server Protocol" icon="code" href="/features/language-server-protocol">
    Add code intelligence with LSP support
  </Card>
</CardGroup>