# Access Code
Source: https://docs.calstudio.com/account/access-code

Restrict access to your AI app with an access code

Restrict access to your AI app by setting up an access code. This feature allows you to control who can use your app without requiring full user authentication.

## Setting Up an Access Code

1. Open your app in the editor
2. Navigate to the **More** tab
3. Enter your desired access code in the "Access Code" field
4. Save your changes

<img alt="Access Code Configuration" />

When someone tries to access your app, they'll need to enter the code to proceed. Leave the access code field blank for unrestricted access.

<Tip>
  Access codes are great for beta testing, exclusive communities, or paid access outside of the built-in payment system.
</Tip>

## Revoking User Access

You can revoke access for individual users through the App Analytics dashboard:

1. Go to your app's **Analytics** section
2. Click on **Manage Users**
3. Find the user whose access you want to revoke
4. Click **Revoke Access** next to their email

<img alt="Revoke User Access" />

<Warning>
  Revoking access is immediate. The user will no longer be able to use your app until you restore their access or they re-authenticate.
</Warning>


# API Reference
Source: https://docs.calstudio.com/account/api-reference

How to generate and use your own API key

## API Key

An API Key is a unique identifier used to authenticate requests made from your application to CalStudio APIs.
Think of it as a secure access badge that allows your application to use CalStudio’s services safely.

At CalStudio we allow you to use our APIs using the API keys that we generate for you.

### Creating Your API Keys

You can generate and manage your API keys directly from your CalStudio Dashboard.
Steps to Create an API Key:

1. Log in or Sign up

   * Visit calstudio.com and log in with your credentials.

   * If you don’t have an account, sign up to access the dashboard.

2. Navigate to API Keys Section

   * On the left-hand sidebar of the dashboard, locate and click on API Keys.

3. Generate a New Key

   * Click the Create API Key button.

   * Provide a label or description (optional, but recommended to help you identify usage).

   * Your new API key will be generated instantly.

4. Copy and Store Securely

   * Copy the key and keep it in a secure location.

### Best Practices for Using API Keys

* Keep it secret → Never share your key publicly (e.g., GitHub, client-side code).

* Restrict usage → Apply restrictions (IP, domain, or service-level) when possible.

* Rotate regularly → Regenerate keys periodically and update your applications.

* Revoke if compromised → Immediately delete and regenerate your key if you suspect unauthorized use.

<img alt="Main dashboard interface" />

### How to use your API Key

Make POST requests to [https://calstudio.com/getbackResponse](https://calstudio.com/getbackResponse) with the following parameters in the request body:

* prompt: Your input text
* apiKey: Your API key
* appName: Name of your app
* fileUrl (optional): URL to a file (image, PDF, or other document) for the AI to analyze. Only one file per request is supported.

<CodeGroup>
  ```javascript NodeJS theme={null}
  const axios = require("axios");

  async function getAppResponse() {
    try {
      const response = await axios.post("https://calstudio.com/getbackResponse", {
        prompt: "Hello, how are you?",
        apiKey: "your_api_key_here",
        appName: "your_app_name", // replace with your app name
      });

      console.log(response.data);
      // {
      //   message: "App's response",
      //   status: 200,
      //   success: true
      // }
    } catch (error) {
      console.error("Error:", error);
    }
  }
  ```

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

  def get_app_response():
      try:
          response = requests.post(
              'https://calstudio.com/getbackResponse',
              json={
                  'prompt': 'Hello, how are you?',
                  'apiKey': 'your_api_key_here',
                  'appName': 'your_app_name' // replace with your app name
              }
          )
          print(response.json())
      except Exception as e:
          print('Error:', str(e))
  ```

  ```java Java theme={null}
  public class AppRequest {
      public static void main(String[] args) {
          OkHttpClient client = new OkHttpClient();

          MediaType mediaType = MediaType.parse("application/json");
          String json = "{"
                  + "\"prompt\":\"Hello, how are you?\","
                  + "\"apiKey\":\"your_api_key_here\","
                  + "\"appName\":\"your_app_name\""
                  + "}";

          RequestBody body = RequestBody.create(json, mediaType);

          Request request = new Request.Builder()
                  .url("https://calstudio.com/getbackResponse")
                  .post(body)
                  .addHeader("Content-Type", "application/json")
                  .build();

          try (Response response = client.newCall(request).execute()) {
              System.out.println(response.body().string());
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
  ```

  ```ruby Ruby on Rails theme={null}
  require 'httparty'

  response = HTTParty.post(
    'https://calstudio.com/getbackResponse',
    headers: { 'Content-Type' => 'application/json' },
    body: {
      prompt: 'Hello, how are you?',
      apiKey: 'your_api_key_here',
      appName: 'your_app_name'
    }.to_json
  )

  puts response.body

  ```

  ```go Go theme={null}
  package main

  import (
  	"bytes"
  	"fmt"
  	"io/ioutil"
  	"net/http"
  )

  func main() {
  	url := "https://calstudio.com/getbackResponse"
  	jsonData := []byte(`{
  		"prompt": "Hello, how are you?",
  		"apiKey": "your_api_key_here",
  		"appName": "your_app_name"
  	}`)

  	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  	if err != nil {
  		panic(err)
  	}

  	req.Header.Set("Content-Type", "application/json")

  	client := &http.Client{}
  	resp, err := client.Do(req)
  	if err != nil {
  		panic(err)
  	}
  	defer resp.Body.Close()

  	body, _ := ioutil.ReadAll(resp.Body)
  	fmt.Println(string(body))
  }


  ```
</CodeGroup>

## Working with files

You can provide file URLs in your API requests to have the AI analyze images, PDFs, and other documents. Simply include the fileUrl parameter with a valid, publicly accessible URL to your file. Note: Only one file per request is supported.

<CodeGroup>
  ```javascript NodeJS theme={null}
  const axios = require("axios");

  async function getAppResponseWithFile() {
    try {
      const data = {
        prompt: "What does this image show?",
        apiKey: "your_api_key_here",
        appName: "your_app_name",
        fileUrl: "https://example.com/path/to/your/image.jpg",
      };

      const response = await axios.post(
        "https://calstudio.com/getbackResponse",
        data
      );

      console.log(response.data);
      // {
      //   message: "App's response about the image",
      //   status: 200,
      //   success: true
      // }
    } catch (error) {
      console.error("Error:", error);
    }
  }
  ```

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

  def get_app_response_with_file():
      try:
          # Create request data with file URL
          data = {
              'prompt': 'What does this image show?',
              'apiKey': 'your_api_key_here',
              'appName': 'your_app_name',
              'fileUrl': 'https://example.com/path/to/your/image.jpg'
          }

          # Make the request with data including file URL
          response = requests.post(
              'https://calstudio.com/getbackResponse',
              json=data
          )

          print(response.json())
          # {
          #   "message": "App's response about the image",
          #   "status": 200,
          #   "success": true
          # }
      except Exception as e:
          print('Error:', str(e))

  ```

  ```ruby Ruby on Rails theme={null}
  require 'httparty'

  class AppResponsesController < ApplicationController
    include HTTParty
    base_uri "https://calstudio.com"

    def get_app_response_with_file
      response = self.class.post(
        "/getbackResponse",
        body: {
          prompt: "What does this image show?",
          apiKey: "your_api_key_here",
          appName: "your_app_name",
          fileUrl: "https://example.com/path/to/your/image.jpg"
        }.to_json,
        headers: { "Content-Type" => "application/json" }
      )

      render json: {
        status: response.code,
        body: response.parsed_response
      }
    rescue => e
      render json: { error: e.message }, status: 500
    end
  end

  ```

  ```go Go theme={null}
  package main

  import (
  	"bytes"
  	"encoding/json"
  	"fmt"
  	"io/ioutil"
  	"net/http"
  )

  func getAppResponseWithFile() {
  	// Request payload
  	data := map[string]string{
  		"prompt":  "What does this image show?",
  		"apiKey":  "your_api_key_here",
  		"appName": "your_app_name",
  		"fileUrl": "https://example.com/path/to/your/image.jpg",
  	}

  	// Convert map to JSON
  	jsonData, err := json.Marshal(data)
  	if err != nil {
  		fmt.Println("Error encoding JSON:", err)
  		return
  	}

  	// Make POST request
  	resp, err := http.Post("https://calstudio.com/getbackResponse",
  		"application/json", bytes.NewBuffer(jsonData))
  	if err != nil {
  		fmt.Println("Error making request:", err)
  		return
  	}
  	defer resp.Body.Close()

  	// Read response
  	body, err := ioutil.ReadAll(resp.Body)
  	if err != nil {
  		fmt.Println("Error reading response:", err)
  		return
  	}

  	fmt.Println("Response:", string(body))
  }

  func main() {
  	getAppResponseWithFile()
  }


  ```
</CodeGroup>


# Custom Domain
Source: https://docs.calstudio.com/account/custom-domain

Connect your AI apps to your own domain for professional branding

<Info>
  Custom domains allow you to publish your CalStudio AI apps and App Studios on your own branded domain, providing a seamless experience for your users without any CalStudio branding.
</Info>

## Overview

Custom domains solve a major limitation of AI chatbots - the ability to share and deploy them on your own website. With CalStudio, you can:

* Host your AI apps on your own domain (e.g., `yourdomain.com` or `chat.yourdomain.com`)
* Share your apps publicly without requiring user sign-ups
* Maintain complete brand consistency
* Build trust with professional URLs
* Improve SEO and discoverability
* Embed apps directly on your existing website

## Prerequisites

Before setting up a custom domain, ensure you have:

<CardGroup>
  <Card title="CalStudio Pro Plan" icon="credit-card">
    Custom domains are available on Pro plans and above
  </Card>

  <Card title="Domain Ownership" icon="globe">
    A registered domain with DNS management access
  </Card>
</CardGroup>

## Step-by-Step Setup Process

### Step 1: Sign Up and Access Dashboard

1. Sign up on the [CalStudio platform](https://calstudio.com/)
2. Once signed up, you'll see your dashboard

### Step 2: Create Your AI App

1. Click on the **"Create App"** button in your dashboard
2. Fill out the app creation form with:
   * **App Name**: Choose a descriptive name
   * **Description**: Brief explanation of your app's purpose
   * **AI Model**: Select your preferred model (GPT-4, GPT-3.5, Claude, etc.)
   * **System Prompt**: Define your AI's behavior and personality
   * **Knowledge Base**: Optionally upload files for your AI to reference
3. Click **"Create App"** to generate your AI application

### Step 3: Test and Launch Your App

1. Test your app thoroughly using the built-in chat interface
2. Make any necessary adjustments to the prompt or settings
3. When satisfied, click **"Launch"** to make it publicly available

### Step 4: Publish to Custom Domain

1. In your app's dashboard, find the **Status** row
2. Click on the **"Publish"** option
3. Select **"Custom Domain"** from the publishing options
4. Enter your desired domain:
   * **Root domain**: `yourdomain.com`
   * **Subdomain**: `app.yourdomain.com` or `chat.yourdomain.com`

### Step 5: Configure DNS Settings

CalStudio will provide DNS records based on your domain type:

<Tabs>
  <Tab title="Subdomain (Recommended)">
    For subdomains like `chat.yourdomain.com`:

    1. **You'll receive a CNAME record** from CalStudio
    2. Add this record to your DNS provider:
       ```
       Type: CNAME
       Name: chat (or your chosen subdomain)
       Value: [provided-by-calstudio].calstudio.app
       TTL: 3600 (or default)
       ```
    3. Save your DNS changes

    <Note>
      Subdomains are easier to configure and don't affect your main website or email settings.
    </Note>
  </Tab>

  <Tab title="Root Domain">
    For root domains like `yourdomain.com`:

    1. **You'll receive NS (Name Server) records** from CalStudio
    2. These will be AWS Route 53 nameservers (not CalStudio nameservers)
    3. At your domain registrar, update your nameservers to the provided AWS records, which typically look like:
       ```
       ns-1234.awsdns-12.org
       ns-5678.awsdns-34.co.uk
       ns-9012.awsdns-56.com
       ns-3456.awsdns-78.net
       ```
    4. This process can take 24-48 hours to propagate globally

    <Warning>
      NS delegation affects your entire domain. All existing DNS records (including email, subdomains, etc.) will need to be recreated in the new DNS system. Consider using a subdomain instead if you have existing services on your root domain.
    </Warning>
  </Tab>
</Tabs>

### Step 6: Verify Deployment

1. **Wait for DNS propagation** (usually 5-30 minutes for CNAME, up to 48 hours for NS)
2. Visit your custom domain
3. Your AI app should now be live!

<Tip>
  Use [DNS Checker](https://dnschecker.org) to verify your DNS records have propagated globally.
</Tip>

## Visual Walkthrough

<Note>
  Follow these step-by-step instructions to publish your Custom GPT to a custom domain using CalStudio.
</Note>

### 1. Sign Up on CalStudio

Navigate to [CalStudio](https://calstudio.com/) and create your account to get started.

![CalStudio Homepage](https://miro.medium.com/v2/resize:fit:1400/format:webp/0*uHJLvKetzJvffIZD.png)

### 2. Create Your App

Once you have signed up, click on the "Create App" button in your dashboard.

![CalStudio Dashboard](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*HCa_DcwIkyoGtln0SfEtSw.png)

### 3. Configure Your AI App

Fill out the form with the necessary details:

* Select the AI model of your choice (GPT-4, GPT-3.5, Claude, etc.)
* Add a name and description
* Define the system prompt
* Optionally, add a knowledge base for your AI bot

![Create App Form](https://miro.medium.com/v2/resize:fit:1400/format:webp/0*Ti6zqt58jBZjPr76.png)

### 4. Test and Launch

Click on "Create App" and you'll have your Custom GPT app created in the dashboard. Test this app and launch it, making it available to anyone publicly.

![App Dashboard](https://miro.medium.com/v2/resize:fit:1400/format:webp/0*2sajd4pZE3gAeYWh.png)

### 5. Publish to Custom Domain

To publish the app on a custom domain, click on the Publish option under the status row:

<img alt="CalStudio Publish Modal" />

Select "Custom Domain" to publish it to a custom domain. You'll then need to provide the domain name:

<img alt="CalStudio Custom Domain Input" />

### 6. Configure DNS Records

After entering your domain, you'll receive DNS records to configure:

#### For Subdomains

When publishing to a subdomain (e.g., `app.yourdomain.com`), you'll receive two CNAME records:

<img alt="CalStudio Subdomain DNS Records Example" />

**Example records you'll receive:**

1. **SSL Certificate Validation Record**:
   * This CNAME record is required for SSL certificate validation
   * It will have a long, unique name starting with an underscore
   * The value points to AWS Certificate Manager for validation

2. **Website CNAME Record**:
   * This points your subdomain to your CalStudio app
   * Name: Your chosen subdomain (e.g., `app.yourdomain.com`)
   * Value: An AWS load balancer URL

**Important:** After adding these records, your website will be available at your custom domain. The first CNAME record is specifically for SSL certificate validation.

#### For Root Domains

Root domains will receive NS (nameserver) records as described in the DNS settings section above.

## Video Tutorial

<Info>
  For a detailed video walkthrough of the custom domain setup process, watch this [helpful tutorial](https://youtu.be/z2jqALQbSbk).
</Info>

## Studio Custom Domains

<Info>
  Studios can also be published to custom domains, allowing you to create your own AI marketplace under your branded domain. For the full step-by-step guide, see the dedicated [Custom Domain for Studios](/account/studio-custom-domain) page.
</Info>

## SSL Certificates

<Check>
  CalStudio automatically provisions and manages SSL certificates for all custom domains using AWS Certificate Manager. Your app will be served securely over HTTPS.
</Check>

## Best Practices

<CardGroup>
  <Card title="Use Subdomains" icon="sitemap">
    Subdomains are easier to manage and don't affect your main website
  </Card>

  <Card title="Test First" icon="flask">
    Thoroughly test your app before connecting a production domain
  </Card>

  <Card title="Monitor Uptime" icon="chart-line">
    Set up monitoring to ensure your custom domain stays accessible
  </Card>

  <Card title="Keep Records" icon="clipboard">
    Document your DNS configuration for future reference
  </Card>
</CardGroup>

## How to Add CNAME Records

Here's how to add the two CNAME records in popular DNS providers:

<AccordionGroup>
  <Accordion title="Cloudflare">
    1. Log in to Cloudflare dashboard
    2. Select your domain
    3. Go to **DNS** → **Records**
    4. Click **Add record**

    **For the SSL validation record:**

    * Type: CNAME
    * Name: Paste the long underscore name (e.g., `_ce016fc2...`)
    * Target: Paste the AWS validation value
    * Proxy status: **DNS only** (gray cloud)
    * TTL: Auto

    **For the subdomain record:**

    * Type: CNAME
    * Name: Your subdomain (e.g., `app`)
    * Target: Paste the AWS load balancer URL
    * Proxy status: **DNS only** (gray cloud)
    * TTL: Auto
  </Accordion>

  <Accordion title="GoDaddy">
    1. Sign in to GoDaddy Domain Control Center
    2. Select your domain
    3. Click **DNS** → **Manage DNS**
    4. Click **ADD** under records

    **For each CNAME record:**

    * Type: CNAME
    * Host: The record name (remove your domain from the end if GoDaddy adds it)
    * Points to: The target value
    * TTL: 1 hour

    5. Save both records
  </Accordion>

  <Accordion title="Namecheap">
    1. Sign in to Namecheap
    2. Go to **Domain List** → **Manage**
    3. Select **Advanced DNS**
    4. Click **Add New Record**

    **For each CNAME record:**

    * Type: CNAME Record
    * Host: The record name (without your domain)
    * Value: The target value
    * TTL: Automatic

    5. Save all changes
  </Accordion>

  <Accordion title="Google Domains">
    1. Sign in to Google Domains
    2. Click your domain
    3. Go to **DNS** → **Manage custom records**
    4. Click **Create new record**

    **For each CNAME record:**

    * Type: CNAME
    * Host name: The record name
    * Data: The target value
    * TTL: 1 hour

    5. Save both records
  </Accordion>
</AccordionGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Domain not working after 48 hours">
    * Verify DNS records are correctly configured
    * Check for typos in the domain name
    * Ensure no conflicting A or AAAA records exist
    * Contact support with your domain details
  </Accordion>

  <Accordion title="SSL certificate errors">
    * CalStudio automatically handles SSL certificates
    * If using Cloudflare, ensure proxy is disabled (DNS only)
    * Allow up to 24 hours for certificate provisioning
  </Accordion>

  <Accordion title="Email stopped working (root domain)">
    * This occurs with NS delegation
    * You'll need to recreate MX records in CalStudio's DNS manager
    * Consider using a subdomain instead to avoid email issues
  </Accordion>

  <Accordion title="Want to remove custom domain">
    * Remove the domain in CalStudio dashboard first
    * Then update/remove DNS records at your provider
    * Your app will revert to the CalStudio subdomain
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup>
  <Card title="White-Label Branding" icon="palette" href="/account/pricing">
    Remove all CalStudio branding (Pro Plus)
  </Card>

  <Card title="Embed Your App" icon="code" href="/quickstart">
    Embed your AI app on existing websites
  </Card>
</CardGroup>


# Pricing Plans
Source: https://docs.calstudio.com/account/pricing

Choose the perfect plan for your AI app creation needs

<Info>
  All plans include access to the latest AI models from OpenAI, Anthropic, Meta, and Google. No API keys required!
</Info>

## Plan Comparison

| Plan     | Monthly Price | Messages/Month | Max Apps | Monetization | Analytics         | Custom Domains | White-Label | Priority Support | Dedicated Server |
| -------- | ------------- | -------------- | -------- | ------------ | ----------------- | -------------- | ----------- | ---------------- | ---------------- |
| Free     | \$0           | 50             | 5        | ❌            | ❌                 | ❌              | ❌           | ❌                | ❌                |
| Lite     | \$15          | 1,000          | 50       | ✅            | ❌                 | ❌              | ❌           | ❌                | ❌                |
| Pro      | \$19-2,499    | 1K-50K         | 100      | ✅            | Limited (Last 50) | ✅              | ❌           | ❌                | ❌                |
| Pro Plus | \$39-3,299    | 1K-50K         | 1,000    | ✅            | Yes (Last 500)    | ✅              | ✅           | ✅                | ❌                |
| Pro Max  | \$99-4,999    | 1K-50K         | 1,000    | ✅            | All Analytics     | ✅              | ✅           | ✅                | ✅                |

## Plan Details

### Free Plan

**Perfect for Getting Started**

**\$0/month**

* ✅ Create up to 5 custom AI apps
* ✅ 50 messages per month
* ✅ Access to all AI models
* ✅ Basic app customization
* ❌ Monetization features
* ❌ Analytics dashboard
* ❌ Custom domains

### Lite Plan

**For Growing Creators**

**\$15/month**

* ✅ Everything in Free, plus:
* ✅ Create up to 50 AI apps
* ✅ 1,000 messages per month
* ✅ **Monetization enabled** (payments & subscriptions)
* ✅ Stripe integration
* ❌ Analytics dashboard
* ❌ Custom domains

### Pro Plan

**For Professional Use**

**Starting at \$19/month**

Includes everything in Lite, plus:

* ✅ Create up to 100 AI apps
* ✅ **Custom domain support**
* ✅ **Embed apps on any website**
* ✅ Basic analytics (last 50 conversations)
* ✅ SSL certificates included
* ✅ Email support

**Usage-based pricing tiers:**

* 1,000 messages/month: \$19
* 5,000 messages/month: \$49
* 10,000 messages/month: \$249
* 20,000 messages/month: \$499
* 30,000 messages/month: \$999
* 50,000 messages/month: \$2,499

### Pro Plus Plan

**For Scaling Businesses**

**Starting at \$39/month**

Includes everything in Pro, plus:

* ✅ Create up to 1,000 AI apps
* ✅ **White-label capabilities**
* ✅ **AI Studio marketplace** (bundle & sell apps)
* ✅ Advanced analytics (last 500 conversations)
* ✅ Priority feature requests
* ✅ Early access to new features
* ✅ Priority email support

**Usage-based pricing tiers:**

* 1,000 messages/month: \$39
* 5,000 messages/month: \$99
* 10,000 messages/month: \$399
* 20,000 messages/month: \$649
* 30,000 messages/month: \$1,299
* 50,000 messages/month: \$3,299

### Pro Max Plan

**Enterprise Solution**

**Starting at \$79/month**

Our most comprehensive plan includes:

* ✅ Everything in Pro Plus
* ✅ **Dedicated server infrastructure**
* ✅ **Unlimited analytics history**
* ✅ Advanced security features
* ✅ Custom integrations support
* ✅ Dedicated account manager
* ✅ 99.9% uptime SLA
* ✅ Phone & video support

**Usage-based pricing tiers:**

* 1,000 messages/month: \$99
* 5,000 messages/month: \$199
* 10,000 messages/month: \$699
* 20,000 messages/month: \$999
* 30,000 messages/month: \$1,699
* 50,000 messages/month: \$4,999

## How Message Limits Work

<Warning>
  When you reach your monthly message limit, you'll receive an email notification to upgrade your plan. Your apps will continue working temporarily, but will stop accepting new messages if you don't upgrade within the grace period.
</Warning>

* Each user input and AI response counts as one message
* Message counts reset on your monthly billing date
* Email notifications are sent when you reach 80% of your limit
* Apps require plan upgrade to continue after reaching the limit

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title="Can I change plans anytime?">
    Yes! You can upgrade or downgrade your plan at any time. Changes take effect immediately, and billing is prorated.
  </Accordion>

  <Accordion title="What happens when I reach my message limit?">
    You'll receive email notifications when you reach 80% and 100% of your monthly limit. You'll need to upgrade your plan for your apps to continue accepting new messages. There's a short grace period to allow you time to upgrade.
  </Accordion>

  <Accordion title="Do you offer custom enterprise plans?">
    Absolutely! For custom message volumes, dedicated infrastructure, or special requirements, contact us at [support@calstudio.com](mailto:support@calstudio.com).
  </Accordion>

  <Accordion title="How does white-labeling work?">
    Pro Plus and Pro Max users can remove CalStudio branding and use custom branding throughout their apps. This includes custom logos, colors, and domain names.
  </Accordion>

  <Accordion title="Do you offer educational or nonprofit discounts?">
    Yes! We offer special pricing for verified educational institutions and registered nonprofits. Contact [support@calstudio.com](mailto:support@calstudio.com) with proof of status.
  </Accordion>
</AccordionGroup>

## Ready to Get Started?

<CardGroup>
  <Card title="Create Free Account" icon="rocket" href="https://calstudio.com/signup">
    Start building AI apps today
  </Card>

  <Card title="Contact Sales" icon="phone" href="mailto:support@calstudio.com">
    Discuss enterprise solutions
  </Card>
</CardGroup>


# Custom Domain for Studios
Source: https://docs.calstudio.com/account/studio-custom-domain

Connect your AI Studio to your own domain for a fully branded experience

<Info>
  Custom domains for Studios allow you to publish your entire AI Studio marketplace on your own branded domain, giving your users a seamless experience under your own URL.
</Info>

## Overview

When you connect a custom domain to your Studio, all the apps within that Studio become accessible under your branded domain. This is ideal for:

* Creating a professional AI marketplace or portal under your brand
* Providing a unified experience for all your AI apps
* Building trust with your audience through a recognizable URL
* Removing CalStudio branding from your Studio

## Prerequisites

Before setting up a custom domain for your Studio, ensure you have:

<CardGroup>
  <Card title="CalStudio Pro Plan" icon="credit-card">
    Custom domains are available on Pro plans and above
  </Card>

  <Card title="Live Studio" icon="rocket">
    Your Studio must be published and live before adding a custom domain
  </Card>

  <Card title="Domain Ownership" icon="globe">
    A registered domain with DNS management access
  </Card>
</CardGroup>

## Step-by-Step Setup Process

### Step 1: Navigate to Your Studios

1. Log in to your [CalStudio dashboard](https://calstudio.com/dashboard)
2. Go to the **Studios** page to see your list of Studios

### Step 2: Open Studio Options

1. Find the Studio you want to connect a custom domain to
2. Click the **three-dot menu** (⋮) next to the Studio name
3. You'll see the following options:
   * View Studio
   * Edit Studio
   * Analytics
   * Invite User
   * Grant Credits
   * **Custom Domain**
   * Delete Studio

<img alt="Studio options dropdown showing Custom Domain option" />

### Step 3: Enter Your Domain

1. Click **"Custom Domain"** from the menu
2. The **Configure Custom Domain** dialog will appear
3. Enter the domain you want to use for your Studio:
   * **Root domain**: `yourdomain.com`
   * **Subdomain**: `app.yourdomain.com` or `studio.yourdomain.com`
4. Click **"Continue"**

<img alt="Configure Custom Domain modal with domain input field" />

### Step 4: Configure DNS Records

After clicking Continue, CalStudio will provide you with **CNAME records** to add to your DNS provider.

<Tabs>
  <Tab title="Subdomain (Recommended)">
    For subdomains like `studio.yourdomain.com`, you'll receive two CNAME records:

    1. **SSL Certificate Validation Record**:
       * This CNAME record is required for SSL certificate validation
       * It will have a long, unique name starting with an underscore
       * The value points to AWS Certificate Manager for validation
       ```
       Type: CNAME
       Name: _abc123... (provided by CalStudio)
       Value: _xyz789....acm-validations.aws
       TTL: 3600 (or default)
       ```

    2. **Studio CNAME Record**:
       * This points your subdomain to your CalStudio Studio
       * Name: Your chosen subdomain (e.g., `studio`)
       * Value: An AWS load balancer URL
       ```
       Type: CNAME
       Name: studio (or your chosen subdomain)
       Value: [provided-by-calstudio].elb.amazonaws.com
       TTL: 3600 (or default)
       ```

    <Note>
      Subdomains are recommended because they are easier to configure and don't affect your main website or email settings.
    </Note>
  </Tab>

  <Tab title="Root Domain">
    For root domains like `yourdomain.com`:

    1. **You'll receive NS (Name Server) records** from CalStudio
    2. These will be AWS Route 53 nameservers
    3. At your domain registrar, update your nameservers to the provided AWS records:
       ```
       ns-1234.awsdns-12.org
       ns-5678.awsdns-34.co.uk
       ns-9012.awsdns-56.com
       ns-3456.awsdns-78.net
       ```
    4. This process can take 24-48 hours to propagate globally

    <Warning>
      NS delegation affects your entire domain. All existing DNS records (including email, subdomains, etc.) will need to be recreated in the new DNS system. Consider using a subdomain instead if you have existing services on your root domain.
    </Warning>
  </Tab>
</Tabs>

### Step 5: Add Records to Your DNS Provider

Add the CNAME records to your DNS provider. Here's how for popular providers:

<AccordionGroup>
  <Accordion title="Cloudflare">
    1. Log in to Cloudflare dashboard
    2. Select your domain
    3. Go to **DNS** > **Records**
    4. Click **Add record**

    **For the SSL validation record:**

    * Type: CNAME
    * Name: Paste the long underscore name (e.g., `_ce016fc2...`)
    * Target: Paste the AWS validation value
    * Proxy status: **DNS only** (gray cloud)
    * TTL: Auto

    **For the subdomain record:**

    * Type: CNAME
    * Name: Your subdomain (e.g., `studio`)
    * Target: Paste the AWS load balancer URL
    * Proxy status: **DNS only** (gray cloud)
    * TTL: Auto
  </Accordion>

  <Accordion title="GoDaddy">
    1. Sign in to GoDaddy Domain Control Center
    2. Select your domain
    3. Click **DNS** > **Manage DNS**
    4. Click **ADD** under records

    **For each CNAME record:**

    * Type: CNAME
    * Host: The record name (remove your domain from the end if GoDaddy adds it)
    * Points to: The target value
    * TTL: 1 hour

    5. Save both records
  </Accordion>

  <Accordion title="Namecheap">
    1. Sign in to Namecheap
    2. Go to **Domain List** > **Manage**
    3. Select **Advanced DNS**
    4. Click **Add New Record**

    **For each CNAME record:**

    * Type: CNAME Record
    * Host: The record name (without your domain)
    * Value: The target value
    * TTL: Automatic

    5. Save all changes
  </Accordion>

  <Accordion title="Google Domains">
    1. Sign in to Google Domains
    2. Click your domain
    3. Go to **DNS** > **Manage custom records**
    4. Click **Create new record**

    **For each CNAME record:**

    * Type: CNAME
    * Host name: The record name
    * Data: The target value
    * TTL: 1 hour

    5. Save both records
  </Accordion>
</AccordionGroup>

### Step 6: Verify Deployment

1. **Wait for DNS propagation** (usually 5-30 minutes for CNAME, up to 48 hours for NS)
2. Visit your custom domain in the browser
3. Your Studio and all its apps should now be live at your domain

<Tip>
  Use [DNS Checker](https://dnschecker.org) to verify your DNS records have propagated globally.
</Tip>

## SSL Certificates

<Check>
  CalStudio automatically provisions and manages SSL certificates for all custom domains using AWS Certificate Manager. Your Studio will be served securely over HTTPS — no additional configuration required.
</Check>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Custom Domain option is grayed out or missing">
    * Make sure your Studio is **live** (published). Custom domains can only be added to live Studios.
  </Accordion>

  <Accordion title="Domain not working after 48 hours">
    * Verify DNS records are correctly configured
    * Check for typos in the domain name
    * Ensure no conflicting A or AAAA records exist
    * Contact support at [support@calstudio.com](mailto:support@calstudio.com) with your domain details
  </Accordion>

  <Accordion title="SSL certificate errors">
    * CalStudio automatically handles SSL certificates
    * If using Cloudflare, ensure proxy is disabled (DNS only)
    * Allow up to 24 hours for certificate provisioning
    * Ensure the SSL validation CNAME record is correctly added
  </Accordion>

  <Accordion title="Email stopped working (root domain)">
    * This occurs with NS delegation for root domains
    * You'll need to recreate MX records in the new DNS system
    * Consider using a subdomain instead to avoid email issues
  </Accordion>

  <Accordion title="Want to remove the custom domain">
    * Open the Studio options menu and click **Custom Domain**
    * Remove the domain in the CalStudio dashboard
    * Then update/remove DNS records at your provider
    * Your Studio will revert to its default CalStudio URL
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup>
  <Card title="Custom Domain for Apps" icon="globe" href="/account/custom-domain">
    Set up custom domains for individual AI apps
  </Card>

  <Card title="White-Label Branding" icon="palette" href="/account/pricing">
    Remove all CalStudio branding (Pro Plus)
  </Card>
</CardGroup>


# Webhooks
Source: https://docs.calstudio.com/account/webhooks

Connect your AI apps to automation platforms and external services

## What are Webhooks?

<Info>
  Webhooks enable real-time communication between your CalStudio AI apps and external services. When specific events occur in your app, webhooks automatically send data to your chosen destination, powering instant automations and integrations.
</Info>

Webhooks are essential for:

* **Automation Platforms**: Integrate with Zapier, Make.com, or custom workflows
* **CRM Integration**: Sync conversations to Salesforce, HubSpot, or other systems
* **Analytics**: Send chat data to your data warehouse or analytics tools
* **Notifications**: Alert your team about important conversations
* **Custom Workflows**: Trigger any action based on user interactions

## Setting Up Webhooks

### Step 1: Create Your Webhook Endpoint

First, create a webhook endpoint in your automation platform:

<Tabs>
  <Tab title="Zapier">
    1. Create a new Zap
    2. Choose **"Webhooks by Zapier"** as trigger
    3. Select **"Catch Hook"**
    4. Copy the webhook URL provided
  </Tab>

  <Tab title="Make.com">
    1. Create a new scenario
    2. Add **"Webhooks"** module
    3. Select **"Custom webhook"**
    4. Copy the webhook URL
  </Tab>

  <Tab title="Custom API">
    1. Create an endpoint that accepts POST requests
    2. Ensure it can handle JSON payloads
    3. Return a 200 status code on success
  </Tab>
</Tabs>

### Step 2: Configure in CalStudio

1. **Navigate to your app settings**
   * Open your AI app in the CalStudio dashboard
   * Go to the **"Webhooks"** section

2. **Add your webhook URL**
   * Paste the URL from your automation platform
   * CalStudio will validate the URL format

3. **Select trigger events**

   Choose when to send webhook notifications:

   <CardGroup>
     <Card title="Message Sent" icon="message">
       Triggers when a user sends a message to your AI app
     </Card>

     <Card title="New User Signup" icon="user-plus">
       Triggers when a new user registers or starts using your app
     </Card>

     <Card title="Custom Conditions" icon="code-branch">
       Define custom logic using natural language prompts
     </Card>

     <Card title="Conversation End" icon="stop">
       Triggers when a conversation session ends
     </Card>
   </CardGroup>

### Step 3: Configure Custom Conditions (Optional)

For advanced use cases, create custom triggers:

1. **Select "Custom Conditions"**
2. **Write a trigger prompt** that describes when to fire the webhook
3. **CalStudio will evaluate** each conversation against your conditions

**Example prompts:**

* "When a user asks about pricing or costs"
* "If the user expresses frustration or dissatisfaction"
* "When the user provides their email address"
* "If the conversation mentions a competitor"

## Webhook Payload Structure

CalStudio sends a POST request with a JSON payload containing event details:

<CodeGroup>
  ```json Sample Webhook Request theme={null}
  {
    "event": "Message sent",
    "timestamp": "2024-01-01T12:00:00.000Z",
    "app_name": "My App",
    "user_email": "user@example.com",
    "user_name": "John Doe",
    "last_message": "User message",
    "response": "App response message"
  }
  ```
</CodeGroup>

### Payload Fields

| Field          | Type   | Description                                                         |
| -------------- | ------ | ------------------------------------------------------------------- |
| `event`        | string | The type of event that triggered the webhook ("Message sent", etc.) |
| `timestamp`    | string | The exact time the event occurred, formatted as ISO 8601            |
| `app_name`     | string | The name of your CalStudio app                                      |
| `user_email`   | string | The user's email address                                            |
| `user_name`    | string | The user's display name                                             |
| `last_message` | string | The most recent message sent by the user                            |
| `response`     | string | The AI app's response to the user                                   |

## Common Use Cases

<CardGroup>
  <Card title="Lead Capture" icon="user-plus">
    Send qualified leads to your CRM when users express interest
  </Card>

  <Card title="Support Escalation" icon="headset">
    Create tickets in Zendesk when users report issues
  </Card>

  <Card title="Analytics Tracking" icon="chart-line">
    Log conversations to Google Analytics or Mixpanel
  </Card>

  <Card title="Email Follow-up" icon="envelope">
    Trigger personalized emails based on conversation topics
  </Card>
</CardGroup>

## Example: Zapier Integration

Here's a step-by-step example of connecting CalStudio to Google Sheets via Zapier:

<Steps>
  <Step title="Create a Zap">
    1. Log in to Zapier and create a new Zap
    2. Search for "Webhooks by Zapier" as the trigger
    3. Choose "Catch Hook" as the trigger event
    4. Copy the custom webhook URL
  </Step>

  <Step title="Configure CalStudio">
    1. Go to your app's webhook settings
    2. Paste the Zapier webhook URL
    3. Select "Message Sent" as the trigger
    4. Save your configuration
  </Step>

  <Step title="Test the Connection">
    1. Send a test message in your AI app
    2. Return to Zapier and click "Test trigger"
    3. Zapier should receive the webhook data
  </Step>

  <Step title="Add Google Sheets Action">
    1. Add a new action step
    2. Choose Google Sheets
    3. Select "Create Spreadsheet Row"
    4. Map webhook fields to sheet columns
  </Step>
</Steps>

## Best Practices

<Steps>
  <Step title="Secure Your Endpoints">
    * Use HTTPS for all webhook URLs
    * Implement authentication tokens if needed
    * Validate incoming requests
  </Step>

  <Step title="Handle Errors Gracefully">
    * Return appropriate HTTP status codes
    * Log failed webhook attempts
    * Set up retry logic for failures
  </Step>

  <Step title="Process Asynchronously">
    * Acknowledge webhooks quickly (\< 3 seconds)
    * Process data in background jobs
    * Avoid blocking operations
  </Step>

  <Step title="Monitor Performance">
    * Track webhook delivery rates
    * Set up alerts for failures
    * Monitor response times
  </Step>
</Steps>

## Testing Webhooks

<Tip>
  Use tools like [webhook.site](https://webhook.site) or [RequestBin](https://requestbin.com) to test your webhook configuration before connecting to production systems.
</Tip>

1. Create a test webhook URL
2. Configure it in CalStudio
3. Trigger test events in your app
4. Verify the payload structure
5. Implement your automation logic

## Troubleshooting

<AccordionGroup>
  <Accordion title="Webhook not firing">
    * Verify the webhook URL is correct and accessible
    * Check that events are properly configured
    * Ensure your app is active and receiving messages
    * Test with a simple webhook receiver first
  </Accordion>

  <Accordion title="Receiving duplicate webhooks">
    * Implement idempotency using the conversation ID
    * Check if multiple webhook configurations exist
    * Verify your endpoint isn't triggering retries
  </Accordion>

  <Accordion title="Missing data in payload">
    * Some fields are only available for specific events
    * User data requires users to be logged in
    * Check your app's privacy settings
  </Accordion>

  <Accordion title="Webhook delays">
    * Webhooks are sent immediately after events
    * Network latency may cause small delays
    * Check your endpoint's response time
  </Accordion>
</AccordionGroup>

## Related Resources

<CardGroup>
  <Card title="WhatsApp Integration" icon="whatsapp" href="/account/whatsApp-integration">
    Connect your AI apps to WhatsApp
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Programmatic webhook management
  </Card>
</CardGroup>


# WhatsApp Integration
Source: https://docs.calstudio.com/account/whatsApp-integration

Deploy your custom AI apps to WhatsApp and SMS with Twilio

<Info>
  Transform your CalStudio AI apps into powerful WhatsApp and SMS assistants. This integration allows your custom AI to communicate directly with users through their preferred messaging platforms.
</Info>

## Overview

With CalStudio's Twilio integration, you can:

* Deploy AI apps to WhatsApp Business accounts
* Enable SMS communication for your AI assistants
* Test safely using Twilio's sandbox environment
* Scale to production with WhatsApp Business API
* Handle customer support, sales inquiries, and automated responses

## Prerequisites

Before you begin, ensure you have:

<CardGroup>
  <Card title="CalStudio Account" icon="user">
    Free to start - [Sign up here](https://calstudio.com/signup)
  </Card>

  <Card title="Twilio Account" icon="message">
    For messaging API access - [Create account](https://www.twilio.com/try-twilio)
  </Card>

  <Card title="Phone Number" icon="phone">
    A verified number for testing
  </Card>

  <Card title="Facebook Business" icon="facebook">
    Optional - Required for production WhatsApp deployment
  </Card>
</CardGroup>

## Setup Guide

### Step 1: Create Your AI App in CalStudio

1. **Access your dashboard**
   * Sign in to your [CalStudio Dashboard](https://calstudio.com/dashboard)
   * Click **"Create App"**

2. **Configure your AI app**
   * **App Name**: Choose a descriptive name
   * **App Icon**: Upload a logo (optional)
   * **AI Model**: Select from GPT-4, Claude, Gemini, or others
   * **System Prompt**: Define your bot's personality and behavior

3. **Launch your app**
   * Click **"Create App"** in the top-right corner
   * Once created, click **"Launch"** to make it live

<Note>
  No API keys required! CalStudio handles all AI model connections for you.
</Note>

### Step 2: Connect CalStudio with Twilio

1. In your CalStudio dashboard, locate your launched app
2. Click **"Publish"** → **"Continue with Twilio"**
3. You'll need to provide:
   * **Account SID**: Your Twilio account identifier
   * **Auth Token**: Your Twilio authentication token
   * **Twilio Phone Number**: In E.164 format (e.g., +14155552671)

<Tip>
  Keep this window open while you retrieve your Twilio credentials in the next step.
</Tip>

### Step 3: Retrieve Twilio Credentials

1. **Access Twilio Console**
   * Sign up or log in at [Twilio Console](https://console.twilio.com)
   * Complete phone verification with OTP
   * Save your recovery code securely

2. **Copy your credentials**
   * From your Twilio dashboard, locate:
     * **Account SID** (starts with AC...)
     * **Auth Token** (click to reveal)

3. **Return to CalStudio**
   * Paste your Account SID and Auth Token
   * Add your Twilio phone number in E.164 format
   * Click **"Publish"**

<Warning>
  Keep your Auth Token secure. Never share it publicly or commit it to version control.
</Warning>

### Step 4: Configure Webhook for Testing (Sandbox)

1. **Get your webhook URL**
   * After publishing, CalStudio generates a unique webhook URL
   * Copy this URL for the next step

2. **Configure Twilio Sandbox**
   * In Twilio Console, navigate to:
     * **Messaging** → **Try it Out** → **Send a WhatsApp Message**
     * Click **"Sandbox Settings"**

3. **Set up the webhook**
   * Paste your CalStudio webhook URL in **"When a message comes in"**
   * Set HTTP method to **POST**
   * Save your changes

4. **Join the sandbox**
   * Scan the QR code provided by Twilio
   * Or send the join code to the sandbox WhatsApp number

<Check>
  Your WhatsApp bot is now ready for testing! Send a message to see it in action.
</Check>

### Step 5: Deploy to Production

<Steps>
  <Step title="Upgrade Twilio Account">
    1. Click **"Upgrade Account"** in Twilio Console
    2. Complete verification:
       * Legal name and country
       * Government ID verification
       * Payment details
  </Step>

  <Step title="Purchase Phone Number">
    1. Navigate to **Phone Numbers** → **Manage** → **Buy a Number**
    2. Select a number with SMS and voice capabilities
    3. Complete the purchase
  </Step>

  <Step title="Register with WhatsApp Business">
    1. Go to **Messaging** → **Senders** → **WhatsApp Senders**
    2. Click **"Get Started"**
    3. Select your Twilio phone number
    4. Log in with Facebook to verify WhatsApp Business
    5. Provide business information:
       * Business name and category
       * WhatsApp display name
       * Complete OTP verification
  </Step>

  <Step title="Configure Production Webhook">
    1. In your WhatsApp Sender settings
    2. Paste your CalStudio webhook URL under **"Incoming Messages"**
    3. Save your configuration
  </Step>
</Steps>

### Step 6: Test Your Production Bot

1. **Add to contacts**
   * Save your Twilio WhatsApp number to your phone contacts
2. **Start chatting**
   * Send a message to your WhatsApp Business number
   * Your AI app will respond instantly!

<Check>
  Congratulations! Your custom AI app is now live on WhatsApp.
</Check>

## SMS Integration (Optional)

To enable SMS messaging for your AI app:

1. Use the same Twilio phone number
2. In Twilio Console, configure SMS settings
3. Set incoming messages webhook to your CalStudio URL
4. No additional verification required

<Note>
  SMS integration is simpler than WhatsApp as it doesn't require Facebook Business verification.
</Note>

## Best Practices

<CardGroup>
  <Card title="Message Templates" icon="file-lines">
    Use WhatsApp-approved templates for business-initiated conversations
  </Card>

  <Card title="Response Time" icon="clock">
    Configure your AI to respond quickly to maintain user engagement
  </Card>

  <Card title="Compliance" icon="shield-check">
    Follow WhatsApp Business policies and Twilio's acceptable use guidelines
  </Card>

  <Card title="Error Handling" icon="triangle-exclamation">
    Set up fallback responses for when your AI can't understand a query
  </Card>
</CardGroup>

## What's Next?

<CardGroup>
  <Card title="Configure Webhooks" icon="webhook" href="/account/webhooks">
    Set up automated workflows with Zapier or Make.com
  </Card>

  <Card title="Customize Your Bot" icon="palette" href="/quickstart">
    Fine-tune your AI's personality and responses
  </Card>

  <Card title="Monitor Analytics" icon="chart-line" href="/account/pricing">
    Track usage and conversations (Pro plans)
  </Card>

  <Card title="Get Support" icon="headset" href="mailto:support@calstudio.com">
    Contact our team for assistance
  </Card>
</CardGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Bot not responding in WhatsApp">
    * Verify webhook URL is correctly configured in Twilio
    * Check that your CalStudio app is launched and active
    * Ensure Twilio credentials are correct in CalStudio
  </Accordion>

  <Accordion title="Messages delayed or not delivering">
    * Check Twilio account balance and limits
    * Verify phone number format (E.164)
    * Review Twilio error logs for specific issues
  </Accordion>

  <Accordion title="WhatsApp Business verification failed">
    * Ensure Facebook Business account is properly set up
    * Verify business information matches across platforms
    * Contact Twilio support for verification assistance
  </Accordion>
</AccordionGroup>


# Create Plant
Source: https://docs.calstudio.com/api-reference/endpoint/create

POST /plants
Creates a new plant in the store



# Delete Plant
Source: https://docs.calstudio.com/api-reference/endpoint/delete

DELETE /plants/{id}
Deletes a single plant based on the ID supplied



# Get Plants
Source: https://docs.calstudio.com/api-reference/endpoint/get

GET /plants
Returns all plants from the system that the user has access to



# New Plant
Source: https://docs.calstudio.com/api-reference/endpoint/webhook

WEBHOOK /plant/webhook
Information about a new plant added to the store



# API Reference
Source: https://docs.calstudio.com/api-reference/introduction

Programmatically manage your CalStudio AI apps

## Overview

The CalStudio API enables you to programmatically create, manage, and interact with your custom AI apps. Whether you're integrating CalStudio into your existing workflow or building advanced automation, our RESTful API provides comprehensive access to platform features.

### Key Capabilities

* **App Management**: Create, update, and delete AI apps
* **User Analytics**: Access detailed usage statistics and chat history
* **Webhook Integration**: Receive real-time notifications for app events
* **Custom Deployments**: Manage white-label configurations
* **Payment Processing**: Handle subscriptions and credit purchases

### Base URL

```
https://api.calstudio.com/v1
```

### API Versioning

We use URL-based versioning to ensure backward compatibility. The current version is `v1`. We'll notify you well in advance of any breaking changes through our [changelog](https://pmfm.featurebase.app/changelog).

## Authentication

CalStudio uses API keys for authentication. Include your API key in the Authorization header of every request:

```bash theme={null}
curl -X GET https://api.calstudio.com/v1/apps \
  -H "Authorization: Bearer YOUR_API_KEY"
```

### Getting Your API Key

1. Log in to your [CalStudio dashboard](https://calstudio.com/dashboard)
2. Navigate to **Account Settings** → **API Keys**
3. Click **Generate New Key**
4. Store your key securely - it won't be shown again

<Warning>
  Keep your API keys secure and never expose them in client-side code or public repositories. Treat them like passwords.
</Warning>

## Rate Limits

API requests are subject to rate limiting to ensure platform stability:

| Plan     | Requests per Minute | Requests per Day |
| -------- | ------------------- | ---------------- |
| Free     | 60                  | 1,000            |
| Lite     | 120                 | 5,000            |
| Pro      | 300                 | 25,000           |
| Pro Plus | 600                 | 100,000          |

Rate limit headers are included in all responses:

```
X-RateLimit-Limit: 300
X-RateLimit-Remaining: 299
X-RateLimit-Reset: 1640995200
```

## Error Handling

CalStudio API uses standard HTTP status codes and returns detailed error messages:

```json theme={null}
{
  "error": {
    "code": "invalid_api_key",
    "message": "The provided API key is invalid or expired",
    "request_id": "req_123abc"
  }
}
```

### Common Error Codes

| Status Code | Description                                  |
| ----------- | -------------------------------------------- |
| 400         | Bad Request - Invalid parameters             |
| 401         | Unauthorized - Invalid API key               |
| 403         | Forbidden - Insufficient permissions         |
| 404         | Not Found - Resource doesn't exist           |
| 429         | Too Many Requests - Rate limit exceeded      |
| 500         | Internal Server Error - Something went wrong |

## Quick Start

Ready to make your first API call? Check out these common use cases:

<CardGroup>
  <Card title="List Your Apps" icon="list" href="/api-reference/endpoint/get">
    Retrieve all AI apps in your account
  </Card>

  <Card title="Create an App" icon="plus" href="/api-reference/endpoint/create">
    Programmatically create new AI apps
  </Card>

  <Card title="Configure Webhooks" icon="webhook" href="/api-reference/endpoint/webhook">
    Set up real-time event notifications
  </Card>

  <Card title="Delete an App" icon="trash" href="/api-reference/endpoint/delete">
    Remove AI apps from your account
  </Card>
</CardGroup>


# Development
Source: https://docs.calstudio.com/development

Preview changes locally to update your docs

<Info>
  **Prerequisite**: Please install Node.js (version 19 or higher) before proceeding. <br />
  Please upgrade to `docs.json` before proceeding and delete the legacy `mint.json` file.
</Info>

Follow these steps to install and run Mintlify on your operating system:

**Step 1**: Install Mintlify:

<CodeGroup>
  ```bash npm theme={null}
  npm i -g mintlify
  ```

  ```bash yarn theme={null}
  yarn global add mintlify
  ```
</CodeGroup>

**Step 2**: Navigate to the docs directory (where the `docs.json` file is located) and execute the following command:

```bash theme={null}
mintlify dev
```

A local preview of your documentation will be available at `http://localhost:3000`.

### Custom Ports

By default, Mintlify uses port 3000. You can customize the port Mintlify runs on by using the `--port` flag. To run Mintlify on port 3333, for instance, use this command:

```bash theme={null}
mintlify dev --port 3333
```

If you attempt to run Mintlify on a port that's already in use, it will use the next available port:

```md theme={null}
Port 3000 is already in use. Trying 3001 instead.
```

## Mintlify Versions

Please note that each CLI release is associated with a specific version of Mintlify. If your local website doesn't align with the production version, please update the CLI:

<CodeGroup>
  ```bash npm theme={null}
  npm i -g mintlify@latest
  ```

  ```bash yarn theme={null}
  yarn global upgrade mintlify
  ```
</CodeGroup>

## Validating Links

The CLI can assist with validating reference links made in your documentation. To identify any broken links, use the following command:

```bash theme={null}
mintlify broken-links
```

## Deployment

<Tip>
  Unlimited editors available under the [Pro
  Plan](https://mintlify.com/pricing) and above.
</Tip>

If the deployment is successful, you should see the following:

<Frame>
  <img />
</Frame>

## Code Formatting

We suggest using extensions on your IDE to recognize and format MDX. If you're a VSCode user, consider the [MDX VSCode extension](https://marketplace.visualstudio.com/items?itemName=unifiedjs.vscode-mdx) for syntax highlighting, and [Prettier](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) for code formatting.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Error: Could not load the &#x22;sharp&#x22; module using the darwin-arm64 runtime">
    This may be due to an outdated version of node. Try the following:

    1. Remove the currently-installed version of mintlify: `npm remove -g mintlify`
    2. Upgrade to Node v19 or higher.
    3. Reinstall mintlify: `npm install -g mintlify`
  </Accordion>

  <Accordion title="Issue: Encountering an unknown error">
    Solution: Go to the root of your device and delete the \~/.mintlify folder. Afterwards, run `mintlify dev` again.
  </Accordion>
</AccordionGroup>

Curious about what changed in the CLI version? [Check out the CLI changelog.](https://www.npmjs.com/package/mintlify?activeTab=versions)


# Welcome to CalStudio
Source: https://docs.calstudio.com/index

Create and Deploy Custom AI Apps, Voice Agents, and AI Studios without code

## Create and Launch Custom AI Apps Without Code

CalStudio is the no-code platform that empowers educators, consultants, startups, and businesses to create custom AI apps in just 5 minutes. Join over 5,000 creators who are building and monetizing AI solutions without writing a single line of code.

### Why CalStudio?

* **Launch in Minutes, Not Months**: Go from idea to live AI app in under 5 minutes
* **No Coding Required**: Build sophisticated AI apps through our intuitive interface
* **Multiple AI Models**: Access OpenAI, Anthropic, Meta, and Google models without API keys
* **Built-in Monetization**: Accept payments globally with integrated Stripe processing
* **White-Label Ready**: Bundle and sell apps in your own branded AI Studio marketplace
* **Enterprise Features**: Custom domains, SSL security, detailed analytics, and embedding options

<img alt="CalStudio builders collaborating inside the dashboard" />

<img alt="CalStudio builders collaborating inside the dashboard" />

## Get Started

<CardGroup>
  <Card title="Create Your First App" icon="rocket" href="https://calstudio.com/signup">
    Build your custom AI app in 5 minutes
  </Card>

  <Card title="Quickstart Guide" icon="book-open" href="/quickstart">
    Step-by-step tutorial for your first app
  </Card>

  <Card title="Explore Pricing" icon="credit-card" href="/account/pricing">
    From free tier to enterprise solutions
  </Card>

  <Card title="API Documentation" icon="code" href="/api-reference/introduction">
    Integrate CalStudio with your systems
  </Card>
</CardGroup>

## Popular Use Cases

<CardGroup>
  <Card title="Education" icon="graduation-cap">
    Create AI tutors and learning assistants
  </Card>

  <Card title="Business" icon="briefcase">
    Build customer support and automation tools
  </Card>

  <Card title="Consulting" icon="users">
    Deploy custom solutions for clients
  </Card>
</CardGroup>

## Resources & Support

<CardGroup>
  <Card title="What's New" icon="sparkles" href="https://pmfm.featurebase.app/changelog">
    Latest features and updates
  </Card>

  <Card title="Support Center" icon="headset" href="mailto:support@calstudio.com">
    Get help with account and billing
  </Card>

  <Card title="Discord Community" icon="discord" href="https://discord.gg/FnktGy3mkV">
    Connect with 5,000+ creators
  </Card>
</CardGroup>


# Quickstart Guide
Source: https://docs.calstudio.com/quickstart

Create your first custom AI app in 5 minutes

<Info>
  This guide will walk you through creating your first custom AI app on CalStudio. You'll learn how to configure, customize, and deploy a fully functional AI application without writing any code.
</Info>

## Prerequisites

Before you begin, make sure you have:

* A CalStudio account ([Sign up free](https://calstudio.com/signup))
* An idea for your AI app (customer support bot, educational tutor, content generator, etc.)

## Step 1: Access Your Dashboard

1. Navigate to [CalStudio.com](https://calstudio.com/login)
2. Log in with your credentials
3. You'll be directed to your [dashboard](https://calstudio.com/dashboard) where you can manage all your AI apps

## Step 2: Create Your AI App

### Select Your AI Model

1. Click the **"Create App"** button on your dashboard
2. Choose from our selection of cutting-edge AI models:
   * **OpenAI** (GPT-4, GPT-3.5)
   * **Anthropic** (Claude)
   * **Meta** (Llama)
   * **Google** (Gemini)

<Note>
  No API keys required! CalStudio handles all the technical complexity for you.
</Note>

## Step 3: Configure Your App

The app builder interface is divided into two sections:

* **Configuration Panel** (left): Multiple tabs for customizing your app
* **Live Preview** (right): See your changes in real-time

### Basic Configuration

In the **Basics** tab, set up your app's core functionality:

1. **App Identity**
   * Upload a logo for brand recognition
   * Set your app name (internal identifier)
   * Choose a display name (what users will see)
   * Write a compelling description

2. **AI Configuration**
   * Select your specific model version (e.g., GPT-4 Turbo)
   * Define the AI's behavior with a clear system prompt
   * Set a welcoming message for first-time users

3. **Access Control**
   * Toggle login requirements
   * Configure user authentication settings

<Tip>
  Your system prompt is crucial! Be specific about what your AI should and shouldn't do. For example: "You are a friendly customer support agent for an e-commerce store. Always be helpful, professional, and try to resolve issues quickly."
</Tip>

### Monetization Setup (Optional)

Navigate to the **Credits** tab to configure how users access your app:

1. **Free Tier Settings**
   * Set number of free messages per user
   * Enable monthly reset for recurring free access

2. **Payment Options** (if monetizing)
   * **One-time Payments**: Users purchase message credits
   * **Subscription Model**: Monthly recurring access

3. **Pricing Configuration**
   * Select your currency (USD, EUR, GBP, etc.)
   * Set your pricing structure
   * Example: $5 for 50 messages, $10 for 150 messages

<Info>
  CalStudio uses Stripe for secure payment processing. Payments are available globally with support for multiple currencies.
</Info>

## Step 4: Launch Your App

1. Review your configuration in the live preview
2. Click the **"Create App"** button in the top-right corner
3. Your AI app will be instantly deployed with a unique URL

<Check>
  Congratulations! Your custom AI app is now live and ready to use. Share the URL with your users or embed it on your website.
</Check>

## What's Next?

Now that you've created your first AI app, explore these advanced features:

<CardGroup>
  <Card title="Custom Domain" icon="globe" href="/account/custom-domain">
    Use your own domain for professional branding
  </Card>

  <Card title="WhatsApp Integration" icon="whatsapp" href="/account/whatsApp-integration">
    Connect your AI to WhatsApp for messaging
  </Card>

  <Card title="Webhooks" icon="webhook" href="/account/webhooks">
    Integrate with external services and APIs
  </Card>

  <Card title="API Access" icon="code" href="/api-reference/introduction">
    Programmatically manage your AI apps
  </Card>
</CardGroup>

## Need Help?

* Join our [Discord community](https://discord.gg/FnktGy3mkV) to connect with other creators
* Contact [support@calstudio.com](mailto:support@calstudio.com) for technical assistance
* Check our [changelog](https://pmfm.featurebase.app/changelog) for the latest features