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

# Quickstart

> Make your first Tiro API call in under 5 minutes.

export const TwoDoors = ({restHref, restTitle, restDescription, mcpHref, mcpTitle, mcpDescription}) => <div className="tiro-two-doors">
    <a className="tiro-two-doors__door" href={restHref}>
      <span className="tiro-two-doors__label">REST API</span>
      <h3 className="tiro-two-doors__title">{restTitle}</h3>
      <p className="tiro-two-doors__desc">{restDescription}</p>
    </a>
    <a className="tiro-two-doors__door" href={mcpHref}>
      <span className="tiro-two-doors__label">MCP Server</span>
      <h3 className="tiro-two-doors__title">{mcpTitle}</h3>
      <p className="tiro-two-doors__desc">{mcpDescription}</p>
    </a>
  </div>;

Tiro gives you two ways to connect: the REST API for programmatic access from your backend, or the MCP Server for AI clients like Claude and ChatGPT.

<TwoDoors restHref="/en/developers/fundamentals/api-overview" restTitle="REST API" restDescription="Full programmatic access — notes, transcripts, summaries, webhooks." mcpHref="/en/developers/mcp/mcp-overview" mcpTitle="MCP Server" mcpDescription="Connect Claude, ChatGPT, Cursor, and other AI clients in minutes." />

## Get your API key

Go to the [Tiro Platform API Keys page](https://platform.tiro.ooo/dashboard/api-keys) and create a key.

<Steps>
  <Step title="Sign in">
    Go to [platform.tiro.ooo/dashboard/api-keys](https://platform.tiro.ooo/dashboard/api-keys).
  </Step>

  <Step title="Pick a workspace">
    Use the workspace switcher in the sidebar to choose the workspace your key should reach. The key is scoped to that workspace.
  </Step>

  <Step title="Create a key">
    Click **Create New API Key**. Copy the **full key** including the dot — `abc123.xR7mK9pL2qW4...`.
  </Step>

  <Step title="Store it">
    Save it as an environment variable. You can't view it again after closing the creation dialog.
  </Step>
</Steps>

<Warning>
  Store your API key in an environment variable. Never hardcode it or commit it.
</Warning>

<Note>
  Using a personal API key from before workspaces? Those keys are deprecated and stop working on **June 30, 2026**. [Migrate to a workspace key](/en/developers/fundamentals/authentication#legacy-personal-keys-deprecated).
</Note>

## Make your first request

Fetch your notes:

<CodeGroup>
  ```bash cURL theme={"system"}
  curl -H "Authorization: Bearer $TIRO_API_KEY" \
       -H "Content-Type: application/json" \
       https://api.tiro.ooo/v1/external/notes
  ```

  ```javascript Node.js theme={"system"}
  const response = await fetch("https://api.tiro.ooo/v1/external/notes", {
    headers: {
      "Authorization": `Bearer ${process.env.TIRO_API_KEY}`,
      "Content-Type": "application/json",
    },
  });

  const data = await response.json();
  console.log(`Found ${data.content.length} notes`);
  ```

  ```python Python theme={"system"}
  import os
  import requests

  headers = {
      'Authorization': f'Bearer {os.getenv("TIRO_API_KEY")}',
      'Content-Type': 'application/json'
  }

  response = requests.get('https://api.tiro.ooo/v1/external/notes', headers=headers)
  data = response.json()
  print(f"Found {len(data['content'])} notes")
  ```

  ```go Go theme={"system"}
  package main

  import (
      "encoding/json"
      "fmt"
      "net/http"
      "os"
  )

  func main() {
      client := &http.Client{}
      req, _ := http.NewRequest("GET", "https://api.tiro.ooo/v1/external/notes", nil)
      
      apiKey := os.Getenv("TIRO_API_KEY")
      req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))
      req.Header.Set("Content-Type", "application/json")
      
      resp, _ := client.Do(req)
      defer resp.Body.Close()
      
      var data map[string]interface{}
      json.NewDecoder(resp.Body).Decode(&data)
      fmt.Printf("Found %v notes\n", len(data["content"].([]interface{})))
  }
  ```

  ```kotlin Kotlin + Spring theme={"system"}
  @RestController
  class NotesController {
      
      @Value("\${tiro.api.key}")
      private lateinit var apiKey: String
      
      private val restTemplate = RestTemplate()
      
      @GetMapping("/my-notes")
      fun getMyNotes(): ResponseEntity<Map<String, Any>> {
          val headers = HttpHeaders()
          headers.set("Authorization", "Bearer $apiKey")
          headers.contentType = MediaType.APPLICATION_JSON
          
          val entity = HttpEntity<String>(headers)
          
          val response = restTemplate.exchange(
              "https://api.tiro.ooo/v1/external/notes",
              HttpMethod.GET,
              entity,
              object : ParameterizedTypeReference<Map<String, Any>>() {}
          )
          
          val data = response.body!!
          println("Found ${(data["content"] as List<*>).size} notes")
          
          return ResponseEntity.ok(data)
      }
  }
  ```
</CodeGroup>

Tiro returns a paginated list of your notes. Each object contains the title, creation date, processing status, and a `guid` you use to fetch transcripts, summaries, and documents.

Now that you have a list, read the [Note Data Model](/en/developers/fundamentals/note-data-model) to understand what each `guid` unlocks — transcripts, summaries, documents, and folders.