Base Getting Started: Account, Keys, and First Request (2026)

Getting started overview

Getting started with Base primarily involves setting up a workspace through its web interface, then configuring API access if programmatic integration is required. Base is designed as a no-code database and application builder, meaning many initial interactions occur within its visual environment. However, an API is available for extending functionality, integrating with other systems, or automating workflows programmatically via the Base platform.

The core steps to begin using Base and making your first API calls are:

1. Create an account: Sign up for a free or paid Base plan.
2. Set up a workspace: Establish your initial data structures and applications within the Base UI.
3. Generate an API key: Obtain the necessary credentials for authenticating API requests.
4. Make your first request: Interact with your Base data using the API key.

This guide focuses on the API aspects, assuming you have a basic understanding of Base's no-code capabilities.

Quick reference table

The following table provides a high-level overview of the getting started process with Base, from account creation to your first API request.

Create an account and get keys

To begin, you need a Base account and an API key. Base offers a Free Plan that includes up to 5,000 requests per month and 1GB of storage, which is suitable for initial testing and development.

1. Sign up for Base: Navigate to the Base pricing page and choose your preferred plan to create an account. Follow the on-screen instructions to complete the registration process.

2. Access your Base dashboard: After signing up, you will be directed to your Base dashboard. This is where you can create new workspaces, projects, and manage your data.

3. Create a workspace/project: If you haven't already, create a new workspace or project within Base. This will be the container for your data and applications that you intend to interact with via the API.

4. Navigate to API settings: Within your chosen workspace or project, look for sections related to Settings, API & Integrations, or Developer Tools. The exact navigation may vary slightly but similar paths are common among no-code platforms providing API access, such as Notion API integration setup. For Base, this will typically be found within your individual workspace or application settings.

5. Generate an API Key:

   • Look for an option to Generate New API Key or Create Token.
   • Base API keys are typically associated with a specific workspace or application, granting access to its data.
   • Assign a descriptive name to your API key (e.g., "My First App Integration").
   • Copy the generated API key immediately and store it securely. Base, like many API providers, may only display the key once upon creation. Treat this key as sensitive information, similar to a password.

Your API key will be a long alphanumeric string. This key will be used to authenticate your requests to the Base API.

Your first request

Once you have your API key, you can make your first authenticated request to Base. For this example, we'll assume you have a basic Table named Customers with some sample data within your Base workspace. You will need to identify the specific API endpoint URL for your table.

1. Identify your API endpoint:

   • Go back to your Base workspace.
   • Navigate to the specific table or application you want to query.
   • Within the API & Integrations settings for that specific table or application, Base will provide the base URL for its API endpoints. This URL will usually include your workspace or application ID. It might look something like https://api.base.ai/v1/workspace_id/table_id/.
   • For example, to list records from your Customers table, your endpoint might be https://api.base.ai/v1/your_workspace_id/customers/records. (Note: Replace your_workspace_id and verify the exact path within your Base API documentation.)

2. Construct your request: Most Base API requests will require your API key in the Authorization header.

   Using cURL, a common command-line tool for making HTTP requests, you can make a GET request to list records from your Customers table:

   curl -X GET \
     'https://api.base.ai/v1/your_workspace_id/customers/records' \
     -H 'Authorization: Bearer YOUR_API_KEY' \
     -H 'Content-Type: application/json'

   • Replace your_workspace_id with your actual Base workspace ID.
   • Replace YOUR_API_KEY with the API key you generated.
   • The -X GET specifies the HTTP method.
   • The -H flags add HTTP headers. Authorization: Bearer YOUR_API_KEY is critical for authentication.

3. Execute the request: Run the curl command in your terminal. If successful, you should receive a JSON response containing the records from your Customers table. A successful response typically returns a 200 OK HTTP status code, as described in Mozilla's HTTP status codes documentation.

   {
     "data": [
       {
         "id": "rec_abc123",
         "fields": {
           "Name": "John Doe",
           "Email": "[email protected]"
         },
         "createdTime": "2026-05-29T12:00:00.000Z"
       },
       {
         "id": "rec_def456",
         "fields": {
           "Name": "Jane Smith",
           "Email": "[email protected]"
         },
         "createdTime": "2026-05-29T12:05:00.000Z"
       }
     ],
     "pagination": {
       "offset": null,
       "limit": 100
     }
   }

   This response indicates that your API key is valid and you have successfully retrieved data from your Base workspace.

Common next steps

After successfully making your first API request, consider these common next steps to further integrate with Base:

• Explore more API endpoints: Base's API likely supports various operations beyond listing records, such as creating, updating, or deleting records (POST, PATCH, DELETE requests). Consult the official Base API documentation for a complete list of available endpoints and their specific parameters.

• Integrate with programming languages: Instead of cURL, you can use HTTP client libraries in languages like Python (requests), JavaScript (fetch or axios), or Node.js to interact with the Base API. This allows for more dynamic and complex integrations within your applications.

• Set up webhooks: For real-time data updates, investigate Base's webhook capabilities. Webhooks allow Base to notify your external application when specific events occur (e.g., a new record is created), pushing data to you rather than requiring constant polling. This is a common pattern for event-driven architectures, as seen in Stripe's webhook implementation guide.

• Implement error handling: Production applications should always include robust error handling. Familiarize yourself with Base's API error codes and messages to gracefully manage issues like invalid API keys, authentication failures, or malformed requests.

• Manage API key security: Ensure your API keys are never hardcoded directly into client-side code or publicly accessible repositories. Use environment variables, secret management services, or secure server-side proxies to protect your credentials.

• Explore no-code builder features: While leveraging the API, remember Base's strength lies in its no-code application builder. You can often design and deploy front-end applications, forms, and workflows directly within Base, then use the API for specific backend integrations or advanced automations.

Troubleshooting the first call

If your first API call to Base doesn't return the expected results, consider the following common troubleshooting steps:

• Check API Key:

  • Verification: Double-check that the API key in your request matches the one generated in your Base workspace exactly. Even a single character mismatch will cause authentication to fail.
  • Type: Ensure you are using the correct type of API key if Base offers different keys for read-only, read/write, or administrative access.
  • Prefix: Confirm you've included the Bearer prefix before your API key in the Authorization header, as this is a common scheme for OAuth 2.0-style tokens.

• Verify Endpoint URL:

  • Accuracy: Make sure the entire URL, including your workspace ID and table/application ID, is correct and matches what Base provides in its API documentation for your specific resource.
  • HTTP vs. HTTPS: Always use HTTPS for API calls to ensure secure communication.

• HTTP Method:

  • Matching Method: Confirm that the HTTP method (e.g., GET, POST, PATCH, DELETE) used in your request matches the method expected by the Base API for the specific operation. For example, listing records typically uses GET, while creating new records uses POST.

• Content-Type Header:

  • Correct Header: For requests sending data in the body (like POST or PATCH), ensure the Content-Type: application/json header is present if you are sending JSON data.

• Review Error Messages:

  • Server Response: Carefully read any error messages returned in the API response body. These messages often provide specific details about what went wrong (e.g., "Invalid API key," "Resource not found," "Permission denied").
  • HTTP Status Codes: Pay attention to the HTTP status code returned (e.g., 401 Unauthorized for authentication issues, 403 Forbidden for permission problems, 404 Not Found for incorrect URLs, 500 Internal Server Error for server-side issues). Understanding HTTP status codes helps diagnose the problem category.

• Check Permissions:

  • Key Scope: Some API keys might have limited permissions. Verify in your Base workspace settings that the API key you are using has the necessary permissions to perform the action you are attempting (e.g., read access to the specific table).

• Rate Limits:

  • Exceeded Limits: If you are making many requests quickly, you might be hitting Base's API rate limits. Check the response headers for X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset, if provided, to understand your current status.