Quickstart - Scoot Gateway

Get started in four steps

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

Before you begin, make sure you have a Scoot account. If you don’t have one yet, follow our account creation guide to get started.

Step 1: Set Up Your Scoot Account

If you haven’t already created your Scoot account:

Create Your Scoot Account

Complete step-by-step account creation process

Once your account is ready:

Log in to your Scoot
With your API Token previous requested Request the token

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

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:

X-API-Key: your-api-key-here

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

Environment Setup

Create a .env file in your project:

SCOOT_API_KEY=your-api-key-here
SCOOT_BASE_URL=https://api.scoot.app

Add .env to your .gitignore file to prevent accidental commits.

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

curl -X GET "https://api.scoot.app/api/v1/transcription" \
  -H "X-API-Key: your-api-key-here" \
  -H "Content-Type: application/json"

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();

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
$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;
}
?>

Example: Save a Transcription

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"
    }
  }'

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();

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()

Step 4: Handle Responses and Errors

Understanding common response patterns will help you build robust integrations.

Response Status Codes

Success Responses

200 OK: Request successful, data returned
201 Created: Resource created successfully
204 No Content: Request successful, no data returned

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

Server Errors

500 Internal Server Error: Server-side error
502 Bad Gateway: Upstream service error
503 Service Unavailable: Service temporarily down

Error Handling Example

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:

API Reference

Explore all available endpoints and their parameters

Transcription Endpoints

Deep dive into transcription management features

Support and Resources

Documentation: Comprehensive API reference and guides
Status Page: Check service status at status.scoot.app
Support: Contact us at support@scoot.app
Community: Join our developer community for tips and best practices

Start with the transcription endpoints as they provide a great introduction to Scoot’s data structure and authentication patterns.

​Get started in four steps

​Step 1: Set Up Your Scoot Account

Create Your Scoot Account

​Step 2: Understanding Authentication

​Authentication Strategy

​Step 3: Make Your First API Call

​Example: Get Transcriptions

​Example: Save a Transcription

​Step 4: Handle Responses and Errors

​Response Status Codes

​Error Handling Example

​Next Steps

API Reference

Transcription Endpoints

​Support and Resources

Get started in four steps

Step 1: Set Up Your Scoot Account

Step 2: Understanding Authentication

Authentication Strategy

Step 3: Make Your First API Call

Example: Get Transcriptions

Example: Save a Transcription

Step 4: Handle Responses and Errors

Response Status Codes

Error Handling Example

Next Steps

Support and Resources