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

# Quickstart

> Create a project, surface insights across your documents, and — if you need it — generate a document from a prompt. Five minutes end to end.

This guide walks you through: get an API key, run your first project
intelligence flow (upload files → read insights → export a report),
and optionally generate a standalone document from a prompt.

## 1. Get an API key

Pick whichever path fits your workflow — they produce the same `sk_live_*`
key.

<Tabs>
  <Tab title="From the dashboard (recommended)">
    1. Sign in to [app.overten.ai](https://app.overten.ai).
    2. Open **Settings → API keys**.
    3. Click **Create key**, pick **Personal** or a workspace, and copy the
       secret shown once.
    4. Export it so the rest of this guide can use it:

    ```bash theme={null}
    export OVERTEN_API_KEY="sk_live_..."
    ```

    That's it — jump to step 2.
  </Tab>

  <Tab title="From code (headless signup)">
    For CI test harnesses or fully scripted onboarding. You'll exchange a
    Firebase ID token for an `sk_live_*` key via the API.

    First, get a Firebase ID token with the Firebase web SDK (or a Google
    sign-in flow — the token is the same):

    ```javascript theme={null}
    import { initializeApp } from "firebase/app";
    import { getAuth, signInWithEmailAndPassword } from "firebase/auth";

    const app = initializeApp({ /* your Firebase config */ });
    const auth = getAuth(app);
    const { user } = await signInWithEmailAndPassword(auth, email, password);
    const firebaseToken = await user.getIdToken();
    ```

    Then call `/signup` to bootstrap an org and mint your first key:

    <CodeGroup>
      ```bash curl theme={null}
      curl -X POST "https://backend.overtenai.com/api/v1/signup" \
        -H "Authorization: Bearer $FIREBASE_TOKEN" \
        -H "Content-Type: application/json" \
        -d '{
          "org_name": "Acme Docs",
          "tier": "free",
          "key_name": "primary"
        }'
      ```

      ```python Python theme={null}
      import os, requests

      resp = requests.post(
          "https://backend.overtenai.com/api/v1/signup",
          headers={"Authorization": f"Bearer {os.environ['FIREBASE_TOKEN']}"},
          json={
              "org_name": "Acme Docs",
              "tier": "free",
              "key_name": "primary",
          },
      )
      print(resp.json())
      ```

      ```javascript Node theme={null}
      const resp = await fetch("https://backend.overtenai.com/api/v1/signup", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.FIREBASE_TOKEN}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          org_name: "Acme Docs",
          tier: "free",
          key_name: "primary",
        }),
      });
      console.log(await resp.json());
      ```
    </CodeGroup>

    Response:

    ```json theme={null}
    {
      "key_id": "key_abc123...",
      "org_id": "org_xyz456...",
      "org_name": "Acme Docs",
      "name": "primary",
      "prefix": "sk_live_4aT7",
      "secret": "sk_live_4aT7bX9cD2eF8gH3iJ5kL6mN1pQ",
      "webhook_secret": "whsec_...",
      "created_at": "2026-04-17T11:20:00Z",
      "docs_url": "https://apidocs.overtenai.com/api"
    }
    ```

    <Warning>
      The `secret` field is shown **only once**. Copy it immediately and
      store it in a secret manager. If you lose it, revoke it and mint a
      new one via `POST /organizations/{org_id}/api-keys`.
    </Warning>

    Export it:

    ```bash theme={null}
    export OVERTEN_API_KEY="sk_live_4aT7bX9cD2eF8gH3iJ5kL6mN1pQ"
    ```
  </Tab>
</Tabs>

## 2. Run a project intelligence flow

This is the primary surface — upload related files, let the pipeline
cross-reference them, read the resulting alerts and insights.

<CodeGroup>
  ```python Python theme={null}
  import os, requests, time

  API = "https://backend.overtenai.com/api/v1"
  H = {"X-API-Key": os.environ["OVERTEN_API_KEY"]}

  # 1. Create a project
  project = requests.post(
      f"{API}/projects",
      headers=H,
      json={"name": "Acme Q3 Due Diligence", "tags": ["dd", "q3"]},
  ).json()
  pid = project["project_id"]

  # 2. Attach files (analysis kicks off automatically)
  for path in ["financials.xlsx", "report.pdf", "contract.docx"]:
      with open(path, "rb") as f:
          requests.post(
              f"{API}/projects/{pid}/files",
              headers=H,
              files={"file": f},
              data={"role": "primary"},
          ).raise_for_status()

  # 3. Poll status
  while True:
      s = requests.get(f"{API}/projects/{pid}/analysis/status", headers=H).json()
      print(f"phase={s['pipeline']['phase']} progress={s['progress']}%")
      if s["pipeline"]["status"] == "completed":
          break
      time.sleep(10)

  # 4. Read the alerts / insights feed
  insights = requests.get(
      f"{API}/projects/{pid}/insights",
      headers=H,
      params={"severity": "critical,high", "limit": 50},
  ).json()
  for item in insights["items"]:
      print("-", item["alert"]["description"])

  # 5. Export a branded .docx report
  report = requests.post(
      f"{API}/projects/{pid}/reports",
      headers=H,
      json={"title": "Acme Due Diligence — Key Findings"},
  ).json()
  with open("insights_report.docx", "wb") as f:
      f.write(requests.get(report["download_url"]).content)
  print("Saved insights_report.docx")
  ```

  ```bash curl theme={null}
  # 1. Create a project
  PID=$(curl -sS -X POST "$API/projects" \
    -H "X-API-Key: $OVERTEN_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"name":"Acme Q3 Due Diligence"}' | jq -r .project_id)

  # 2. Attach a file (repeat per file)
  curl -sS -X POST "$API/projects/$PID/files" \
    -H "X-API-Key: $OVERTEN_API_KEY" \
    -F "file=@financials.xlsx" -F "role=primary"

  # 3. Poll status
  curl -sS "$API/projects/$PID/analysis/status" \
    -H "X-API-Key: $OVERTEN_API_KEY" | jq '.pipeline, .progress'

  # 4. Read insights
  curl -sS "$API/projects/$PID/insights?severity=critical,high" \
    -H "X-API-Key: $OVERTEN_API_KEY" | jq '.items[].alert.description'

  # 5. Export report
  URL=$(curl -sS -X POST "$API/projects/$PID/reports" \
    -H "X-API-Key: $OVERTEN_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"title":"Acme Due Diligence — Key Findings"}' | jq -r .download_url)
  curl -sS "$URL" -o insights_report.docx
  ```
</CodeGroup>

Open `insights_report.docx` — you'll see a cover page with a summary
strip, then one section per severity with each finding laid out as a
titled card with description, source, and recommendations. Same
structure every run (it's a deterministic template, not an LLM write).

See the full surface in the [Project Intelligence guide](/guides/projects).

## 3. Generate a standalone document

If you don't need the cross-document analysis — you just want to
produce a spreadsheet, report, or deck from a prompt — hit the format
endpoints directly. No project required.

<CodeGroup>
  ```python Python theme={null}
  resp = requests.post(
      f"{API}/excel/generate",
      headers=H,
      json={"prompt": "Create a sales report with summary statistics"},
  )
  resp.raise_for_status()
  result = resp.json()
  print(f"run_id={result['run_id']} credits_used={result['credits_used']}")

  with open("sales_report.xlsx", "wb") as f:
      f.write(requests.get(result["download_url"]).content)
  ```

  ```bash curl theme={null}
  RUN=$(curl -sS -X POST "$API/excel/generate" \
    -H "X-API-Key: $OVERTEN_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"prompt":"Create a sales report with summary statistics"}')
  URL=$(echo "$RUN" | jq -r .download_url)
  curl -sS "$URL" -o sales_report.xlsx
  ```

  ```javascript Node theme={null}
  const resp = await fetch(`${API}/excel/generate`, {
    method: "POST",
    headers: { ...H, "Content-Type": "application/json" },
    body: JSON.stringify({ prompt: "Create a sales report with summary statistics" }),
  });
  const result = await resp.json();
  const file = await fetch(result.download_url);
  await Bun.write("sales_report.xlsx", await file.arrayBuffer());
  ```
</CodeGroup>

The same shape works for `/word/generate` and `/slides/generate`. See
the [format guides](/guides/excel) for what each agent can produce.

## 4. Iterate on the same document

Pass the `run_id` back to **resume** — the agent already knows the
document structure, so the next turn is much cheaper:

```python theme={null}
resp2 = requests.post(
    f"{API}/excel/generate",
    headers=H,
    json={
        "run_id": result["run_id"],
        "prompt": "Now add a chart comparing regions over the last 4 quarters",
    },
)
```

Resume works across all generation endpoints. See
[Runs and tasks](/concepts/runs-and-tasks) for the full resume semantics.

## 5. Skip polling with a webhook

If you don't want to block on the sync response, submit asynchronously
and let us POST the result to you when ready:

```python theme={null}
resp = requests.post(
    f"{API}/excel/generate",
    headers=H,
    json={
        "prompt": "Create a Q3 sales report",
        "async": True,
        "webhook_url": "https://myapp.example.com/webhooks/overten",
    },
)
# → {"run_id": "run_...", "task_id": "task_...", "status": "queued"}
```

Payload shape and signature verification:
[Webhooks](/concepts/webhooks).

***

## What's next

<CardGroup cols={2}>
  <Card title="Project intelligence" icon="magnifying-glass-chart" href="/guides/projects">
    Full surface for cross-document analysis, insights, and reports.
  </Card>

  <Card title="Format guides" icon="files" href="/guides/excel">
    Real-world examples for Word, Excel, and Slides generation.
  </Card>

  <Card title="Conversions" icon="file-export" href="/guides/conversions">
    Turn any .docx/.xlsx/.pptx into .pdf, .html, .txt, and more.
  </Card>

  <Card title="API reference" icon="rectangle-list" href="/api-reference">
    Try every endpoint from the browser.
  </Card>
</CardGroup>