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

# Quickstart

> Get an API key, install an SDK or the CLI, and execute your first tool.

Every step below shows the **same action on each surface** - pick one tab and stay in it end to end:

* **Python / TypeScript** - the [SDKs](/developers/sdk), for when Engini is called from your code
* **CLI** - the [`engini` terminal tool](/developers/cli) (npm), for shells, scripts, and CI
* **cURL** - the raw [REST API](/developers/api-reference), for any other language

All four hit the same API with the same key, so you can switch lanes later without redoing anything.

## 1. Get an API key

Create a Developer API key on your [Engini account's keys page](https://app.engini.io/users). Keys are prefixed `eng_` and are sent in the `x-api-key` header - the key is bound to your account server-side, so it's the only credential you need.

<Warning>Never commit API keys. Export them as environment variables: `ENGINI_API_KEY`.</Warning>

## 2. Install

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

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

  ```bash CLI theme={null}
  npm install -g @engini/cli
  ```
</CodeGroup>

## 3. Verify your key

<CodeGroup>
  ```python Python theme={null}
  from engini import Engini

  client = Engini()  # reads ENGINI_API_KEY
  print(client.auth.whoami())
  ```

  ```typescript TypeScript theme={null}
  import { Engini } from "@engini/sdk";

  const client = new Engini(); // reads ENGINI_API_KEY
  console.log(await client.auth.whoami());
  ```

  ```bash CLI theme={null}
  engini login --api-key $ENGINI_API_KEY
  engini whoami
  ```

  ```bash cURL theme={null}
  curl https://api.engini.io/v1/auth/whoami \
    -H "x-api-key: $ENGINI_API_KEY"
  ```
</CodeGroup>

## 4. Discover applications and tools

<CodeGroup>
  ```python Python theme={null}
  apps = client.applications.list(available=True)
  tools = client.tools.get(applications=["monday"], limit=5)
  ```

  ```typescript TypeScript theme={null}
  const apps = await client.applications.list({ available: true });
  const tools = await client.tools.get({ applications: ["monday"], limit: 5 });
  ```

  ```bash CLI theme={null}
  engini applications list --available
  engini tools list --application monday --limit 5
  ```

  ```bash cURL theme={null}
  curl "https://api.engini.io/v1/tools?applicationSlug=monday&top=5" \
    -H "x-api-key: $ENGINI_API_KEY"
  ```
</CodeGroup>

## 5. Connect an application

Tools execute *through* a connection - your authenticated link to the application (an OAuth grant, an API key you paste, DB credentials). You create it **once**; every surface can use it afterwards.

<Note>
  This is the one step where we recommend the CLI **whatever lane you're in**: `engini connect` is a guided flow that handles credentials, OAuth, and object selection in one go. A connection created here is immediately usable from the SDKs and the REST API - it lives in your account, not in the CLI.
</Note>

<CodeGroup>
  ```python Python theme={null}
  # programmatic creation - direct credentials:
  conn = client.connections.create("monday", "My Monday", auth_id, {"ApiKey": "..."})
  # OAuth apps need the sign-in flow - see /sdk/connections
  ```

  ```typescript TypeScript theme={null}
  // programmatic creation - direct credentials:
  const conn = await client.connections.create("monday", "My Monday", authId, { ApiKey: "..." });
  // OAuth apps need the sign-in flow - see /sdk/connections
  ```

  ```bash CLI theme={null}
  engini connect monday
  # ... walks you through auth, verifies the connection,
  # and prints its connection_id - you'll use it in step 6
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.engini.io/v1/connections" \
    -H "x-api-key: $ENGINI_API_KEY" -H "Content-Type: application/json" \
    -d '{"applicationSlug":"monday","connectionName":"My Monday","authenticationId":0,"fields":{"ApiKey":"..."}}'
  # OAuth apps need the sign-in flow - see /examples/oauth-onboarding
  ```
</CodeGroup>

## 6. Execute a tool

<CodeGroup>
  ```python Python theme={null}
  result = client.tools.execute(
      "monday_create_item",
      {"name": "My first item"},
      connection_id=connection_id,   # omit to use your default connection
  )
  if result.is_success:
      print(result.output)
  ```

  ```typescript TypeScript theme={null}
  const result = await client.tools.execute(
    "monday_create_item",
    { name: "My first item" },
    { connectionId },   // omit to use your default connection
  );
  if (result.isSuccess) console.log(result.output);
  ```

  ```bash CLI theme={null}
  # --connection takes the connection_id printed by `engini connect` in step 5
  engini tools call monday_create_item --args '{"name":"My first item"}' --connection 3
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.engini.io/v1/tools/monday_create_item/execute" \
    -H "x-api-key: $ENGINI_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"fields": {"name": "My first item"}}'
  ```
</CodeGroup>

<Note>
  A `200` response does not mean the tool succeeded - always check `isSuccess`. Tool-runtime failures (e.g. the downstream API rejected the call) return `200` with `isSuccess: false` and an `errorMessage`; every other failure uses the standard [error envelope](/developers/get-started/pagination-errors-rate-limits).
</Note>

## Next steps

<CardGroup cols={2}>
  <Card title="Connections & OAuth" href="/developers/sdk/connections-oauth">Create connections programmatically, run the OAuth flow, select objects.</Card>
  <Card title="Give tools to an LLM" href="/developers/sdk/llm-providers">Toolsets + OpenAI/Anthropic providers - the agent loop.</Card>
  <Card title="CLI machine contract" href="/developers/cli/machine-contract">Exit codes, JSON output, `--schema`, result handles.</Card>
  <Card title="For AI Agents" href="/developers/ai-agents">How agents should discover and operate Engini.</Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.