# POST /v1/bookings
Source: https://docs.skaala.ai/api-reference/bookings/create-bookings

POST /v1/bookings
POST /v1/bookings

# POST /v1/bookings

## Request Body

<ParamField type="CreateBooking">
  Request body following the [`CreateBooking`](#components/schemas/CreateBooking) schema
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://www.skaala.ai/api/v1/bookings \
    -H "X-API-Key: sk_live_your_key_here" \
    -H "Content-Type: application/json" \
    -d '{
      // Your request body here
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/bookings', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      // Your request body here
    })
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.post(
      'https://www.skaala.ai/api/v1/bookings',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']},
      json={
          # Your request body here
      }
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# POST /v1/bookings/{id}/cancel
Source: https://docs.skaala.ai/api-reference/bookings/create-bookings-by-id-cancel

POST /v1/bookings/{id}/cancel
Transform booking to API response format (snake_case)

# POST /v1/bookings//cancel

Transform booking to API response format (snake\_case)

## Path Parameters

<ParamField type="string">
  id
</ParamField>

## Request Body

<ParamField type="CreateBooking">
  Request body following the [`CreateBooking`](#components/schemas/CreateBooking) schema
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://www.skaala.ai/api/v1/bookings/abc123/cancel \
    -H "X-API-Key: sk_live_your_key_here" \
    -H "Content-Type: application/json" \
    -d '{
      // Your request body here
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/bookings/abc123/cancel', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      // Your request body here
    })
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.post(
      'https://www.skaala.ai/api/v1/bookings/abc123/cancel',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']},
      json={
          # Your request body here
      }
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/bookings/{id}
Source: https://docs.skaala.ai/api-reference/bookings/get-bookings-by-id

GET /v1/bookings/{id}
Transform booking to API response format (snake_case)

# GET /v1/bookings/

Transform booking to API response format (snake\_case)

## Path Parameters

<ParamField type="string">
  id
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/bookings/abc123 \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/bookings/abc123', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/bookings/abc123',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/bookings
Source: https://docs.skaala.ai/api-reference/bookings/list-bookings

GET /v1/bookings
GET /v1/bookings

# GET /v1/bookings

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/bookings \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/bookings', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/bookings',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# PUT /v1/bookings/{id}
Source: https://docs.skaala.ai/api-reference/bookings/update-bookings-by-id

PUT /v1/bookings/{id}
Transform booking to API response format (snake_case)

# PUT /v1/bookings/

Transform booking to API response format (snake\_case)

## Path Parameters

<ParamField type="string">
  id
</ParamField>

## Request Body

<ParamField type="CreateBooking">
  Request body following the [`CreateBooking`](#components/schemas/CreateBooking) schema
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X PUT https://www.skaala.ai/api/v1/bookings/abc123 \
    -H "X-API-Key: sk_live_your_key_here" \
    -H "Content-Type: application/json" \
    -d '{
      // Your request body here
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/bookings/abc123', {
    method: 'PUT',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      // Your request body here
    })
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.put(
      'https://www.skaala.ai/api/v1/bookings/abc123',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']},
      json={
          # Your request body here
      }
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/calls/{id}
Source: https://docs.skaala.ai/api-reference/calls/get-calls-by-id

GET /v1/calls/{id}
Transform call to detailed API response format (snake_case)

# GET /v1/calls/

Transform call to detailed API response format (snake\_case)

## Path Parameters

<ParamField type="string">
  id
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/calls/abc123 \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/calls/abc123', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/calls/abc123',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/calls
Source: https://docs.skaala.ai/api-reference/calls/list-calls

GET /v1/calls
Transform call to API response format (snake_case)

# GET /v1/calls

Transform call to API response format (snake\_case)

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/calls \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/calls', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/calls',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# POST /v1/contacts
Source: https://docs.skaala.ai/api-reference/contacts/create-contacts

POST /v1/contacts
Transform contact to API response format (snake_case)

# POST /v1/contacts

Transform contact to API response format (snake\_case)

## Request Body

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://www.skaala.ai/api/v1/contacts \
    -H "X-API-Key: sk_live_your_key_here" \
    -H "Content-Type: application/json" \
    -d '{
      // Your request body here
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/contacts', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      // Your request body here
    })
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.post(
      'https://www.skaala.ai/api/v1/contacts',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']},
      json={
          # Your request body here
      }
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/contacts/{id}
Source: https://docs.skaala.ai/api-reference/contacts/get-contacts-by-id

GET /v1/contacts/{id}
Transform contact to API response format (snake_case)

# GET /v1/contacts/

Transform contact to API response format (snake\_case)

## Path Parameters

<ParamField type="string">
  id
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/contacts/abc123 \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/contacts/abc123', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/contacts/abc123',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/contacts
Source: https://docs.skaala.ai/api-reference/contacts/list-contacts

GET /v1/contacts
Transform contact to API response format (snake_case)

# GET /v1/contacts

Transform contact to API response format (snake\_case)

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/contacts \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/contacts', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/contacts',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# PUT /v1/contacts/{id}
Source: https://docs.skaala.ai/api-reference/contacts/update-contacts-by-id

PUT /v1/contacts/{id}
Transform contact to API response format (snake_case)

# PUT /v1/contacts/

Transform contact to API response format (snake\_case)

## Path Parameters

<ParamField type="string">
  id
</ParamField>

## Request Body

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X PUT https://www.skaala.ai/api/v1/contacts/abc123 \
    -H "X-API-Key: sk_live_your_key_here" \
    -H "Content-Type: application/json" \
    -d '{
      // Your request body here
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/contacts/abc123', {
    method: 'PUT',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      // Your request body here
    })
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.put(
      'https://www.skaala.ai/api/v1/contacts/abc123',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']},
      json={
          # Your request body here
      }
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/services
Source: https://docs.skaala.ai/api-reference/services/list-services

GET /v1/services
Transform service to API response format (snake_case)

# GET /v1/services

Transform service to API response format (snake\_case)

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/services \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/services', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/services',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# POST /v1/webhooks
Source: https://docs.skaala.ai/api-reference/webhooks/create-webhooks

POST /v1/webhooks
GET /api/v1/webhooks List webhook subscriptions for the team

# POST /v1/webhooks

GET /api/v1/webhooks List webhook subscriptions for the team

## Request Body

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://www.skaala.ai/api/v1/webhooks \
    -H "X-API-Key: sk_live_your_key_here" \
    -H "Content-Type: application/json" \
    -d '{
      // Your request body here
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/webhooks', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      // Your request body here
    })
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.post(
      'https://www.skaala.ai/api/v1/webhooks',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']},
      json={
          # Your request body here
      }
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# DELETE /v1/webhooks/{webhookId}
Source: https://docs.skaala.ai/api-reference/webhooks/delete-webhooks-by-id

DELETE /v1/webhooks/{webhookId}
GET /api/v1/webhooks/[webhookId] Get a single webhook subscription

# DELETE /v1/webhooks/

GET /api/v1/webhooks/\[webhookId] Get a single webhook subscription

## Path Parameters

<ParamField type="string">
  webhookId
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X DELETE https://www.skaala.ai/api/v1/webhooks/example_webhookId \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/webhooks/example_webhookId', {
    method: 'DELETE',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.delete(
      'https://www.skaala.ai/api/v1/webhooks/example_webhookId',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/webhooks/{webhookId}
Source: https://docs.skaala.ai/api-reference/webhooks/get-webhooks-by-id

GET /v1/webhooks/{webhookId}
GET /api/v1/webhooks/[webhookId] Get a single webhook subscription

# GET /v1/webhooks/

GET /api/v1/webhooks/\[webhookId] Get a single webhook subscription

## Path Parameters

<ParamField type="string">
  webhookId
</ParamField>

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/webhooks/example_webhookId \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/webhooks/example_webhookId', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/webhooks/example_webhookId',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/webhooks
Source: https://docs.skaala.ai/api-reference/webhooks/list-webhooks

GET /v1/webhooks
GET /api/v1/webhooks List webhook subscriptions for the team

# GET /v1/webhooks

GET /api/v1/webhooks List webhook subscriptions for the team

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/webhooks \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/webhooks', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/webhooks',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# GET /v1/webhooks/events
Source: https://docs.skaala.ai/api-reference/webhooks/list-webhooks-events

GET /v1/webhooks/events
GET /api/v1/webhooks/events List available webhook event types (public endpoint for documentation)

# GET /v1/webhooks/events

GET /api/v1/webhooks/events List available webhook event types (public endpoint for documentation)

## Responses

<ResponseField name="200" type="success">
  Successful response
</ResponseField>

<ResponseField name="400" type="error">
  Bad request - Invalid parameters

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="401" type="error">
  Unauthorized - Invalid or missing API key

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="404" type="error">
  Not found

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

<ResponseField name="500" type="error">
  Internal server error

  Returns a [`Error`](#components/schemas/Error) object
</ResponseField>

## Code Examples

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET https://www.skaala.ai/api/v1/webhooks/events \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/webhooks/events', {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const data = await response.json();
  console.log(data);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/webhooks/events',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(data)
  ```
</CodeGroup>


# Authentication
Source: https://docs.skaala.ai/getting-started/authentication

Learn how to authenticate with the Skaala API using API keys or OAuth

# API Authentication

Skaala supports two authentication methods for API access:

<CardGroup>
  <Card title="API Keys" icon="key">
    **Recommended for integrations**
    Simple bearer token authentication with granular scopes
  </Card>

  <Card title="Stack Auth Cookies" icon="cookie">
    **For web dashboard**
    Session-based authentication for browser access
  </Card>
</CardGroup>

## API Key Authentication

### Creating an API Key

<Tabs>
  <Tab title="Dashboard UI (Recommended)">
    <Steps>
      <Step title="Navigate to settings">
        Go to **Dashboard** → **Settings** → **Developer**
      </Step>

      <Step title="Create API key">
        Click **Create API Key** and configure:

        * **Name**: Descriptive name (e.g., "Zapier Integration")
        * **Scopes**: Select required permissions
        * **Expiration**: Set expiry date (default: 365 days)
      </Step>

      <Step title="Save immediately">
        **Important**: Copy the key immediately - it's only shown once!
      </Step>
    </Steps>
  </Tab>

  <Tab title="API (Programmatic)">
    ```bash theme={null}
    curl -X POST "https://www.skaala.ai/api/teams/{TEAM_ID}/api-keys" \
      -H "Content-Type: application/json" \
      -H "Cookie: {YOUR_AUTH_COOKIE}" \
      -d '{
        "name": "Zapier Integration",
        "scopes": ["read:bookings", "write:bookings", "read:contacts"],
        "expires_in_days": 365
      }'
    ```
  </Tab>
</Tabs>

### Using API Keys

API keys can be provided in two ways:

<Tabs>
  <Tab title="Authorization Header (Recommended)">
    <CodeGroup>
      ```bash cURL theme={null}
      curl "https://www.skaala.ai/api/v1/bookings" \
        -H "Authorization: Bearer sk_live_your_api_key_here"
      ```

      ```javascript JavaScript theme={null}
      const response = await fetch('https://www.skaala.ai/api/v1/bookings', {
        headers: {
          'Authorization': `Bearer ${process.env.SKAALA_API_KEY}`
        }
      });
      ```

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

      response = requests.get(
          'https://www.skaala.ai/api/v1/bookings',
          headers={'Authorization': f"Bearer {os.environ['SKAALA_API_KEY']}"}
      )
      ```

      ```powershell PowerShell theme={null}
      $ApiKey = $env:SKAALA_API_KEY
      Invoke-RestMethod -Uri "https://www.skaala.ai/api/v1/bookings" `
        -Headers @{ "Authorization" = "Bearer $ApiKey" }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="X-API-Key Header">
    <CodeGroup>
      ```bash cURL theme={null}
      curl "https://www.skaala.ai/api/v1/bookings" \
        -H "X-API-Key: sk_live_your_api_key_here"
      ```

      ```javascript JavaScript theme={null}
      const response = await fetch('https://www.skaala.ai/api/v1/bookings', {
        headers: {
          'X-API-Key': process.env.SKAALA_API_KEY
        }
      });
      ```

      ```python Python theme={null}
      response = requests.get(
          'https://www.skaala.ai/api/v1/bookings',
          headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
      )
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## Available Scopes

API keys support granular permissions to limit access:

<AccordionGroup>
  <Accordion title="Read Scopes" icon="book-open">
    * `read:bookings` - View bookings and appointments
    * `read:contacts` - View contacts and customer profiles
    * `read:calls` - View call history and transcripts
    * `read:services` - View services and pricing
    * `read:staff` - View staff information
  </Accordion>

  <Accordion title="Write Scopes" icon="pen-to-square">
    * `write:bookings` - Create and update bookings
    * `write:contacts` - Create and update contacts
    * `write:calls` - Create call records
  </Accordion>

  <Accordion title="Management Scopes" icon="gears">
    * `webhooks:manage` - Subscribe to and manage webhooks
  </Accordion>
</AccordionGroup>

<Tip>
  **Best Practice**: Use the minimum scopes required for your integration.
  For read-only integrations, only request `read:*` scopes.
</Tip>

## Security Best Practices

<CardGroup>
  <Card title="Environment Variables" icon="shield-check">
    Never commit API keys to version control. Use environment variables:

    ```bash theme={null}
    export SKAALA_API_KEY=sk_live_...
    ```
  </Card>

  <Card title="Minimal Scopes" icon="lock">
    Grant only the permissions needed. Read-only when possible.
  </Card>

  <Card title="Set Expiration" icon="calendar-days">
    Default: 365 days. Rotate keys regularly for production.
  </Card>

  <Card title="Monitor Usage" icon="chart-line">
    Check "Last Used" timestamp in dashboard to detect unused keys.
  </Card>
</CardGroup>

## Error Responses

<ResponseField name="401 Unauthorized" type="error">
  ```json theme={null}
  {
    "error": "unauthorized",
    "message": "Invalid API key"
  }
  ```

  **Common causes:**

  * API key doesn't exist or has been revoked
  * API key has expired
  * Invalid format (must start with `sk_live_`)
</ResponseField>

<ResponseField name="403 Forbidden" type="error">
  ```json theme={null}
  {
    "error": "forbidden",
    "message": "Insufficient scopes"
  }
  ```

  **Common causes:**

  * API key lacks required scope for endpoint
  * User no longer has team access
  * Team membership revoked
</ResponseField>

## Complete Example

Here's a complete PowerShell example showing both GET and POST requests:

```powershell PowerShell theme={null}
$BaseUrl = "https://www.skaala.ai"
$ApiKey = $env:SKAALA_API_KEY

# List bookings
$bookings = Invoke-RestMethod -Method Get `
  -Uri "$BaseUrl/api/v1/bookings" `
  -Headers @{ "Authorization" = "Bearer $ApiKey" }

Write-Output "Found $($bookings.meta.total) bookings"

# Create a booking
$body = @{
  service_id = "svc_abc123"
  start_time = "2025-01-15T10:00:00Z"
  contact = @{
    name = "Anna Svensson"
    email = "anna@example.se"
    phone = "+46701234567"
  }
  notes = "First-time customer"
} | ConvertTo-Json

$newBooking = Invoke-RestMethod -Method Post `
  -Uri "$BaseUrl/api/v1/bookings" `
  -Headers @{
    "Authorization" = "Bearer $ApiKey"
    "Content-Type" = "application/json"
  } `
  -Body $body

Write-Output "Booking created: $($newBooking.data.id)"
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="Unauthorized with valid-looking key">
    **Check:**

    1. Key format must start with `sk_live_`
    2. Key hasn't been revoked in dashboard
    3. Key hasn't expired
    4. Correct team ID in URL path
  </Accordion>

  <Accordion title="Forbidden with valid key">
    **Check:**

    1. Key has required scope (e.g., `write:bookings` for POST)
    2. User still has team membership
    3. Team ID matches key's team
  </Accordion>

  <Accordion title="Can't create API key">
    **Check:**

    1. You have `admin` or `owner` role
    2. Authenticated via dashboard cookies
    3. Team ID is correct in the URL
  </Accordion>
</AccordionGroup>

## Migration from Cookie Auth

If you're currently using cookie authentication and want to switch:

<Tabs>
  <Tab title="Before (Cookies)">
    ```powershell theme={null}
    Invoke-RestMethod -Uri "$BaseUrl/api/v1/bookings" `
      -Headers @{ "Cookie" = "stack-access-token=..." }
    ```
  </Tab>

  <Tab title="After (API Key)">
    ```powershell theme={null}
    Invoke-RestMethod -Uri "$BaseUrl/api/v1/bookings" `
      -Headers @{ "Authorization" = "Bearer sk_live_..." }
    ```
  </Tab>
</Tabs>

**Benefits of API keys:**

* ✅ No cookie refresh handling required
* ✅ Simpler authentication flow
* ✅ Granular permissions via scopes
* ✅ Easy rotation and revocation
* ✅ Audit trail with "last used" timestamp

## Next Steps

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/getting-started/quickstart">
    Make your first API call
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/bookings/list-bookings">
    Browse all endpoints
  </Card>

  <Card title="Rate Limits" icon="gauge-high" href="/guides/rate-limits">
    Understand API limits
  </Card>

  <Card title="Webhooks" icon="webhook" href="/guides/webhooks">
    Set up real-time notifications
  </Card>
</CardGroup>


# Introduction
Source: https://docs.skaala.ai/getting-started/introduction

Welcome to the Skaala API documentation. Build powerful integrations with our AI-powered receptionist platform.

# Welcome to Skaala API

Skaala provides a comprehensive REST API that enables you to integrate AI-powered phone receptionist capabilities into your applications. Our API allows you to manage bookings, contacts, calls, services, and more.

## What is Skaala?

Skaala is an AI-powered phone receptionist platform that combines:

* **Voice AI**: Natural conversational AI powered by ElevenLabs
* **Phone Integration**: Seamless telephony via Twilio
* **Smart Booking**: Automated appointment scheduling and management
* **CRM**: Built-in customer relationship management
* **Analytics**: Detailed call logs and performance insights

## Key Features

<CardGroup>
  <Card title="RESTful API" icon="brackets-curly">
    Clean, predictable REST endpoints with JSON responses
  </Card>

  <Card title="Real-time Webhooks" icon="webhook">
    Get instant notifications for booking events, call completions, and more
  </Card>

  <Card title="OpenAPI Spec" icon="file-code">
    Full OpenAPI 3.1 specification with interactive playground
  </Card>

  <Card title="Multi-language" icon="language">
    Documentation available in English, Swedish, and Norwegian
  </Card>
</CardGroup>

## Getting Started

<Steps>
  <Step title="Get your API key">
    Sign up at [skaala.ai](https://www.skaala.ai) and generate an API key from your dashboard settings.
  </Step>

  <Step title="Make your first request">
    Try listing your bookings to verify authentication is working.
  </Step>

  <Step title="Explore the API">
    Browse our API reference to discover all available endpoints.
  </Step>

  <Step title="Set up webhooks">
    Configure webhooks to receive real-time notifications.
  </Step>
</Steps>

## Need Help?

<CardGroup>
  <Card title="API Reference" icon="book" href="/api-reference/bookings/list-bookings">
    Browse all available endpoints
  </Card>

  <Card title="Guides" icon="map" href="/guides/webhooks">
    Step-by-step tutorials and examples
  </Card>

  <Card title="Support" icon="life-ring" href="https://www.skaala.ai/en/contact">
    Contact our support team
  </Card>

  <Card title="Dashboard" icon="gauge" href="https://www.skaala.ai/dashboard">
    Access your API keys and settings
  </Card>
</CardGroup>


# Quickstart
Source: https://docs.skaala.ai/getting-started/quickstart

Get up and running with the Skaala API in minutes

# Quickstart

This guide will help you make your first API call to Skaala in under 5 minutes.

## 1. Get Your API Key

<Steps>
  <Step title="Sign in to Skaala">
    Log in to your Skaala dashboard at [skaala.ai](https://www.skaala.ai/dashboard)
  </Step>

  <Step title="Navigate to API Settings">
    Go to **Settings** → **API Keys**
  </Step>

  <Step title="Create API Key">
    Click **Create API Key** and copy your new key. It will look like `sk_live_abc123...`
  </Step>
</Steps>

<Warning>
  **Keep your API key secure!** Never share it publicly or commit it to version control.
  Use environment variables to store your key safely.
</Warning>

## 2. Make Your First Request

Let's list your bookings to verify everything is working:

<CodeGroup>
  ```bash cURL theme={null}
  curl https://www.skaala.ai/api/v1/bookings \
    -H "X-API-Key: sk_live_your_key_here"
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch('https://www.skaala.ai/api/v1/bookings', {
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY
    }
  });

  const { data, meta } = await response.json();
  console.log(`Found ${meta.total} bookings`);
  ```

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

  response = requests.get(
      'https://www.skaala.ai/api/v1/bookings',
      headers={'X-API-Key': os.environ['SKAALA_API_KEY']}
  )

  data = response.json()
  print(f"Found {data['meta']['total']} bookings")
  ```

  ```php PHP theme={null}
  <?php
  $apiKey = getenv('SKAALA_API_KEY');

  $ch = curl_init('https://www.skaala.ai/api/v1/bookings');
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      'X-API-Key: ' . $apiKey
  ]);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

  $response = curl_exec($ch);
  $data = json_decode($response, true);

  echo "Found {$data['meta']['total']} bookings\n";
  ?>
  ```
</CodeGroup>

## 3. Create a Booking

Now let's create a new booking:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://www.skaala.ai/api/v1/bookings \
    -H "X-API-Key: sk_live_your_key_here" \
    -H "Content-Type: application/json" \
    -d '{
      "service_id": "svc_abc123",
      "start_time": "2025-01-15T10:00:00Z",
      "contact": {
        "name": "Anna Svensson",
        "email": "anna@example.se",
        "phone": "+46701234567"
      },
      "notes": "First-time customer"
    }'
  ```

  ```javascript JavaScript theme={null}
  const booking = await fetch('https://www.skaala.ai/api/v1/bookings', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.SKAALA_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      service_id: 'svc_abc123',
      start_time: '2025-01-15T10:00:00Z',
      contact: {
        name: 'Anna Svensson',
        email: 'anna@example.se',
        phone: '+46701234567'
      },
      notes: 'First-time customer'
    })
  });

  const { data } = await booking.json();
  console.log('Booking created:', data.id);
  ```

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

  booking = requests.post(
      'https://www.skaala.ai/api/v1/bookings',
      headers={
          'X-API-Key': os.environ['SKAALA_API_KEY'],
          'Content-Type': 'application/json'
      },
      json={
          'service_id': 'svc_abc123',
          'start_time': '2025-01-15T10:00:00Z',
          'contact': {
              'name': 'Anna Svensson',
              'email': 'anna@example.se',
              'phone': '+46701234567'
          },
          'notes': 'First-time customer'
      }
  )

  data = booking.json()
  print(f"Booking created: {data['data']['id']}")
  ```
</CodeGroup>

## 4. Set Up Webhooks (Optional)

Get real-time notifications when events occur:

```bash theme={null}
curl -X POST https://www.skaala.ai/api/v1/webhooks \
  -H "X-API-Key: sk_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.com/webhooks/skaala",
    "events": ["booking.created", "booking.cancelled", "call.completed"]
  }'
```

<Tip>
  See our [Webhooks Guide](/guides/webhooks) for detailed setup instructions and event types.
</Tip>

## Next Steps

<CardGroup>
  <Card title="Authentication" icon="key" href="/getting-started/authentication">
    Learn about API keys and OAuth
  </Card>

  <Card title="Pagination" icon="list" href="/guides/pagination">
    Handle large result sets efficiently
  </Card>

  <Card title="Error Handling" icon="triangle-exclamation" href="/guides/errors">
    Understand error codes and responses
  </Card>

  <Card title="Rate Limits" icon="gauge-high" href="/guides/rate-limits">
    Stay within API limits
  </Card>
</CardGroup>

## Common Use Cases

Explore these guides for specific integration scenarios:

* [Booking Flow](/guides/use-cases/booking-flow) - Build a complete booking system
* [Agent Configuration](/guides/use-cases/agent-configuration) - Set up voice AI agents
* [Call Handling](/guides/use-cases/call-handling) - Manage inbound calls

## Need Help?

* **API Reference**: Browse all endpoints and schemas
* **Support**: Email [support@skaala.ai](mailto:support@skaala.ai) or [contact us](https://www.skaala.ai/en/contact)
* **Dashboard**: Access your [API keys and settings](https://www.skaala.ai/dashboard)


# SDK Installation
Source: https://docs.skaala.ai/getting-started/sdk-installation

Install and configure Skaala SDKs for your preferred language

# SDK Installation

Skaala provides official SDKs to make integration easier. Choose your language below:

<Info>
  **Coming Soon**: Official SDKs are currently in development. For now, use the REST API directly with your preferred HTTP client.
</Info>

## Available SDKs

<CardGroup>
  <Card title="JavaScript/TypeScript" icon="js">
    **Status**: Coming Q1 2025

    Features:

    * Type-safe API client
    * Webhook verification
    * React hooks
  </Card>

  <Card title="Python" icon="python">
    **Status**: Coming Q1 2025

    Features:

    * Async/await support
    * Pydantic models
    * Django integration
  </Card>

  <Card title="PHP" icon="php">
    **Status**: Coming Q2 2025

    Features:

    * PSR-7 compatible
    * Laravel package
    * Symfony bundle
  </Card>
</CardGroup>

## Using the REST API Directly

Until official SDKs are available, you can use the REST API with your favorite HTTP client:

<Tabs>
  <Tab title="JavaScript/TypeScript">
    ```typescript theme={null}
    // Using fetch (built-in)
    const SKAALA_API_KEY = process.env.SKAALA_API_KEY;
    const BASE_URL = 'https://www.skaala.ai/api';

    async function listBookings() {
      const response = await fetch(`${BASE_URL}/v1/bookings`, {
        headers: {
          'Authorization': `Bearer ${SKAALA_API_KEY}`
        }
      });

      if (!response.ok) {
        throw new Error(`API error: ${response.status}`);
      }

      return await response.json();
    }

    // Usage
    const { data, meta } = await listBookings();
    console.log(`Found ${meta.total} bookings`);
    ```

    **Recommended clients:**

    * `fetch` (built-in in Node 18+)
    * `axios` - Feature-rich HTTP client
    * `ky` - Modern fetch wrapper
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    import requests
    import os

    SKAALA_API_KEY = os.environ['SKAALA_API_KEY']
    BASE_URL = 'https://www.skaala.ai/api'

    def list_bookings():
        response = requests.get(
            f'{BASE_URL}/v1/bookings',
            headers={'Authorization': f'Bearer {SKAALA_API_KEY}'}
        )
        response.raise_for_status()
        return response.json()

    # Usage
    result = list_bookings()
    print(f"Found {result['meta']['total']} bookings")
    ```

    **Recommended clients:**

    * `requests` - Simple HTTP library
    * `httpx` - Async-capable client
    * `aiohttp` - Async HTTP client
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    <?php
    require 'vendor/autoload.php';

    use GuzzleHttp\Client;

    $apiKey = getenv('SKAALA_API_KEY');
    $baseUrl = 'https://www.skaala.ai/api';

    $client = new Client([
        'base_uri' => $baseUrl,
        'headers' => [
            'Authorization' => 'Bearer ' . $apiKey
        ]
    ]);

    $response = $client->get('/v1/bookings');
    $data = json_decode($response->getBody(), true);

    echo "Found {$data['meta']['total']} bookings\n";
    ?>
    ```

    **Recommended clients:**

    * `guzzlehttp/guzzle` - Full-featured HTTP client
    * `symfony/http-client` - Symfony's HTTP client
  </Tab>
</Tabs>

## Code Generators

Generate type-safe clients from our OpenAPI specification:

<CardGroup>
  <Card title="OpenAPI Generator" icon="code">
    Generate clients in 50+ languages from our OpenAPI spec:

    ```bash theme={null}
    openapi-generator-cli generate \
      -i https://www.skaala.ai/api-docs/openapi.json \
      -g typescript-fetch \
      -o ./skaala-client
    ```
  </Card>

  <Card title="Swagger Codegen" icon="file-code">
    Alternative code generator:

    ```bash theme={null}
    swagger-codegen generate \
      -i https://www.skaala.ai/api-docs/openapi.json \
      -l typescript-fetch \
      -o ./skaala-client
    ```
  </Card>
</CardGroup>

## Environment Setup

Store your API key securely using environment variables:

<Tabs>
  <Tab title=".env File">
    ```bash .env theme={null}
    SKAALA_API_KEY=sk_live_your_key_here
    SKAALA_BASE_URL=https://www.skaala.ai/api
    ```

    <Warning>
      Add `.env` to your `.gitignore` to prevent committing secrets!
    </Warning>
  </Tab>

  <Tab title="Vercel">
    ```bash theme={null}
    # Add via Vercel CLI
    vercel env add SKAALA_API_KEY

    # Or via Vercel Dashboard:
    # Settings → Environment Variables
    ```
  </Tab>

  <Tab title="GitHub Actions">
    ```yaml .github/workflows/deploy.yml theme={null}
    env:
      SKAALA_API_KEY: ${{ secrets.SKAALA_API_KEY }}
    ```

    Add secrets via **Settings** → **Secrets and variables** → **Actions**
  </Tab>
</Tabs>

## Next Steps

<CardGroup>
  <Card title="Authentication" icon="key" href="/getting-started/authentication">
    Learn about API keys and scopes
  </Card>

  <Card title="Quickstart" icon="rocket" href="/getting-started/quickstart">
    Make your first API call
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/bookings/list-bookings">
    Explore all endpoints
  </Card>

  <Card title="OpenAPI Spec" icon="file-code" href="https://www.skaala.ai/api-docs/openapi.json">
    Download OpenAPI specification
  </Card>
</CardGroup>

## Subscribe for SDK Updates

Want to be notified when official SDKs are released?

<Info>
  Email [support@skaala.ai](mailto:support@skaala.ai) with subject "SDK Notifications" and your preferred language(s).
</Info>


# Bookings & Payments
Source: https://docs.skaala.ai/guides/bookings-and-payments

How the booking system and payment processing work

# Bookings & Payments

Skaala's booking system lets your AI receptionist schedule appointments and collect payments automatically. This guide explains how it all works.

## How Bookings Work

### The Customer Experience

When someone calls your Skaala number and wants to book an appointment:

<Steps>
  <Step title="AI Checks Availability">
    Your AI looks at your calendar in real-time and tells the caller which time slots are open
  </Step>

  <Step title="Customer Chooses Time">
    Caller picks their preferred date and time
  </Step>

  <Step title="AI Collects Information">
    Gets name, phone, email, and any special requests
  </Step>

  <Step title="Payment (if enabled)">
    If you require payment, AI securely collects payment information
  </Step>

  <Step title="Confirmation">
    Customer gets instant confirmation via SMS and email
  </Step>
</Steps>

### Behind the Scenes

What happens after the booking:

1. **Calendar Updated**: Booking appears in your dashboard instantly
2. **Time Slot Blocked**: That time is no longer offered to other callers
3. **Customer Added**: Contact is created or updated in your CRM
4. **Notifications Sent**: You and the customer both get confirmation
5. **Payment Processed**: If payment required, funds are secured immediately

<Info>
  **Real-Time Sync**: If you manually add a booking in your dashboard, the AI immediately knows about it and won't double-book that slot.
</Info>

***

## Booking Configuration

### Service Setup

Each service you offer needs to be configured with:

**Required Information:**

* Service name (e.g., "60-Minute Massage", "Haircut & Styling")
* Duration (how long it takes)
* Price (can be free if you don't charge)
* Description (helps AI explain it to customers)

**Optional Settings:**

* Buffer time before/after (e.g., 15 minutes between appointments)
* Specific availability (only certain days/times)
* Maximum bookings per day
* Requires deposit vs. full payment

### Calendar Rules

Control when bookings can be made:

<AccordionGroup>
  <Accordion title="Advance Notice">
    **Minimum**: Prevent last-minute bookings (e.g., "must book at least 2 hours ahead")

    **Maximum**: Limit how far in advance (e.g., "can only book up to 3 months out")

    **Why this matters**: Gives you time to prepare and prevents booking conflicts
  </Accordion>

  <Accordion title="Availability Windows">
    Set when each service is available:

    * Regular business hours
    * Specific days only (e.g., "Spa treatments only on weekdays")
    * Seasonal variations

    Example: "Haircuts available Mon-Sat 9am-6pm, but premium color services only Tue-Thu"
  </Accordion>

  <Accordion title="Capacity Management">
    Control booking limits:

    * Maximum appointments per day
    * Maximum simultaneous bookings (if you have multiple staff)
    * Block off time for breaks, lunch, admin work
  </Accordion>

  <Accordion title="Smart Scheduling">
    Let AI optimize your calendar:

    * Group similar services together
    * Minimize gaps between appointments
    * Prefer back-to-back bookings or spaced out (your choice)
  </Accordion>
</AccordionGroup>

***

## Payment Processing with Stripe

If you want to collect payments when customers book, you'll use Stripe - a secure, trusted payment platform used by millions of businesses worldwide.

### What is Stripe Express?

**Think of it like this:** Stripe Express is your own mini payment processor, connected to your bank account. When customers pay, money goes through Stripe and directly to your bank.

**Why Stripe Express?**

* ✅ **You keep control**: Funds go to YOUR bank account
* ✅ **Fast payouts**: Money available in 2-7 business days
* ✅ **Customer trust**: They see payments are processed by Stripe (secure & familiar)
* ✅ **No middleman**: Skaala never touches your money

### Setting Up Stripe (5-Minute Process)

<Steps>
  <Step title="Connect from Dashboard">
    Go to Settings → Payments → "Connect Stripe"
  </Step>

  <Step title="Create Stripe Account">
    If you don't have one, create a free Stripe Express account:

    * Business info (name, type, address)
    * Bank account details (for payouts)
    * ID verification (required by law)
  </Step>

  <Step title="Configure Payment Settings">
    Choose your preferences:

    * When to charge (booking time vs. later)
    * Refund policy
    * Deposit vs. full payment
  </Step>

  <Step title="Test It">
    Make a test booking to ensure everything works
  </Step>
</Steps>

<Warning>
  **Important**: Stripe requires business verification for legal/security reasons. Have your business registration info and bank account number ready.
</Warning>

### Payment Options

You have several ways to collect payment:

<CardGroup>
  <Card title="Full Payment at Booking" icon="credit-card">
    **Best for**: Services where no-shows are costly

    Customer pays entire amount when they book. Booking is guaranteed.
  </Card>

  <Card title="Deposit Only" icon="coins">
    **Best for**: High-value services

    Customer pays partial amount (e.g., 20-50%) to secure booking. Pay rest in person.
  </Card>

  <Card title="Pay in Person" icon="building-columns">
    **Best for**: Building trust with new customers

    No payment required to book. Customer pays when they arrive. Higher no-show risk.
  </Card>

  <Card title="Mixed Approach" icon="split">
    **Best for**: Multiple service types

    Require payment for some services, allow pay-in-person for others.
  </Card>
</CardGroup>

### Payment Flow (What Customers Experience)

**During the Call:**

1. AI mentions the price: "This service is 450 kr"
2. If payment required, AI asks: "Would you like to pay now to confirm your booking?"
3. Customer says yes → AI sends a secure payment link via SMS
4. Customer clicks link, enters card info on Stripe's secure page
5. Payment processed → Booking confirmed instantly

**Alternatively:**

* AI can take card details over the phone (if you enable this)
* Customer can pay later via link in confirmation email

<Tip>
  **Security Note**: Skaala and your AI never see or store card numbers. All payment info goes directly to Stripe's secure servers.
</Tip>

***

## Managing Payments in Your Dashboard

### Payment Status Tracking

Each booking shows payment status:

* ✅ **Paid**: Payment received, booking secured
* ⏳ **Pending**: Payment link sent but not completed
* 💰 **Deposit Paid**: Partial payment received
* 📍 **Pay in Person**: No advance payment required
* ❌ **Refunded**: Payment was returned to customer

### Refunds & Cancellations

**If customer needs to cancel:**

<Steps>
  <Step title="Go to Booking Details">
    Find the booking in your dashboard
  </Step>

  <Step title="Click 'Cancel Booking'">
    Choose cancellation reason
  </Step>

  <Step title="Choose Refund Option">
    * **Full refund**: Return entire payment
    * **Partial refund**: Keep cancellation fee
    * **No refund**: Per your policy
  </Step>

  <Step title="Process Refund">
    Refund appears in customer's account in 5-10 business days
  </Step>
</Steps>

<Warning>
  **Refund Policy**: Clearly state your cancellation and refund policy. AI can mention it during booking: "Please note we have a 24-hour cancellation policy."
</Warning>

### Financial Reports

Track your revenue in **Analytics → Financial Reports**:

* Total bookings value
* Payments received vs. pending
* Refunds issued
* Revenue by service type
* Revenue by day/week/month

**Export Options:**

* Download as CSV for accounting software
* Automatic monthly reports via email
* Integration with accounting tools (via Zapier)

***

## Advanced Booking Features

### Variable Pricing

Charge different rates based on:

* **Time of day**: Higher rates for peak hours
* **Day of week**: Weekend premium pricing
* **Season**: Summer vs. winter rates
* **Duration**: Discounts for longer sessions

Example:

```
Standard Massage (60 min): 500 kr
Extended Massage (90 min): 650 kr (save 100 kr!)
Weekend Massage (60 min): 600 kr
```

### Packages & Bundles

Sell multi-session packages:

* "Buy 5 sessions, get 6th free"
* "Monthly unlimited pass"
* "Package of 10 sessions at discounted rate"

AI can explain packages during calls and book package sessions.

### Add-Ons & Upgrades

Let customers enhance their booking:

* "Add aromatherapy for +50 kr"
* "Upgrade to premium products"
* "Include after-care kit"

AI asks about add-ons naturally during booking.

### Group Bookings

Accept bookings for multiple people:

* "Book 2 spa treatments at the same time"
* "Reserve time for me and 3 friends"
* AI handles group pricing and scheduling

***

## Booking Rules & Policies

### No-Show Prevention

Reduce no-shows with these strategies:

<CardGroup>
  <Card title="Require Payment">
    Customers who pay upfront rarely miss appointments
  </Card>

  <Card title="Reminder Messages">
    Automatic SMS/email 24 hours before appointment
  </Card>

  <Card title="Easy Rescheduling">
    Let customers change time via link (avoids no-shows)
  </Card>

  <Card title="No-Show Fees">
    Charge penalty if payment was required but customer didn't show
  </Card>
</CardGroup>

### Cancellation Policy

Set clear rules:

* **Free cancellation**: Up to X hours before appointment
* **Cancellation fee**: If cancelled within X hours
* **No refund**: If customer simply doesn't show up

Example Policy:

```
"Free cancellation up to 24 hours before your appointment.
Cancellations within 24 hours: 50% charge.
No-shows: Full charge."
```

AI automatically mentions this when taking bookings.

***

## Integration with External Systems

### Calendar Sync

Connect your existing calendar:

* Google Calendar
* Outlook Calendar
* Apple Calendar
* iCal-compatible systems

**Two-way sync means:**

* Skaala bookings appear in your calendar
* Events in your calendar block off time in Skaala
* No double-bookings, ever

### External Booking Systems

Already have a booking system? Integrate it:

* Skaala can check availability via API
* AI books directly in your existing system
* All your current workflows stay the same

Supported platforms:

* Bokadirekt
* Timely
* Acuity Scheduling
* Custom systems via API

### Point-of-Sale Integration

If you have a POS system:

* Sync pricing from your POS to Skaala
* Export Skaala bookings to your POS
* Unified reporting across all channels

***

## Best Practices

### For Maximum Bookings

<AccordionGroup>
  <Accordion title="Keep It Simple">
    Don't overwhelm customers with too many options. Limit to 3-5 main services with clear descriptions.
  </Accordion>

  <Accordion title="Flexible Availability">
    More available slots = more bookings. Consider extended hours or weekend availability.
  </Accordion>

  <Accordion title="Easy Payment">
    Offer multiple payment options. Some customers prefer pay-in-person, others want to pay upfront.
  </Accordion>

  <Accordion title="Clear Pricing">
    No hidden fees or surprises. AI should state the exact price before booking.
  </Accordion>
</AccordionGroup>

### For Smooth Operations

<AccordionGroup>
  <Accordion title="Buffer Time">
    Add 10-15 minutes between appointments for cleanup, setup, or running late.
  </Accordion>

  <Accordion title="Realistic Durations">
    Don't overbook by underestimating how long services take. Include customer greeting/checkout time.
  </Accordion>

  <Accordion title="Block Personal Time">
    Mark lunch breaks, meetings, and personal appointments in your calendar.
  </Accordion>

  <Accordion title="Regular Review">
    Weekly review: Which services are popular? Which time slots never book? Adjust accordingly.
  </Accordion>
</AccordionGroup>

***

## Troubleshooting Common Issues

<AccordionGroup>
  <Accordion title="Customer says payment link didn't work">
    **Check**: Is their phone number correct? Payment link sent via SMS.

    **Solution**: Resend link from booking details, or send via email instead.
  </Accordion>

  <Accordion title="Double-booking happened">
    **Cause**: Usually external calendar not syncing properly.

    **Solution**: Re-authorize calendar connection in Settings → Integrations.
  </Accordion>

  <Accordion title="Refund not showing up for customer">
    **Timeline**: Refunds take 5-10 business days to appear.

    **Check**: Look in Stripe dashboard to confirm refund was processed.
  </Accordion>

  <Accordion title="AI offering wrong prices">
    **Check**: Service pricing in Settings → Services.

    **Solution**: Update prices, AI uses latest info immediately.
  </Accordion>
</AccordionGroup>

***

## Need Help?

<CardGroup>
  <Card title="Payment Setup Support" icon="headset" href="https://www.skaala.ai/en/contact">
    Get help connecting Stripe or troubleshooting payments
  </Card>

  <Card title="API Documentation" icon="code" href="/api-reference/bookings/create-bookings">
    Technical details for custom booking integrations
  </Card>
</CardGroup>


# Dashboard Overview
Source: https://docs.skaala.ai/guides/dashboard-overview

Everything you can do in your Skaala dashboard

# Dashboard Overview

Your Skaala dashboard is mission control for your AI receptionist. This guide explains every feature and what you can do with it.

## Main Navigation

<CardGroup>
  <Card title="Overview" icon="home">
    Your at-a-glance summary of everything happening
  </Card>

  <Card title="Bookings" icon="calendar">
    Manage all appointments and reservations
  </Card>

  <Card title="Contacts" icon="users">
    Your customer relationship management (CRM) system
  </Card>

  <Card title="Calls" icon="phone">
    Listen to recordings and read transcripts
  </Card>

  <Card title="AI Assistant" icon="robot">
    Configure your AI's personality and capabilities
  </Card>

  <Card title="Analytics" icon="chart-line">
    Reports, insights, and performance metrics
  </Card>

  <Card title="Settings" icon="gear">
    Business info, team members, billing, and integrations
  </Card>
</CardGroup>

***

## Overview Page

When you log in, you'll see your dashboard overview - a snapshot of what's happening right now.

### Live Status

At the top, you'll see:

* **AI Status**: Is your receptionist online and ready to take calls?
* **Today's Stats**: Calls answered, bookings made, revenue earned
* **Active Call**: If someone is calling right now, you'll see it here

### Quick Actions

<CardGroup>
  <Card title="Add Booking" icon="plus">
    Manually create an appointment
  </Card>

  <Card title="View Recent Calls" icon="phone">
    Jump to the latest call logs
  </Card>

  <Card title="Update Hours" icon="clock">
    Change when you're open/closed
  </Card>
</CardGroup>

### Recent Activity Feed

See a timeline of everything happening:

* New bookings made by the AI
* Calls received and answered
* Payments processed
* Booking cancellations or changes

<Tip>
  Click any item in the feed to see full details, listen to the call recording, or view the booking.
</Tip>

***

## Bookings Management

This is where you manage all your appointments.

### Viewing Bookings

**Calendar View**: See all bookings on a calendar (day, week, or month)
**List View**: Table of all upcoming bookings with search and filters
**Past Bookings**: Historical record of completed appointments

### Booking Details

Click any booking to see:

* **Customer Info**: Who booked (name, phone, email)
* **Service Details**: What they booked and for how long
* **Payment Status**: Paid, pending, or pay in person
* **Notes**: Any special requests or information
* **Call Recording**: Listen to how the AI booked it
* **Booking Source**: Phone call, API, manual, or Zapier

### What You Can Do

<AccordionGroup>
  <Accordion title="Reschedule Appointments">
    Drag-and-drop in calendar view or click "Reschedule" to pick a new time. Customer gets automatic notification.
  </Accordion>

  <Accordion title="Cancel Bookings">
    Click "Cancel" and choose:

    * Notify customer (sends email/SMS)
    * Refund if they paid
    * Add cancellation reason
  </Accordion>

  <Accordion title="Add Manual Bookings">
    If someone books via email, social media, or in person, add it manually so your AI knows that time slot is taken.
  </Accordion>

  <Accordion title="Update Booking Notes">
    Add internal notes visible only to you (e.g., "VIP customer" or "First time visitor")
  </Accordion>

  <Accordion title="Mark as No-Show">
    If customer didn't show up, mark it as no-show to track and optionally charge no-show fee.
  </Accordion>
</AccordionGroup>

### Booking Rules

Configure how bookings work in **Settings → Booking Rules**:

* Minimum advance notice (e.g., "must book at least 2 hours ahead")
* Maximum advance booking (e.g., "can only book up to 3 months out")
* Buffer time between appointments
* Allow double-booking or block time slots

***

## Contacts (CRM)

Every person who calls becomes a contact automatically.

### Contact Profiles

Each contact shows:

* **Basic Info**: Name, phone, email
* **Call History**: Every conversation they've had with your AI
* **Booking History**: All their appointments (past and future)
* **Total Spent**: If you have payments enabled
* **Tags**: Label customers (e.g., "Regular", "VIP", "Needs Follow-up")
* **Notes**: Add private notes about the customer

### What You Can Do

<CardGroup>
  <Card title="Search & Filter">
    Find contacts by name, phone, email, tags, or booking history
  </Card>

  <Card title="Bulk Actions">
    Select multiple contacts to tag, export, or delete
  </Card>

  <Card title="Export Data">
    Download contact lists as CSV for email marketing or other tools
  </Card>

  <Card title="Merge Duplicates">
    If same person called from different numbers, merge their profiles
  </Card>
</CardGroup>

<Info>
  **Privacy Note**: All contact data is encrypted and GDPR-compliant. Customers can request their data deletion at any time.
</Info>

***

## Call Logs & Recordings

Review every call your AI has handled.

### Call List

See all calls with:

* **Date & Time**: When the call happened
* **Duration**: How long it lasted
* **Caller**: Who called (if number is recognized)
* **Outcome**: Booking made, info provided, missed call, etc.
* **Recording**: Listen to the full conversation

### Call Details Page

Click any call to see:

* **Full Transcript**: Written record of the conversation
* **Audio Player**: Listen to the recording
* **AI Actions**: What the AI did (booked appointment, sent SMS, etc.)
* **Sentiment Analysis**: Was the caller happy, frustrated, or neutral?
* **Keywords**: Automatically detected topics (pricing, hours, cancellation, etc.)

### Quality Monitoring

<AccordionGroup>
  <Accordion title="Track AI Performance">
    See how well your AI is handling calls:

    * Successful bookings vs. missed opportunities
    * Average call duration
    * Calls where AI asked for help or couldn't answer
  </Accordion>

  <Accordion title="Improve Responses">
    If you notice the AI giving wrong information:

    1. Flag the call
    2. Update AI training in Assistant settings
    3. AI learns for next time
  </Accordion>

  <Accordion title="Export Transcripts">
    Download transcripts for compliance, training, or review purposes
  </Accordion>
</AccordionGroup>

<Warning>
  **Legal Note**: Call recordings are stored for 90 days by default. Comply with your local laws regarding call recording and customer notification.
</Warning>

***

## AI Assistant Configuration

This is where you teach your AI how to represent your business.

### Personality & Tone

Choose your AI's communication style:

* **Professional**: Formal, businesslike (good for legal, medical, corporate)
* **Friendly**: Warm and approachable (good for services, hospitality)
* **Casual**: Relaxed and conversational (good for creative businesses)
* **Custom**: Write your own personality description

**Example Settings:**

```
Personality: Friendly and professional
Greeting: "Hej! You've reached Spa Harmony. How can I help you today?"
Tone: "Be warm but efficient. Use the customer's name if they give it."
```

### What the AI Knows

Train your AI by providing:

* **Business Description**: What you do in plain language
* **Services Offered**: Detailed list with descriptions and prices
* **Common Questions**: FAQ that the AI can reference
* **Policies**: Cancellation policy, payment terms, etc.
* **Special Instructions**: Anything specific (e.g., "We're closed on Swedish holidays")

### Capabilities You Can Enable

<CardGroup>
  <Card title="Booking Appointments" icon="calendar-check">
    AI can access your calendar and book available slots
  </Card>

  <Card title="Send SMS During Calls" icon="message">
    AI can text links, confirmations, or info while talking
  </Card>

  <Card title="Answer FAQs" icon="question">
    AI responds to common questions about hours, pricing, location
  </Card>

  <Card title="Take Messages" icon="envelope">
    If AI can't help, it takes detailed messages for you
  </Card>
</CardGroup>

### Advanced Features

<AccordionGroup>
  <Accordion title="Multi-Language Support">
    Enable Swedish, Norwegian, and English. AI auto-detects language and switches seamlessly.
  </Accordion>

  <Accordion title="Custom Workflows">
    Create specific call flows (e.g., "If caller asks about X, say Y and then offer Z")
  </Accordion>

  <Accordion title="Integration Actions">
    Connect to Zapier to trigger automations when certain things happen during calls
  </Accordion>
</AccordionGroup>

***

## Analytics & Reports

Understand your business performance with detailed analytics.

### Key Metrics Dashboard

<CardGroup>
  <Card title="Call Volume">
    Total calls, answered calls, missed calls
  </Card>

  <Card title="Booking Conversion">
    Percentage of calls that result in bookings
  </Card>

  <Card title="Revenue Tracking">
    Total bookings value and payments received
  </Card>

  <Card title="Busiest Hours">
    When do you get most calls? Plan staffing accordingly
  </Card>

  <Card title="Average Call Duration">
    How long customers spend on the phone
  </Card>

  <Card title="Customer Satisfaction">
    Based on call sentiment and feedback
  </Card>
</CardGroup>

### Reports You Can Generate

* **Weekly/Monthly Summaries**: Email reports sent automatically
* **Service Performance**: Which services are most popular?
* **Caller Demographics**: Where are calls coming from?
* **Peak Times Analysis**: When should you have staff ready?
* **Revenue by Service**: What makes the most money?

<Tip>
  **Pro Tip**: Use the "Compare to Previous Period" feature to see if you're growing week-over-week or month-over-month.
</Tip>

***

## Settings

### Business Information

* Update name, address, website
* Change business hours
* Add holidays and special closures
* Update contact information

### Team Management

* Invite team members
* Set permissions (Admin, Manager, Viewer)
* Each member gets their own login

### Billing & Subscription

* View current plan and usage
* Upgrade/downgrade plan
* Payment method and invoices
* Usage alerts (e.g., "90% of monthly minutes used")

### Integrations

* Connect Stripe for payments
* Link Zapier for automation
* API key management for custom integrations
* Webhook configuration for real-time events

***

## Quick Tips for Power Users

<CardGroup>
  <Card title="Keyboard Shortcuts">
    Press `?` anywhere in the dashboard to see all shortcuts
  </Card>

  <Card title="Bulk Operations">
    Select multiple items (bookings, contacts, calls) for batch actions
  </Card>

  <Card title="Custom Views">
    Save filtered views for quick access (e.g., "Today's Bookings", "VIP Contacts")
  </Card>

  <Card title="Mobile App">
    Download the Skaala mobile app to manage on-the-go
  </Card>
</CardGroup>

***

## Need More Help?

<CardGroup>
  <Card title="Video Tutorials" icon="video" href="https://www.skaala.ai/help">
    Watch step-by-step guides
  </Card>

  <Card title="Contact Support" icon="headset" href="https://www.skaala.ai/en/contact">
    Get help from our team
  </Card>

  <Card title="Community Forum" icon="users" href="https://www.skaala.ai/community">
    Learn from other Skaala users
  </Card>
</CardGroup>


# Error Handling
Source: https://docs.skaala.ai/guides/errors

Understanding Skaala API error responses and how to handle them

# Error Handling

The Skaala API uses conventional HTTP response codes to indicate success or failure.

## HTTP Status Codes

| Code | Meaning                                                |
| ---- | ------------------------------------------------------ |
| 200  | Success - Request completed successfully               |
| 201  | Created - Resource created successfully                |
| 400  | Bad Request - Invalid parameters or request body       |
| 401  | Unauthorized - Invalid or missing API key              |
| 403  | Forbidden - Valid API key but insufficient permissions |
| 404  | Not Found - Resource doesn't exist                     |
| 429  | Too Many Requests - Rate limit exceeded                |
| 500  | Server Error - Something went wrong on our end         |

## Error Response Format

```json theme={null}
{
  "error": "validation_error",
  "message": "Invalid request parameters",
  "fields": {
    "start_time": "Must be a valid ISO 8601 datetime"
  }
}
```


# Getting Started with Skaala
Source: https://docs.skaala.ai/guides/getting-started-guide

A complete walkthrough of setting up your AI phone receptionist

# Getting Started with Skaala

Welcome to Skaala! This guide will walk you through everything you need to know to get your AI phone receptionist up and running.

## What is Skaala?

Skaala is your 24/7 AI phone receptionist that answers calls, books appointments, and helps your customers - even when you're busy or closed. Think of it as hiring a professional receptionist who never sleeps, never takes breaks, and always knows your schedule.

## Your First Steps

### 1. Create Your Account

Sign up at [skaala.ai](https://www.skaala.ai) using your email. You'll be asked to:

* Choose your business name
* Select your industry
* Pick your preferred language (Swedish, Norwegian, or English)

### 2. The Setup Wizard

After signing up, you'll meet our interactive AI setup assistant. This is where the magic happens - instead of filling out boring forms, you'll have a natural conversation with our AI to configure everything.

**What the Setup Wizard Will Ask About:**

<AccordionGroup>
  <Accordion title="Your Business Information">
    * What services you offer
    * Your business hours
    * How long appointments typically take
    * Your business address (if needed)
  </Accordion>

  <Accordion title="Booking Preferences">
    * Can customers book online?
    * Do you need payment upfront?
    * How much notice do you need for bookings?
    * Should customers get confirmation emails?
  </Accordion>

  <Accordion title="AI Personality">
    * Should the AI be formal or friendly?
    * What greeting should it use?
    * Any specific phrases or information to mention?
    * Languages the AI should speak
  </Accordion>

  <Accordion title="Features You Want">
    * **Booking System**: Let customers book appointments during calls
    * **Payment Processing**: Accept payments when bookings are made
    * **SMS Notifications**: AI can send text messages during calls (like "I just texted you that link!")
    * **Call Analytics**: Track all calls and see transcripts
  </Accordion>
</AccordionGroup>

<Tip>
  **Pro Tip**: Don't worry about getting everything perfect! You can change all of these settings later in your dashboard.
</Tip>

### 3. Get Your Phone Number

Once you complete the setup wizard, you'll get a Swedish phone number for your AI receptionist. This number is what your customers will call.

**Setting Up Call Forwarding:**

You have two options:

<CardGroup>
  <Card title="Forward Your Existing Number" icon="phone-arrow-right">
    Keep your current business number and forward calls to your AI receptionist. Perfect if customers already know your number.
  </Card>

  <Card title="Use the New Number" icon="phone-plus">
    Use your new Skaala number directly on your website, social media, and marketing materials.
  </Card>
</CardGroup>

<Info>
  **Need help with call forwarding?** The setup wizard will give you the exact codes to dial based on your Swedish phone carrier (Telia, Telenor, Tele2, or Tre).
</Info>

### 4. Test Your AI

Before going live, call your new number and test it out! Try:

* Asking about your business hours
* Booking an appointment
* Asking the AI to send you information via SMS
* Speaking in different languages (if you enabled multiple)

## Understanding Your Dashboard

Once setup is complete, you'll see your dashboard. Here's what each section does:

### Overview Page

* See recent calls and bookings at a glance
* Quick stats: calls answered, bookings made, revenue earned
* Alerts for missed calls or system issues

### Bookings

* View all upcoming and past appointments
* Manually add bookings (if customer booked by phone, email, etc.)
* Cancel or reschedule appointments
* See payment status for each booking

### Contacts (CRM)

* Every caller automatically becomes a contact
* See call history for each person
* Add notes about customers
* Export contact lists

### Call Logs

* Listen to call recordings
* Read AI-generated transcripts
* See how long each call lasted
* Identify missed opportunities

### AI Assistant Settings

* Change your AI's personality and tone
* Update business hours
* Modify what the AI says
* Add new services or update prices

### Analytics

* Track busiest call times
* Most common questions
* Booking conversion rate
* Revenue reports

## Setting Up Payments (Optional)

If you selected payment processing during setup, you'll need to connect your Stripe account:

<Steps>
  <Step title="Connect Stripe">
    Click "Connect Stripe" in your dashboard settings
  </Step>

  <Step title="Complete Stripe Onboarding">
    You'll create a Stripe Express account (takes 5 minutes)
  </Step>

  <Step title="Set Pricing">
    Add prices to your services in the dashboard
  </Step>

  <Step title="Choose Payment Timing">
    Decide if customers pay when booking or in person
  </Step>
</Steps>

<Warning>
  **Important**: With payments enabled, customers can only book if they pay upfront. If you want to allow bookings without payment, keep "Pay in Person" mode enabled.
</Warning>

## Common Questions

<AccordionGroup>
  <Accordion title="What happens if the AI doesn't know an answer?">
    The AI is trained on your business information, but if it encounters something unexpected, it will politely tell the caller it needs to check and can either:

    * Take a message for you
    * Schedule a callback
    * Transfer the call to you (if you've set that up)
  </Accordion>

  <Accordion title="Can I change the AI's voice or personality?">
    Yes! Go to Dashboard → AI Assistant → Voice Settings. You can make it more formal, friendly, professional, or casual. You can also change speaking speed and tone.
  </Accordion>

  <Accordion title="Will the AI call people back?">
    Not automatically. But you can see missed calls in your dashboard and choose to call them back yourself.
  </Accordion>

  <Accordion title="Can I use this internationally?">
    Currently, Skaala provides Swedish phone numbers and is optimized for Swedish, Norwegian, and English. International expansion is coming soon!
  </Accordion>

  <Accordion title="What if I already have a booking system?">
    Perfect! Skaala integrates with your existing calendar and booking systems via our API and Zapier. The AI can check availability and create bookings in your system.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup>
  <Card title="Explore the Dashboard" icon="gauge" href="/guides/dashboard-overview">
    Learn about all dashboard features
  </Card>

  <Card title="Set Up Zapier Automation" icon="bolt" href="/integrations/zapier">
    Connect Skaala to 5,000+ apps
  </Card>

  <Card title="Understand Bookings" icon="calendar" href="/guides/bookings-and-payments">
    Deep dive into the booking system
  </Card>

  <Card title="API Integration" icon="code" href="/api-reference/bookings/list-bookings">
    Build custom integrations
  </Card>
</CardGroup>

## Need Help?

* **Live Chat**: Click the chat icon in the bottom right
* **Email**: [support@skaala.ai](mailto:support@skaala.ai)
* **Dashboard Tutorial**: Watch the walkthrough video in Settings → Help


# Pagination
Source: https://docs.skaala.ai/guides/pagination

Efficiently handle large result sets with pagination

# Pagination

List endpoints return paginated results to keep response sizes manageable.

## Pagination Parameters

| Parameter  | Type    | Default | Description               |
| ---------- | ------- | ------- | ------------------------- |
| `page`     | integer | 1       | Page number (1-indexed)   |
| `per_page` | integer | 25      | Items per page (max: 100) |

## Response Format

```json theme={null}
{
  "data": [...],
  "meta": {
    "total": 247,
    "page": 1,
    "per_page": 25,
    "has_more": true
  }
}
```

## Example

```bash theme={null}
# Get second page of bookings
curl "https://www.skaala.ai/api/v1/bookings?page=2&per_page=50" \
  -H "X-API-Key: sk_live_..."
```


# Rate Limits
Source: https://docs.skaala.ai/guides/rate-limits

Understanding Skaala API rate limits and best practices

# Rate Limits

The Skaala API implements rate limiting to ensure fair usage and system stability.

<Info>
  **Current Limits**: 100 requests per minute per API key
</Info>

## Rate Limit Headers

Every API response includes rate limit information:

```
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1704067200
```

## Handling Rate Limits

When you exceed the rate limit, you'll receive a `429 Too Many Requests` response:

```json theme={null}
{
  "error": "rate_limit_exceeded",
  "message": "Rate limit exceeded. Try again in 42 seconds.",
  "retry_after": 42
}
```

<Tip>
  Implement exponential backoff when you receive a 429 response.
</Tip>


# Agent Configuration
Source: https://docs.skaala.ai/guides/use-cases/agent-configuration

Customize your AI receptionist's personality and capabilities

# Agent Configuration

Configure your Skaala AI agent to match your brand voice and business needs.

## Overview

Your AI agent can be customized for:

* **Personality & Tone**: Professional, friendly, casual, or formal
* **Language Support**: Swedish, Norwegian, English
* **Business Rules**: Operating hours, services, pricing
* **Integration Tools**: Booking, transfers, knowledge base

## Configuration Dashboard

Access agent settings at `https://www.skaala.ai/dashboard/agents`

<Info>
  Changes to agent configuration take effect within 1-2 minutes
</Info>

## Voice & Personality

### Choose Voice Type

<Tabs>
  <Tab title="Professional">
    Business-focused tone suitable for corporate environments

    **Example Response:**

    > "Good morning, this is Acme Corporation. How may I assist you today?"
  </Tab>

  <Tab title="Friendly">
    Warm and approachable for service businesses

    **Example Response:**

    > "Hi there! Thanks for calling Bella Salon. What can I help you with?"
  </Tab>

  <Tab title="Casual">
    Relaxed tone for lifestyle brands

    **Example Response:**

    > "Hey! You've reached Surf Shack. What's up?"
  </Tab>
</Tabs>

### Custom Instructions

Add specific guidelines for your agent:

```yaml theme={null}
# Example agent instructions
greeting: "Welcome to {business_name}. I'm here to help schedule appointments."

booking_policy: |
  - Require full name and phone number
  - Confirm appointment details before booking
  - Offer 3 alternative times if requested slot unavailable

escalation_triggers:
  - Customer asks for manager
  - Pricing questions above $1000
  - Complaints or refund requests
```

## Tool Configuration

### Enable Booking System

<Steps>
  <Step title="Connect Calendar">
    Link Google Calendar or Outlook for availability
  </Step>

  <Step title="Define Services">
    Add bookable services with duration and pricing
  </Step>

  <Step title="Set Business Hours">
    Configure when appointments can be scheduled
  </Step>
</Steps>

### Enable Call Transfers

Configure live agent fallback:

```json theme={null}
{
  "transfer_enabled": true,
  "transfer_number": "+46701234567",
  "transfer_triggers": [
    "customer_escalation",
    "complex_inquiry",
    "vip_customer"
  ]
}
```

## Knowledge Base

Train your agent with business-specific information:

<AccordionGroup>
  <Accordion title="Upload Business Information">
    Add FAQs, policies, and product details
  </Accordion>

  <Accordion title="Website Scraping">
    Automatically pull content from your website
  </Accordion>

  <Accordion title="Custom Q&A">
    Define specific question-answer pairs
  </Accordion>
</AccordionGroup>

## Testing Your Agent

<Tip>
  Always test agent changes before going live
</Tip>

### Test Call Process

1. Call your Skaala test number
2. Try different scenarios (booking, questions, transfers)
3. Verify responses match your expectations
4. Adjust configuration as needed

## Related Resources

<CardGroup>
  <Card title="API Reference" icon="code" href="/api-reference/bookings/list-bookings">
    Programmatic agent configuration
  </Card>

  <Card title="ElevenLabs Integration" icon="microphone" href="/integrations/elevenlabs">
    Voice and audio settings
  </Card>
</CardGroup>


# Booking Flow Integration
Source: https://docs.skaala.ai/guides/use-cases/booking-flow

Complete guide to implementing AI-powered booking system

# Booking Flow Integration

Learn how to integrate Skaala's AI-powered booking system into your application.

## Overview

Skaala's booking system enables customers to schedule appointments through natural conversation with your AI receptionist. The system handles:

* **Availability Checking**: Real-time calendar integration
* **Slot Booking**: Automatic reservation and confirmation
* **Conflict Prevention**: Double-booking protection
* **Customer Notifications**: SMS/email confirmations

## Integration Steps

<Steps>
  <Step title="Configure Services">
    Define your bookable services with duration and pricing

    ```bash theme={null}
    curl -X POST https://www.skaala.ai/api/v1/services \
      -H "X-API-Key: sk_live_..." \
      -d '{
        "name": "Haircut",
        "duration_minutes": 60,
        "price": 500
      }'
    ```
  </Step>

  <Step title="Connect Calendar">
    Link your Google Calendar or Outlook calendar for availability sync
  </Step>

  <Step title="Configure Agent">
    Set up your AI agent to handle booking requests naturally
  </Step>

  <Step title="Test Booking Flow">
    Call your Skaala number and request an appointment
  </Step>
</Steps>

## Webhook Events

Monitor booking events in real-time:

```javascript theme={null}
// Listen for new bookings
app.post('/webhooks/skaala', (req, res) => {
  const { event, data } = req.body;

  if (event === 'booking.created') {
    console.log('New booking:', data);
    // Send confirmation email
    // Update internal systems
  }

  res.status(200).send('OK');
});
```

## Best Practices

<AccordionGroup>
  <Accordion title="Buffer Time Between Appointments">
    Add 10-15 minute buffers to prevent scheduling conflicts
  </Accordion>

  <Accordion title="Confirmation Requirements">
    Require customer phone/email before confirming bookings
  </Accordion>

  <Accordion title="Cancellation Policy">
    Configure cancellation windows and automated reminders
  </Accordion>
</AccordionGroup>

## Related Resources

<CardGroup>
  <Card title="Bookings API" icon="calendar" href="/api-reference/bookings/list-bookings">
    Full API reference for booking endpoints
  </Card>

  <Card title="Webhooks Guide" icon="webhook" href="/guides/webhooks">
    Set up real-time event notifications
  </Card>
</CardGroup>


# Call Handling & Routing
Source: https://docs.skaala.ai/guides/use-cases/call-handling

Advanced call management and routing strategies

# Call Handling & Routing

Implement intelligent call handling with Skaala's AI receptionist.

## Overview

Skaala provides flexible call routing to ensure customers reach the right destination:

* **Smart Routing**: Route based on intent, time, or customer data
* **Overflow Handling**: Fallback options when agents unavailable
* **Business Hours**: Different routing for office hours vs after-hours
* **VIP Treatment**: Priority routing for high-value customers

## Call Flow Architecture

```mermaid theme={null}
graph TD
    A[Incoming Call] --> B{Business Hours?}
    B -->|Yes| C{Intent Detection}
    B -->|No| D[After-Hours Message]
    C -->|Booking| E[Check Availability]
    C -->|Question| F[Knowledge Base]
    C -->|Complaint| G[Transfer to Manager]
    E -->|Available| H[Book Appointment]
    E -->|Unavailable| I[Suggest Alternatives]
    F -->|Answered| J[End Call]
    F -->|Unclear| G
```

## Basic Call Routing

### Business Hours Configuration

```json theme={null}
{
  "business_hours": {
    "monday": { "start": "09:00", "end": "17:00" },
    "tuesday": { "start": "09:00", "end": "17:00" },
    "wednesday": { "start": "09:00", "end": "17:00" },
    "thursday": { "start": "09:00", "end": "17:00" },
    "friday": { "start": "09:00", "end": "17:00" },
    "saturday": { "start": "10:00", "end": "14:00" },
    "sunday": "closed"
  },
  "timezone": "Europe/Stockholm"
}
```

### After-Hours Handling

<Tabs>
  <Tab title="Voicemail">
    Record message and create ticket

    ```javascript theme={null}
    {
      "after_hours_action": "voicemail",
      "voicemail_prompt": "We're currently closed. Please leave a message.",
      "notify_email": "support@example.com"
    }
    ```
  </Tab>

  <Tab title="Emergency Transfer">
    Route urgent calls to on-call staff

    ```javascript theme={null}
    {
      "after_hours_action": "emergency_transfer",
      "emergency_number": "+46701234567",
      "emergency_prompt": "For emergencies, I'll connect you now."
    }
    ```
  </Tab>

  <Tab title="Automated Booking">
    Allow self-service booking 24/7

    ```javascript theme={null}
    {
      "after_hours_action": "booking_only",
      "booking_prompt": "I can help you schedule an appointment."
    }
    ```
  </Tab>
</Tabs>

## Advanced Routing

### Intent-Based Routing

Route calls based on detected customer intent:

```javascript theme={null}
const routingRules = {
  "sales_inquiry": {
    action: "transfer",
    number: "+46701111111",
    message: "Let me connect you with sales"
  },
  "technical_support": {
    action: "transfer",
    number: "+46702222222",
    priority: "high"
  },
  "booking": {
    action: "ai_handle",
    tools: ["calendar", "booking"]
  },
  "general_question": {
    action: "ai_handle",
    tools: ["knowledge_base"]
  }
};
```

### Customer-Based Routing

<AccordionGroup>
  <Accordion title="VIP Customers">
    Detect VIP customers by phone number and provide priority service

    ```javascript theme={null}
    if (customer.tier === 'vip') {
      return {
        greeting: "Welcome back, valued customer",
        wait_time: 0,
        transfer_priority: "immediate"
      };
    }
    ```
  </Accordion>

  <Accordion title="Returning Customers">
    Recognize returning customers and personalize greeting

    ```javascript theme={null}
    if (customer.previous_calls > 0) {
      return {
        greeting: `Welcome back! I see you called about ${lastTopic}`,
        context: customer.history
      };
    }
    ```
  </Accordion>
</AccordionGroup>

## Call Analytics

Track and optimize call performance:

<CardGroup>
  <Card title="Call Volume" icon="chart-line">
    Monitor peak hours and staffing needs
  </Card>

  <Card title="Resolution Rate" icon="check-circle">
    Track % of calls handled by AI vs transferred
  </Card>

  <Card title="Wait Times" icon="clock">
    Measure average hold and response times
  </Card>

  <Card title="Customer Satisfaction" icon="star">
    Post-call surveys and feedback
  </Card>
</CardGroup>

## Webhook Integration

React to call events in real-time:

```javascript theme={null}
app.post('/webhooks/skaala', async (req, res) => {
  const { event, data } = req.body;

  switch (event) {
    case 'call.started':
      // Log call initiation
      await logCall(data.call_id, data.from);
      break;

    case 'call.transferred':
      // Notify agent of incoming transfer
      await notifyAgent(data.agent_id, data.call_context);
      break;

    case 'call.completed':
      // Update CRM with call summary
      await updateCRM(data.contact_id, data.summary);
      break;
  }

  res.status(200).send('OK');
});
```

## Best Practices

<Warning>
  Test your routing rules thoroughly before deploying to production
</Warning>

<Steps>
  <Step title="Map Customer Journeys">
    Document all possible call paths and outcomes
  </Step>

  <Step title="Set Fallback Rules">
    Always have a default route for unexpected scenarios
  </Step>

  <Step title="Monitor & Optimize">
    Review call analytics weekly and adjust routing
  </Step>

  <Step title="Train Staff">
    Ensure human agents understand AI handoff process
  </Step>
</Steps>

## Related Resources

<CardGroup>
  <Card title="Calls API" icon="phone" href="/api-reference/calls/list-calls">
    Programmatic call management
  </Card>

  <Card title="Webhooks" icon="webhook" href="/guides/webhooks">
    Real-time call event notifications
  </Card>
</CardGroup>


# Webhooks
Source: https://docs.skaala.ai/guides/webhooks

Set up real-time notifications for booking events, call completions, and more

# Webhooks

Webhooks allow you to receive real-time HTTP notifications when events occur in your Skaala account.

<Info>
  **Coming Soon**: Detailed webhook documentation is being prepared. For now, check the API Reference for webhook endpoints.
</Info>

## Quick Start

```bash theme={null}
curl -X POST https://www.skaala.ai/api/v1/webhooks \
  -H "X-API-Key: sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.com/webhooks/skaala",
    "events": ["booking.created", "booking.cancelled"]
  }'
```

## Available Events

* `booking.created` - New booking created
* `booking.updated` - Booking modified
* `booking.cancelled` - Booking cancelled
* `call.completed` - Call finished
* `contact.created` - New contact added

## Next Steps

<CardGroup>
  <Card title="API Reference" icon="book" href="/api-reference/webhooks/create-webhooks">
    View webhook endpoints
  </Card>

  <Card title="Security" icon="shield" href="/guides/webhooks#security">
    Verify webhook signatures
  </Card>
</CardGroup>


# Stripe Integration
Source: https://docs.skaala.ai/integrations/stripe

Payment processing and subscription management

# Stripe Integration

Skaala uses Stripe for secure payment processing, subscription management, and billing.

<Info>
  Stripe handles all payment data securely. Skaala never stores credit card information.
</Info>

## Subscription Plans

### Available Plans

<Tabs>
  <Tab title="Starter">
    **Free Trial (14 days)**

    * 100 minutes of AI calls
    * 1 phone number
    * Basic analytics
    * Email support
  </Tab>

  <Tab title="Professional">
    **299 SEK/month**

    * 500 minutes of AI calls
    * 3 phone numbers
    * Advanced analytics
    * Priority support
    * Custom voice training
  </Tab>

  <Tab title="Enterprise">
    **Custom pricing**

    * Unlimited minutes
    * Unlimited phone numbers
    * Dedicated account manager
    * Custom integrations
    * SLA guarantee
  </Tab>
</Tabs>

### Usage-Based Billing

Additional usage beyond plan limits:

| Item                    | Price            |
| ----------------------- | ---------------- |
| AI call minutes         | 1.50 SEK/minute  |
| Additional phone number | 50 SEK/month     |
| SMS messages            | 0.50 SEK/message |
| Call recording storage  | 10 SEK/GB/month  |

## Payment Methods

Accepted payment methods:

* ✅ Credit cards (Visa, Mastercard, Amex)
* ✅ Debit cards
* ✅ SEPA Direct Debit (EU)
* ✅ Invoice (Enterprise plan only)

## Billing Dashboard

Manage billing at `https://www.skaala.ai/dashboard/billing`

### View Usage

```javascript theme={null}
// Example: Fetch current billing period usage
const response = await fetch('https://www.skaala.ai/api/v1/billing/usage', {
  headers: {
    'X-API-Key': process.env.SKAALA_API_KEY
  }
});

const data = await response.json();
console.log('Minutes used:', data.minutes_used);
console.log('Current charges:', data.estimated_charges, 'SEK');
```

### Update Payment Method

<Steps>
  <Step title="Navigate to Billing">
    Go to dashboard → Settings → Billing
  </Step>

  <Step title="Add Payment Method">
    Click "Update payment method"
  </Step>

  <Step title="Enter Card Details">
    Securely enter card information (handled by Stripe)
  </Step>

  <Step title="Confirm">
    New payment method saved and set as default
  </Step>
</Steps>

## Webhooks

Receive billing event notifications:

```javascript theme={null}
app.post('/webhooks/stripe', async (req, res) => {
  const event = req.body;

  switch (event.type) {
    case 'invoice.payment_succeeded':
      // Payment successful
      console.log('Payment received:', event.data.object.amount_paid);
      break;

    case 'invoice.payment_failed':
      // Payment failed - notify customer
      await sendPaymentFailureEmail(event.data.object.customer);
      break;

    case 'customer.subscription.deleted':
      // Subscription cancelled
      await deactivateAccount(event.data.object.customer);
      break;
  }

  res.status(200).send('OK');
});
```

## Invoices

### Download Invoices

Access all past invoices in the billing dashboard:

* PDF downloads
* Itemized usage breakdown
* Payment history
* Tax information

### Automatic Invoicing

Invoices are generated automatically:

* **Monthly subscriptions**: 1st of each month
* **Usage overages**: Included in monthly invoice
* **Enterprise invoices**: Custom NET-30 terms

## Tax Compliance

<Info>
  VAT is automatically calculated based on your business location
</Info>

| Region     | Tax            |
| ---------- | -------------- |
| Sweden     | 25% VAT        |
| Norway     | 25% VAT        |
| EU (other) | Local VAT rate |
| Non-EU     | No VAT         |

## Cancellation

Cancel anytime with no penalties:

<Warning>
  Cancellation takes effect at the end of current billing period
</Warning>

<Steps>
  <Step title="Navigate to Billing">
    Dashboard → Settings → Billing
  </Step>

  <Step title="Cancel Subscription">
    Click "Cancel subscription"
  </Step>

  <Step title="Confirm Cancellation">
    Provide feedback (optional)
  </Step>

  <Step title="Final Invoice">
    Receive final invoice for current period
  </Step>
</Steps>

## Related Resources

<CardGroup>
  <Card title="Pricing" icon="dollar-sign" href="https://www.skaala.ai/pricing">
    View current pricing plans
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/bookings/list-bookings">
    Programmatic billing access
  </Card>
</CardGroup>


# Zapier Integration
Source: https://docs.skaala.ai/integrations/zapier

Connect Skaala with 5,000+ apps using Zapier automation

# Zapier Integration

Automate workflows by connecting Skaala with thousands of apps through Zapier.

<Info>
  Skaala's Zapier integration is in beta. Request early access at [support@skaala.ai](mailto:support@skaala.ai)
</Info>

## Overview

Connect Skaala to popular apps:

* **CRM**: HubSpot, Salesforce, Pipedrive
* **Calendar**: Google Calendar, Outlook, Calendly
* **Communication**: Slack, Microsoft Teams, Discord
* **Email**: Gmail, SendGrid, Mailchimp
* **Spreadsheets**: Google Sheets, Airtable, Notion

## Triggers

Skaala events that can start a Zap:

### New Booking

```javascript theme={null}
{
  "trigger": "booking.created",
  "data": {
    "id": "bkg_abc123",
    "customer_name": "John Doe",
    "customer_phone": "+46701234567",
    "service": "Haircut",
    "start_time": "2025-01-15T10:00:00Z",
    "created_at": "2025-01-10T14:30:00Z"
  }
}
```

**Example Zaps:**

* Create Google Calendar event
* Add contact to CRM
* Send confirmation email via Gmail
* Log to Google Sheets

### Cancelled Booking

```javascript theme={null}
{
  "trigger": "booking.cancelled",
  "data": {
    "id": "bkg_abc123",
    "cancelled_at": "2025-01-12T09:15:00Z",
    "cancellation_reason": "Customer request"
  }
}
```

**Example Zaps:**

* Notify team in Slack
* Update CRM opportunity status
* Send cancellation email

### Call Completed

```javascript theme={null}
{
  "trigger": "call.completed",
  "data": {
    "id": "call_xyz789",
    "duration_seconds": 180,
    "summary": "Customer inquired about pricing",
    "outcome": "booking_created",
    "recording_url": "https://..."
  }
}
```

**Example Zaps:**

* Transcribe call with AssemblyAI
* Create task in Asana
* Log to Notion database

### New Contact

```javascript theme={null}
{
  "trigger": "contact.created",
  "data": {
    "id": "cnt_def456",
    "name": "Jane Smith",
    "phone": "+46709876543",
    "email": "jane@example.com",
    "source": "inbound_call"
  }
}
```

**Example Zaps:**

* Add to email marketing list (Mailchimp, SendGrid)
* Create HubSpot contact
* Send welcome email via Gmail

## Actions

Use Skaala actions in your Zaps:

### Create Booking

```javascript theme={null}
{
  "action": "create_booking",
  "input": {
    "service_id": "svc_abc123",
    "customer_name": "{{trigger.name}}",
    "customer_phone": "{{trigger.phone}}",
    "start_time": "{{trigger.selected_time}}"
  }
}
```

**Example workflows:**

* Create booking from Calendly event
* Book appointment from form submission
* Schedule follow-up from CRM task

### Send SMS

```javascript theme={null}
{
  "action": "send_sms",
  "input": {
    "to": "{{trigger.phone}}",
    "message": "Your appointment is tomorrow at {{booking.time}}"
  }
}
```

**Example workflows:**

* Send reminder 24h before booking
* Notify customer of status change
* Send promotional offers

## Example Zaps

### 1. New Booking → Create Calendar Event + Send Email

<Steps>
  <Step title="Trigger: New Booking in Skaala">
    When a booking is created
  </Step>

  <Step title="Action: Create Google Calendar Event">
    Add appointment to calendar
  </Step>

  <Step title="Action: Send Email via Gmail">
    Send confirmation email to customer
  </Step>

  <Step title="Action: Post to Slack">
    Notify team in #bookings channel
  </Step>
</Steps>

### 2. Form Submission → Create Contact + Book Appointment

<Steps>
  <Step title="Trigger: New Typeform Response">
    Customer submits booking request form
  </Step>

  <Step title="Action: Create Contact in Skaala">
    Add customer details to CRM
  </Step>

  <Step title="Action: Create Booking in Skaala">
    Book appointment from form data
  </Step>

  <Step title="Action: Send SMS via Skaala">
    Send booking confirmation
  </Step>
</Steps>

### 3. Call Completed → Log to CRM + Create Task

<Steps>
  <Step title="Trigger: Call Completed in Skaala">
    AI call finishes
  </Step>

  <Step title="Action: Update HubSpot Contact">
    Log call notes and outcome
  </Step>

  <Step title="Action: Create Asana Task">
    Create follow-up task if needed
  </Step>
</Steps>

## Setup Instructions

<Steps>
  <Step title="Connect Skaala Account">
    In Zapier, search for Skaala and click "Connect"
  </Step>

  <Step title="Enter API Key">
    Get your API key from Skaala dashboard → Settings → API Keys
  </Step>

  <Step title="Test Connection">
    Zapier will verify your credentials
  </Step>

  <Step title="Create Your First Zap">
    Choose trigger and actions to automate your workflow
  </Step>
</Steps>

## Best Practices

<AccordionGroup>
  <Accordion title="Use Filters to Reduce Zap Runs">
    Add filters to only process specific events (e.g., bookings over \$500)
  </Accordion>

  <Accordion title="Add Delays for Sequential Actions">
    Use Zapier's delay feature for time-sensitive workflows
  </Accordion>

  <Accordion title="Test Thoroughly Before Enabling">
    Run test Zaps to verify data mapping is correct
  </Accordion>

  <Accordion title="Monitor Zap History">
    Check Zapier task history for errors and troubleshooting
  </Accordion>
</AccordionGroup>

## Troubleshooting

### Zap Not Triggering

* Verify webhook is active in Skaala dashboard
* Check API key has correct permissions
* Ensure event type matches trigger configuration

### Data Mapping Issues

* Use Zapier's formatter to transform data types
* Add custom JavaScript code for complex transformations
* Test with sample data before going live

## Advanced: Zapier MCP Agent Integration

<Info>
  **What's This?** Your Skaala AI agent can actually trigger Zapier automations DURING phone conversations! This is an advanced feature that lets your AI do powerful actions while talking to customers.
</Info>

### How It Works

When properly configured, your AI agent can:

* Trigger specific Zaps during conversations
* Pass information from the call into automation workflows
* Take actions based on what the customer says
* Update multiple systems in real-time

**Example Scenario:**

```
Customer: "Can you add me to your VIP customer list?"
AI: "Absolutely! I'm adding you right now."
→ AI triggers Zap that:
  1. Tags contact as "VIP" in CRM
  2. Adds to exclusive email list
  3. Sends notification to sales team
  4. Updates loyalty program database
AI: "Done! You'll get our VIP newsletter starting next week."
```

### What the AI Agent Can Do with Zapier

<AccordionGroup>
  <Accordion title="Customer Information Management">
    * Add contacts to email marketing lists during calls
    * Update CRM records with conversation details
    * Create tasks for follow-up based on customer requests
    * Tag customers based on conversation topics
  </Accordion>

  <Accordion title="Real-Time Notifications">
    * Notify your team in Slack when VIP customer calls
    * Alert manager when booking value exceeds threshold
    * Create support tickets from customer complaints
    * Send SMS to technician when urgent service requested
  </Accordion>

  <Accordion title="Data Logging & Analytics">
    * Log call outcomes to Google Sheets
    * Track lead sources in Airtable
    * Update Notion databases with customer insights
    * Record interaction details in Monday.com
  </Accordion>

  <Accordion title="Multi-System Updates">
    * Book appointment in external scheduling system
    * Create invoice in accounting software
    * Update inventory when service is booked
    * Log lead in multiple CRM systems simultaneously
  </Accordion>
</AccordionGroup>

### Setting Up AI-Triggered Zaps

<Steps>
  <Step title="Create a Webhook Zap">
    In Zapier, create a Zap that starts with "Webhooks by Zapier" trigger
  </Step>

  <Step title="Get Webhook URL">
    Zapier will provide a unique webhook URL
  </Step>

  <Step title="Configure in Skaala">
    In your dashboard, go to Settings → Integrations → Zapier MCP
    Add the webhook URL and name the action (e.g., "add\_to\_vip\_list")
  </Step>

  <Step title="Train Your AI">
    In AI Assistant settings, tell the AI when to trigger this Zap:
    "When customer asks to join VIP program, trigger add\_to\_vip\_list"
  </Step>

  <Step title="Test It">
    Call your number and test the trigger phrase
  </Step>
</Steps>

### Example Use Cases

<CardGroup>
  <Card title="Priority Customer Routing" icon="star">
    **Trigger**: Customer identifies as existing VIP

    **Zap Actions**:

    * Check VIP status in CRM
    * Notify account manager via Slack
    * Flag call for priority callback if AI can't help
  </Card>

  <Card title="Lead Capture & Distribution" icon="users">
    **Trigger**: Customer asks about enterprise services

    **Zap Actions**:

    * Create lead in Salesforce
    * Add to enterprise email sequence
    * Assign to sales rep based on territory
    * Schedule discovery call
  </Card>

  <Card title="Inventory Management" icon="box">
    **Trigger**: Customer books service requiring specific equipment

    **Zap Actions**:

    * Check inventory in Airtable
    * Reserve equipment for booking time
    * Create purchase order if stock low
    * Notify warehouse team
  </Card>

  <Card title="Emergency Escalation" icon="bell">
    **Trigger**: Customer mentions urgent problem or keyword

    **Zap Actions**:

    * Create high-priority ticket in Help Scout
    * Send SMS to on-call technician
    * Post in #emergencies Slack channel
    * Log incident in PagerDuty
  </Card>
</CardGroup>

### Best Practices for AI-Triggered Zaps

<AccordionGroup>
  <Accordion title="Keep Triggers Simple">
    Don't create too many triggers - it confuses the AI. Limit to 3-5 key automations.
  </Accordion>

  <Accordion title="Use Clear Trigger Names">
    Name triggers descriptively: "add\_to\_vip\_list" not "zap1". AI uses these names to understand what to do.
  </Accordion>

  <Accordion title="Test Thoroughly">
    Call your number and test each trigger multiple times with different phrasings to ensure AI recognizes them.
  </Accordion>

  <Accordion title="Monitor Zap History">
    Regularly check Zapier task history to ensure automations are working correctly and not triggering unexpectedly.
  </Accordion>

  <Accordion title="Add Failsafes">
    Include filters in your Zaps to prevent actions if critical data is missing (e.g., don't add to email list without email address).
  </Accordion>
</AccordionGroup>

### Troubleshooting AI-Triggered Zaps

<AccordionGroup>
  <Accordion title="AI isn't triggering the Zap">
    **Possible causes:**

    * Trigger phrase too complex or ambiguous
    * AI not properly trained on when to use it
    * Webhook URL incorrect or expired

    **Solution:** Simplify trigger phrase, retrain AI with more examples, verify webhook URL
  </Accordion>

  <Accordion title="Zap triggers at wrong times">
    **Possible causes:**

    * Trigger phrase too generic (e.g., "help")
    * Multiple similar triggers confusing AI

    **Solution:** Make trigger phrases more specific and distinct from each other
  </Accordion>

  <Accordion title="Data not passing correctly">
    **Possible causes:**

    * Field mapping errors
    * AI not extracting data correctly

    **Solution:** Use Zapier's formatter to handle data transformation, add more structure to what AI should capture
  </Accordion>
</AccordionGroup>

***

## Related Resources

<CardGroup>
  <Card title="Webhooks Guide" icon="webhook" href="/guides/webhooks">
    Direct webhook integration for real-time events
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/bookings/list-bookings">
    Build custom integrations with our REST API
  </Card>

  <Card title="AI Assistant Guide" icon="robot" href="/guides/dashboard-overview#ai-assistant-configuration">
    Learn how to configure your AI's capabilities
  </Card>
</CardGroup>

## Need Help Setting This Up?

The Zapier MCP integration is powerful but can be complex. Our support team can help you design and implement the perfect automation workflows for your business.

**Contact us**: [support@skaala.ai](mailto:support@skaala.ai) or chat in your dashboard