> ## Documentation Index
> Fetch the complete documentation index at: https://docs.elding.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Go from zero to protected API keys in 60 seconds, without a .env file.

## Four commands

<Steps>
  <Step title="Install the CLI">
    ```bash theme={null}
    npm install -g @elding/cli
    ```
  </Step>

  <Step title="Sign in">
    ```bash theme={null}
    elding login
    ```

    Your browser opens for authorization. The token is then stored locally with `chmod 600`.
  </Step>

  <Step title="Create a set and add your keys">
    In the [dashboard](https://elding.app), create a set such as `dev` and add your keys.
    Then link your project:

    ```bash theme={null}
    elding init
    ```
  </Step>

  <Step title="Run your application behind the proxy">
    Prefix your usual command with `elding proxy --`:

    ```bash theme={null}
    elding proxy -- node app.js
    ```

    <Check>
      Your API keys are loaded **inside the proxy**, never into your application's memory.
    </Check>
  </Step>
</Steps>

## Add it to `npm run dev`

To make protection automatic, add `elding proxy --` to the `dev` script in `package.json`:

```json package.json theme={null}
{
  "scripts": {
    "dev": "elding proxy -- next dev"
  }
}
```

Now start your application as usual. The key is protected transparently:

```bash theme={null}
npm run dev
```

<Note>
  This works with any command: `next dev`, `vite`, `node server.js`, `nodemon`, and more.
  Your workflow stays the same; Elding runs on top of it.
</Note>

## The key moment

Your code only needs one line. `configure()` handles everything:

```js app.js theme={null}
import OpenAI from "openai";
import { configure } from "@elding/sdk";

const openai = new OpenAI(
  await configure("OPENAI_API_KEY", "https://api.openai.com")
);
// the real key never enters your application
```

Now try logging the key:

```js theme={null}
console.log(process.env.OPENAI_API_KEY); // → undefined or {{OPENAI_API_KEY}}
```

<Note>
  The OpenAI request **still works**: the proxy injects the real key at the last moment and
  locks it to `api.openai.com`. Your application, AI agent, and dependencies only see a
  placeholder. **The real key does not exist anywhere in your process.**
</Note>

## Deploy to production

Development works. Now ship it. Run once, locally:

```bash theme={null}
elding deploy
```

The CLI asks for a key name, creates it, and prints two variables:

```
  ELDING_REFRESH_TOKEN=eld_rt_...
  ELDING_SET_ID=...
```

Add them to your host (Vercel → Settings → Environment Variables, Railway, Render, etc.). Your code stays identical — the SDK switches automatically from the local proxy to the vault.

<Warning>
  Copy the token immediately. It is shown only once.
  Do not run `elding deploy` in a CI pipeline with public logs.
</Warning>

<Card title="All deployment options" icon="rocket" href="/en/sdk/deploy">
  CLI method, dashboard method, revocation.
</Card>

## What's next?

<CardGroup cols={1}>
  <Card title="Understand the proxy" icon="shield" href="/en/concepts/proxy">
    Learn how injection and host locking work.
  </Card>
</CardGroup>