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

# Quickstart

> Get started with Scoot API Gateway in minutes - from account setup to your first API call

## Get started in four steps

Get up and running with Scoot API Gateway quickly and make your first API integration.

<Note>
  Before you begin, make sure you have a Scoot account. If you don't have one yet, follow our [account creation guide](/creating-a-scoot-account) to get started.
</Note>

### Step 1: Set Up Your Scoot Account

If you haven't already created your Scoot account:

<Card title="Create Your Scoot Account" icon="user-plus" href="/creating-a-scoot-account" horizontal>
  Complete step-by-step account creation process
</Card>

Once your account is ready:

1. Log in to your [Scoot](https://us.scoot.app/)
2. With your API Token previous requested [Request the token](https://us.scoot.app/)

<Warning>
  Keep your API key secure and never expose it in client-side code or public repositories.
</Warning>

### Step 2: Understanding Authentication

Scoot API uses **API Key authentication** via the `X-API-Key` header. This is a simple and secure way to authenticate your requests.

#### Authentication Strategy

All API requests require your API key to be included in the request headers:

```bash theme={null}
X-API-Key: your-api-key-here
```

<AccordionGroup>
  <Accordion icon="shield-check" title="API Key Security Best Practices">
    * Store API keys in environment variables
    * Use different keys for development and production
    * Rotate keys regularly
    * Never commit keys to version control
    * Use server-side requests only
  </Accordion>

  <Accordion icon="code" title="Environment Setup">
    Create a `.env` file in your project:

    ```bash theme={null}
    SCOOT_API_KEY=your-api-key-here
    SCOOT_BASE_URL=https://api.scoot.app
    ```

    <Tip>Add `.env` to your `.gitignore` file to prevent accidental commits.</Tip>
  </Accordion>
</AccordionGroup>

### Step 3: Make Your First API Call

Let's start with a simple example using the transcription endpoints to understand how authentication works.

#### Example: Get Transcriptions

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET "https://api.scoot.app/api/v1/transcription" \
    -H "X-API-Key: your-api-key-here" \
    -H "Content-Type: application/json"
  ```

  ```javascript Node.js theme={null}
  const axios = require('axios');

  const config = {
    headers: {
      'X-API-Key': process.env.SCOOT_API_KEY,
      'Content-Type': 'application/json'
    }
  };

  async function getTranscriptions() {
    try {
      const response = await axios.get(
        'https://api.scoot.app/api/v1/transcription',
        config
      );
      console.log('Transcriptions:', response.data);
    } catch (error) {
      console.error('Error:', error.response?.data || error.message);
    }
  }

  getTranscriptions();
  ```

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

  headers = {
      'X-API-Key': os.getenv('SCOOT_API_KEY'),
      'Content-Type': 'application/json'
  }

  def get_transcriptions():
      try:
          response = requests.get(
              'https://api.scoot.app/api/v1/transcription',
              headers=headers
          )
          response.raise_for_status()
          print('Transcriptions:', response.json())
      except requests.exceptions.RequestException as e:
          print('Error:', e)

  get_transcriptions()
  ```

  ```php PHP theme={null}
  <?php
  $api_key = getenv('SCOOT_API_KEY');
  $url = 'https://api.scoot.app/api/v1/transcription';

  $headers = [
      'X-API-Key: ' . $api_key,
      'Content-Type: application/json'
  ];

  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

  $response = curl_exec($ch);
  $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  curl_close($ch);

  if ($http_code === 200) {
      $data = json_decode($response, true);
      echo 'Transcriptions: ' . print_r($data, true);
  } else {
      echo 'Error: HTTP ' . $http_code . ' - ' . $response;
  }
  ?>
  ```
</CodeGroup>

#### Example: Save a Transcription

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST "https://api.scoot.app/api/v1/transcription/save" \
    -H "X-API-Key: your-api-key-here" \
    -H "Content-Type: application/json" \
    -d '{
      "text": "This is a sample transcription text",
      "metadata": {
        "source": "meeting",
        "timestamp": "2025-10-03T10:00:00Z"
      }
    }'
  ```

  ```javascript Node.js theme={null}
  const axios = require('axios');

  const config = {
    headers: {
      'X-API-Key': process.env.SCOOT_API_KEY,
      'Content-Type': 'application/json'
    }
  };

  async function saveTranscription() {
    const data = {
      text: "This is a sample transcription text",
      metadata: {
        source: "meeting",
        timestamp: new Date().toISOString()
      }
    };

    try {
      const response = await axios.post(
        'https://api.scoot.app/api/v1/transcription/save',
        data,
        config
      );
      console.log('Saved transcription:', response.data);
    } catch (error) {
      console.error('Error:', error.response?.data || error.message);
    }
  }

  saveTranscription();
  ```

  ```python Python theme={null}
  import requests
  import os
  from datetime import datetime

  headers = {
      'X-API-Key': os.getenv('SCOOT_API_KEY'),
      'Content-Type': 'application/json'
  }

  def save_transcription():
      data = {
          'text': 'This is a sample transcription text',
          'metadata': {
              'source': 'meeting',
              'timestamp': datetime.utcnow().isoformat() + 'Z'
          }
      }
      
      try:
          response = requests.post(
              'https://api.scoot.app/api/v1/transcription/save',
              json=data,
              headers=headers
          )
          response.raise_for_status()
          print('Saved transcription:', response.json())
      except requests.exceptions.RequestException as e:
          print('Error:', e)

  save_transcription()
  ```
</CodeGroup>

### Step 4: Handle Responses and Errors

Understanding common response patterns will help you build robust integrations.

#### Response Status Codes

<AccordionGroup>
  <Accordion icon="check-circle" title="Success Responses">
    * **200 OK**: Request successful, data returned
    * **201 Created**: Resource created successfully
    * **204 No Content**: Request successful, no data returned
  </Accordion>

  <Accordion icon="exclamation-triangle" title="Client Errors">
    * **400 Bad Request**: Invalid request parameters
    * **401 Unauthorized**: Missing or invalid API key
    * **403 Forbidden**: API key lacks required permissions
    * **404 Not Found**: Resource not found
    * **429 Too Many Requests**: Rate limit exceeded
  </Accordion>

  <Accordion icon="times-circle" title="Server Errors">
    * **500 Internal Server Error**: Server-side error
    * **502 Bad Gateway**: Upstream service error
    * **503 Service Unavailable**: Service temporarily down
  </Accordion>
</AccordionGroup>

#### Error Handling Example

```javascript theme={null}
async function makeAPICall() {
  try {
    const response = await axios.get(url, config);
    return response.data;
  } catch (error) {
    if (error.response) {
      // Server responded with error status
      const status = error.response.status;
      const message = error.response.data?.error || 'Unknown error';
      
      switch (status) {
        case 401:
          console.error('Authentication failed. Check your API key.');
          break;
        case 429:
          console.error('Rate limit exceeded. Please retry after some time.');
          break;
        default:
          console.error(`API Error ${status}: ${message}`);
      }
    } else {
      // Network or other error
      console.error('Network error:', error.message);
    }
    throw error;
  }
}
```

## Next Steps

Now that you've made your first successful API call, explore more capabilities:

<CardGroup cols={2}>
  <Card title="API Reference" icon="book-open" href="/api-reference/introduction">
    Explore all available endpoints and their parameters
  </Card>

  <Card title="Transcription Endpoints" icon="microphone" href="/api-reference/transcription/get">
    Deep dive into transcription management features
  </Card>
</CardGroup>

## Support and Resources

* **Documentation**: Comprehensive API reference and guides
* **Status Page**: Check service status at [status.scoot.app](https://status.scoot.app)
* **Support**: Contact us at [support@scoot.app](mailto:support@scoot.app)
* **Community**: Join our developer community for tips and best practices

<Tip>
  Start with the transcription endpoints as they provide a great introduction to Scoot's data structure and authentication patterns.
</Tip>