--- title: Quickstart description: >- Get from zero to working with Boost.space — as a product user, connecting an AI agent, or building on the API. Pick your path. --- # Quickstart Three ways to start, depending on what you're doing. Pick your path. ## For product users 1. **[Open the app](https://gate.boost.space)** and sign in. 2. **[Create a space](/guides/spaces/how-do-i-create-a-space)** in a module. 3. **[Add records](/guides/records/manage-records)** manually, or **[import them from a file](/guides/working-with-data/import-data-from-file)**. 4. **[Add fields](/guides/fields/custom-fields-creation-usage)** so the data matches your process — or generate them with AI. 5. **[Invite your team](/guides/settings/inviting-users-and-setting-up-teams-admin)** and set [space roles](/guides/spaces/space-roles-members-managers-and-owners). ## For AI agents The zero-setup way: open the **[Agent Chat](/ai/ai-features/agent-chat)** (the **Agent** button in the sidebar) and just start asking. To bring your own agent instead: 1. Create an **[MCP token](/ai/mcp/server/token-creation)** and copy your connection URL. 2. Add Boost.space as a connector in **[Claude, ChatGPT, Cursor, or any MCP client](/ai/mcp/server/common-mcp-clients)**. 3. Ask the agent to read or change your data — it acts within your token's permissions. See **[Connect via MCP](/ai/mcp/server/connect-via-mcp)**. ## For developers 1. Create an **API token** in your profile (see the [API](/api-reference)). 2. Call the API — base URL `https://{system}.boost.space/api`, Bearer auth: ```bash curl https://{system}.boost.space/api/space \ -H "Authorization: Bearer $BS_TOKEN" ``` 3. Prefer a typed client? Install an **[SDK](/sdk)** (TypeScript, Python, PHP, or Go). ## Next steps - Understand the model in **[Core concepts](/core-concepts)**. - Explore the **[product guides](/guides/modules)** and the **[API](/api-reference)**. - Get help in **[Support & resources](/support)**. --- title: What is Boost.space? description: >- Boost.space is the unified data foundation that AI agents run on — connect your tools, keep products, customers, and orders in sync, and let agents act on clean, structured, permission-scoped data. --- # What is Boost.space? Boost.space is a **unified data foundation for your business — built so AI agents can actually run on it**. Most AI projects fail because the data behind them is broken. Boost.space fixes the data first: it connects the tools you already use, keeps your products, customers, orders, and campaigns in sync in both directions, and gives every AI agent one clean, structured place to read and act. ## The idea in one picture 1. **Connect your data** — plug in your e-shop, CRM, ERP, suppliers, and ad platforms (**2,600+ native integrations**). Everything flows into one foundation, synced both ways. 2. **Let agents work on it** — deploy ready-made AI agents for product operations, connect your own over [MCP](/ai/mcp/server/for-agents), or build on the [API](/api-reference) and [SDKs](/sdk). 3. **Results write back** — agents make decisions on live data and write the results back into your systems. These docs cover the foundation itself: [modules](/guides/modules), [spaces](/guides/spaces), [records](/guides/records), and typed [fields](/guides/fields) — plus the [automation](/guides/automation), [AI](/ai), [MCP](/ai/mcp), and developer surfaces built on top. ## Why the foundation matters for AI The same qualities that make data usable by people make it usable by agents: - **Typed fields** — a date is a date, a price is a price; agents read and write without guesswork. See [Field types](/guides/fields/custom-field-types-in-boost-space). - **Relational links** — [linked records](/guides/fields/linked-records) connect products to suppliers, orders to customers — so agents can traverse context, not just rows. - **Deduplicated by design** — the [key field](/guides/fields/key-column) and [source priority](/guides/working-with-data/api-token-prioritization-data-consolidation) keep one clean record per real-world entity, no matter how many tools feed it. - **Permission-scoped** — an agent over [MCP](/ai/mcp/server/for-agents) sees and changes only what the connecting user can. No separate security model. ## How it compares - **Unlike standalone AI tools**, which are only as smart as the data you paste into them — Boost.space prepares the data first, so AI executes with full business context. - **Unlike a traditional PIM**, it unifies products *and* customers, orders, and campaigns on one foundation. - **Unlike a CDP**, it goes deep on product data — built for product-led businesses with complex catalogs across channels and markets. - **Integration platforms (Make, n8n, Zapier)** sit *on top* of it: Boost.space is the data layer underneath — it completes them, not competes with them. ## Who it's for Built for **retailers and brands selling across multiple channels and markets** — pulling data in from suppliers, pushing it out to marketplaces, franchises, and partners — and for the **operations and AI teams** who need a governed, structured backend their agents can trust. Trusted by 15,000+ teams across 140 countries; security and compliance live at the [Trust Center](https://trust.boost.space) (GDPR, ISO 27001, SOC 2, HIPAA). ## Where to go next - Get working fast with the **[Quickstart](/quickstart)**. - Learn the data model in **[Core concepts](/core-concepts)** and the **[product guides](/guides/modules)**. - Connect an agent — **[Boost.space for AI agents](/ai/mcp/server/for-agents)**. - Build on the data with the **[API](/api-reference)** and **[SDKs](/sdk)**. --- title: Support & resources description: Where to get help, check status, review security, and find the legacy documentation. --- # Support & resources ## Get help - **Ask AI** — the fastest answer. It's at the top of every page of these docs and answers from the documentation itself. - **Contact us:** [boost.space/contact](https://boost.space/contact) — for anything Ask AI can't resolve (account, billing, Enterprise features). Or email [support@boost.space](mailto:support@boost.space). - **Open the app:** [gate.boost.space](https://gate.boost.space) - **Release notes:** [boost.space/blog/category/release-notes](https://boost.space/blog/category/release-notes) - **Blog:** [boost.space/blog](https://boost.space/blog) ## Trust & reliability - **Trust Center** (security, compliance, privacy): [trust.boost.space](https://trust.boost.space) - **System status** (uptime & incidents): [status.boost.space](https://status.boost.space) ## For developers - **[API Reference](/api-reference)** — the full REST API. - **[SDKs](/sdk)** — TypeScript, Python, PHP, Go. - **[Changelog](/changelog)** — API and SDK changes. - **AI-readable docs:** [`/llms.txt`](/llms.txt) and [`/llms-full.txt`](/llms-full.txt). ## FAQ **I forgot my password.** Use *Forgot your password?* on the login screen — instructions arrive by email. See [Change or reset your password](/guides/account/password-change-reset). **I lost my 2FA device.** Sign in with one of the **backup codes** you saved when enabling 2FA, then re-enroll. See [Two-factor authentication](/guides/account/two-factor-authentication-2fa). **I need to change my account email.** That's one for [support@boost.space](mailto:support@boost.space) — include your system name, old email, and new email. **Imports keep creating duplicates.** Set a **[key field](/guides/fields/key-column)** on the space — incoming data then updates the matching record instead of adding a new one. **My MCP/API token has the wrong permissions.** Tokens can't be edited after creation — create a new one with the scopes you need. See [API tokens and MCP tokens](/ai/mcp/server/token-creation). **I hit my record limit.** Delete old records to free room, or upgrade your tier — see [Plans and usage limits](/guides/billing/plans-tiers-usage-limits). **Something looks broken in the app.** Open the **[Status center](/guides/account/status-center)** — it checks your connection, data sync, browser, and security settings, and tells you what to fix. ## Legacy & older plans On an older plan, or using the classic modules, the Integrator, or the legacy API? See **[Legacy & older plans](/guides/billing/legacy)** — it maps each legacy feature to today and links the separate **[legacy documentation](https://legacy-api.boost.space)** (classic modules, the Integrator, the app marketplace, and the full legacy API reference). --- title: Modules description: >- Modules are the data types your Boost.space database is built from. Build the modules you need — including with AI — and organize them into spaces, records, and fields. --- # Modules A **module** is a type of data at the top of the Boost.space data model — the tables of your database. Boost.space is **modular**: you build the modules you need and add more as you grow. Each module is a database of [records](/guides/records), organized into [spaces](/guides/spaces) and described by [fields](/guides/fields). ## Build the modules you need Modules are **fully customizable** — define a module's name, icon, [spaces](/guides/spaces), [key field](/guides/fields/key-column), permissions, and [fields](/guides/fields) to match your exact process. You can also **generate fields with AI** while building a module. See [Create a module](/guides/modules/boostspace-bs-custom-module-2) for the step-by-step. ## Modules interconnect automatically Modules connect to each other out of the box, so data flows between them without manual setup — for example, a won opportunity can create a follow-up order in another module. ## Build on custom modules **Start every new project from a custom module you design yourself.** That is where the work has gone and where it keeps going: you define the fields, the structure, and the behaviour, so the module fits the data instead of the data being bent to fit the module. The classic named modules — Tasks, Contacts, Products, Invoices, Warehouses — came from an earlier generation of Boost.space, when each one was pre-designed for you. Custom modules now cover what they did and more, so the classic ones are **not** the place to begin something new. They are documented in the [legacy documentation](https://legacy-api.boost.space) for the systems still on them. ## One module, one kind of data Give each kind of data its own module, and use [spaces](/guides/spaces) for variations of the same kind. A module has a view across all of its spaces at once, and that view unions the fields of every space beneath it — so spaces holding similar records produce a readable overview, while unrelated records crammed into one module produce a very wide table of mostly empty columns. See [Spaces overview](/guides/spaces) for the longer version. ## Admins manage modules **System administrators** create and configure modules, then make them available to other users. For per-module configuration, see [Individual modules – setup (admin)](/guides/modules/setting-up-individual-modules-admin). ## Learn more - [Create a module](/guides/modules/boostspace-bs-custom-module-2) — build your own, step by step - [Hierarchy – modules, spaces and records](/guides/modules/hierarchy-modules-spaces-and-records) - [Navigating the modules](/guides/modules/navigating-through-the-modules) > Looking for the classic named modules (Tasks, Contacts, Invoices, Products…) or their setup? > Those are documented in the [legacy documentation](https://legacy-api.boost.space). --- title: Glossary description: Definitions of the core Boost.space terms. --- # Glossary The terms you'll meet across Boost.space, in one place. **Action** — What an [automation](/guides/automation) does when it fires: a notification, an email, a webhook, or your own code. See [Actions and triggers](/guides/automation/actions-and-triggers). **Admin** — A [system role](/guides/settings/system-roles-users-and-admins) with full access: manage all levels, users, and settings; create fields and modules; configure automations. **Agent Chat** — The agent chat built into the app (the **Agent** button in the sidebar): ask questions, work with records, and build [automations](/guides/automation) in plain language. See [Agent Chat](/ai/ai-features/agent-chat). **AI agent** — An external AI assistant (Claude, ChatGPT, Cursor, and others) connected to your data over [MCP](/ai/mcp/server/connect-via-mcp). It can read and write your records within the connecting user's permissions. **AI credits** — The allowance that powers Boost.space's [AI features](/ai) and the [Agent Chat](/ai/ai-features/agent-chat). See [AI credits](/guides/billing/boost-space-4-0-ai-pricing). **AI field** — A [field](/guides/fields) whose value is generated or enriched by AI. See [AI fields](/ai/ai-features/ai-fields). **AI mapping** — Automatically analyzes incoming data during [import](/guides/working-with-data/import-data-from-file) and maps it to the right fields, recognizing the structure and suggesting new fields when needed. **API token** — A secure code that authenticates a user with the [REST API](/api-reference) and integrations. It can never have more rights than the user it belongs to. See [API tokens and MCP tokens](/ai/mcp/server/token-creation). **API token prioritization** — Priorities set on API tokens that decide which source wins during [data consolidation](/guides/working-with-data/api-token-prioritization-data-consolidation). **Automation** — Keeping data current automatically: native [actions and triggers](/guides/automation/actions-and-triggers), your own [code automations](/guides/automation/code-automations) in a secure sandbox, and [scenarios](/guides/automation/views) on your connected Make.com account. **Basic fields** — The system fields present on every record: ID, Space, [Status](/guides/fields/statuses), [Labels](/guides/fields/labels), Created time, Created by user, and Remote ID. Everything else is a [field](/guides/fields) you define. See [Fields](/guides/fields). **Boost.space system** — The platform that centralizes and synchronizes your company data from internal and external sources. Also called your *system instance*. See [System instance](/guides/settings/system-instance). **Category** — A group of people, used the same places a [team](/guides/settings/inviting-users-and-setting-up-teams-admin) is: space access, menu visibility, segment visibility. Every new user joins **Everyone** by default. **Code automation** — An automation step that runs your **Python** in a secure, isolated sandbox — written by you, your LLM, or the [Agent Chat](/ai/ai-features/agent-chat). See [Code automations](/guides/automation/code-automations). **Connection** — Authenticated access to an external app, used by Make.com [scenarios](/guides/automation/views) to read and write that app's data. **Custom branding** — Personalize the system's appearance: logos, login-screen backgrounds, favicons, and colors. See [Company design settings](/guides/settings/company-design-settings). **Data consolidation** — Merging data from multiple sources into one record, using the [key field](/guides/fields/key-column) to match and API token prioritization to decide which source wins. See [API token prioritization + data consolidation](/guides/working-with-data/api-token-prioritization-data-consolidation). **Field** — A typed attribute on a record (text, number, date, a relational link, a computed value). Fields were formerly called *custom fields*. See [Fields](/guides/fields). **Field group** — A named collection of [fields](/guides/fields). Every field belongs to at least one group, and a field can be shared across several groups. See [Field groups](/guides/fields/field-groups). **Formula field** — A [field](/guides/fields) that computes its value from other fields. See [Formula fields](/guides/fields/custom-fields-formula). **Key field** — The [field](/guides/fields) that identifies records in a [space](/guides/spaces) for merging. Essential for data consolidation — e.g. setting *email* as the key means incoming data with the same email updates the existing record instead of creating a duplicate. See [Key fields](/guides/fields/key-column). **Label** — A tag added to records to categorize and organize them. See [Record labels](/guides/fields/labels). **Licence** — Enables access to certain features and plan tiers. See [Plans, tiers and usage limits](/guides/billing/plans-tiers-usage-limits). **Linked record** — A [field](/guides/fields) that links a record to one or more records in another module — the basis for relationships and lookups. See [Linked records](/guides/fields/linked-records). **Lookup** — A read-only [field](/guides/fields) that pulls a value from a linked record, so related data appears without being duplicated. **Manager** — A [space](/guides/spaces) role that can manage members and other managers, manage records, and change space settings such as statuses and labels. See [Space roles](/guides/spaces/space-roles-members-managers-and-owners). **MCP (Model Context Protocol)** — The open standard that lets an [AI agent](/ai) read, write, and query your data in natural language. See [Connect via MCP](/ai/mcp/server/connect-via-mcp). **Member** — A [space](/guides/spaces) role that can view and manage records using existing statuses and labels, but cannot manage members or change space settings. See [Space roles](/guides/spaces/space-roles-members-managers-and-owners). **Menu editor** — Customize the system's navigation: menus, folders, shortcuts, and embedded content, tailored per user. See [Menu editor](/guides/settings/menu-editor). **Module** — A type of data in your system — a table in your database. Modules hold [spaces](/guides/spaces) and [records](/guides/records); you create the modules your business needs, each with its own structure. **Multicurrency database** — Modules that work with currencies can store exchange rates and recalculate prices automatically. **Multilingual database** — Store your data in multiple languages. **Owner** — A [space](/guides/spaces) role with full control: manage members, managers, and owners; manage records; edit space settings; and delete the space. See [Space roles](/guides/spaces/space-roles-members-managers-and-owners). **Record** — A single data entry in a module — a row in the table (a company, a deal, a ticket). See [Records](/guides/records). **Remote ID** — The identifier a record carries from the external system it came from, used to match and update the right record on re-sync (upsert). See [Remote IDs](/guides/working-with-data/remote-ids). **Rollup** — A field that aggregates a value across [linked records](/guides/fields/linked-records) — a sum, count, minimum or maximum — and keeps it current. See [Rollup fields](/guides/fields/rollup). **Sandbox environment** — A copy of your system instance for risk-free testing. Regenerate it any time to match your main instance. See [Sandbox environment](/guides/settings/sandbox-environment). **Scenario** — A visual automation (a trigger plus steps that move and transform data) that runs on your connected Make.com account against your Boost.space data. See [Views](/guides/automation/views). **SDK** — A typed client for the [REST API](/api-reference), so you write Boost.space calls in your own language instead of assembling HTTP by hand. See [SDK](/sdk). **Segment** — A saved filter over a [module](/guides/modules) that shows only the matching records. Used both as a standing queue of work to do and as a throwaway view for a one-off job; records leave a segment on their own once they stop matching. See [Segmenter](/guides/working-with-data/segmenter). **Space** — A container within a module that groups records (e.g. *EU pipeline* and *US pipeline* inside a Deals module). Access is restricted to users who created it or were granted access. See [Spaces](/guides/spaces). **Status** — An indicator assigned to a record to represent its state or progress — system-defined (e.g. *Active*, *Done*) or custom. See [Record statuses](/guides/fields/statuses). **System instance** — A distinct environment for a team or organization: all its users, modules, spaces, records, and configuration. Every customer gets their own, on their own domain. See [System instance](/guides/settings/system-instance). **System key** — A unique identifier for your Boost.space system, used for secure connections across integrations. See [System name and system key](/guides/settings/system-name-system-key). **System roles** — The two roles: **Admin** (full permissions) and **User** (acts within permissions granted by an admin). See [System roles](/guides/settings/system-roles-users-and-admins). **System settings** — The admin-only settings (fields, actions and triggers, design, and more). See [System settings](/guides/settings/system-settings). **Team** — A named group of people. A team can be granted a [space role](/guides/spaces/space-roles-members-managers-and-owners), so everyone in it inherits that access — the maintainable way to run permissions, because you change the team rather than every space. Managed in **Settings → Teams**; which spaces a team reaches is set from each space. See [Inviting users and setting up teams](/guides/settings/inviting-users-and-setting-up-teams-admin). **Trigger** — What starts an [automation](/guides/automation): a record being created, updated or deleted, or a schedule. See [Actions and triggers](/guides/automation/actions-and-triggers). **User** — Uses the system within the rights an admin assigns, usually inherited through [team](/guides/settings/inviting-users-and-setting-up-teams-admin) membership. See [System roles](/guides/settings/system-roles-users-and-admins). **Vector database** — Turns the text in a space's records into embeddings so agents and search can match records by **meaning** rather than exact words. See [Vector database](/ai/ai-features/vector-database). **Webhook** — A way for an app to send real-time data to a URL in response to an event. As an [automation](/guides/automation) action, Boost.space calls a URL you choose when a record changes, and the payload can carry [dynamic values](/guides/automation/actions-and-triggers) from that record. --- title: Hierarchy – modules, spaces and records description: >- Boost.space organizes data in three levels — modules, spaces, and records. Learn how they nest, and how modules differ from spaces. --- # Hierarchy – modules, spaces and records A Boost.space system can run anywhere from one to dozens of [modules](/guides/modules) at once. Thanks to one uniform structure — **modules → spaces → records** — it stays clear at any size, for people and for [AI agents](/ai/mcp/server/for-agents) alike. Say you've built a simple CRM with three modules: **Companies**, **Deals**, and **Tickets**. ## Modules A [module](/guides/modules) is a **type of data** — a table you design, with its own [fields](/guides/fields). Admins create and configure modules; every user works in them. **Example:** the **Deals** module — with fields like *Value*, *Stage*, and a [link](/guides/fields/linked-records) to **Companies**. ## Spaces A [space](/guides/spaces) groups records **inside** a module. A module can hold unlimited spaces, any user can create one, and access is per space. **Example:** the Deals module split into spaces per team — **EU pipeline** and **US pipeline**. ## Records A [record](/guides/records) is a **single row** in a space. What it represents depends on the module. **Example:** one deal — *"Acme renewal, €12,000, Negotiation"* — inside the EU pipeline space. ## Modules vs. spaces They're easy to confuse, but they do different jobs: | | Module | Space | |---|---|---| | **What it is** | A type of data — the table and its fields. | A container that groups records in a module. | | **Job** | Defines the structure. | Organizes data and controls access. | | **Created by** | Admins. | Any user. | | **Example** | Deals | EU pipeline | In short: **modules define the structure; spaces organize and protect the data** inside it. This same three-level shape is what agents traverse over [MCP](/ai/mcp/server/for-agents) and what the [API](/api-reference) exposes. ## Next - [Create a module](/guides/modules/boostspace-bs-custom-module-2) · [Space settings](/guides/spaces/space-settings) - [Manage records](/guides/records/manage-records) · [Field types](/guides/fields/custom-field-types-in-boost-space) --- title: Core concepts description: >- The vocabulary of Boost.space — modules, spaces, records, fields, field groups, automation, MCP, and the API — and how they fit together. --- # Core concepts A quick mental model of Boost.space. Each term links to its full guide. ## Data structure | Concept | What it is | |---|---| | **[Module](/guides/modules)** | A type of data — the tables of your database. You build the modules your process needs. | | **[Space](/guides/spaces)** | A container that groups records within a module, with its own roles and access. | | **[Record](/guides/records)** | A single row of data in a module (one contact, one task). | | **[Field](/guides/fields)** | A single typed attribute on a record — text, number, date, a relational link, or a computed value. | | **[Field group](/guides/fields/field-groups)** | A named collection of fields. Every field belongs to at least one group; a field can be shared across several. | | **[Key field](/guides/fields/key-column)** | The field that identifies a record for merging, so imports and syncs update instead of duplicate. | ## Working with data | Concept | What it is | |---|---| | **[Linked records](/guides/fields/linked-records)** | Relationships between records — link one record or many, and pull values across with lookups. | | **[Segmenter & filters](/guides/working-with-data)** | Slice large datasets by conditions, labels, status, and users. | | **[Data consolidation](/guides/working-with-data/api-token-prioritization-data-consolidation)** | Merging data from multiple sources into one record, using the key field and source priority. | | **[Users & teams](/guides/settings/system-roles-users-and-admins)** | Members, roles, and permissions across spaces and the system. | ## Connecting & automating | Concept | What it is | |---|---| | **Automation** | Keeping data current automatically — native [actions and triggers](/guides/automation/actions-and-triggers), plus scenarios that run on your connected **Make.com** account. | | **Scenario** | A visual automation (a trigger plus steps that move and transform data) running on Make.com, connected to your Boost.space data. | | **Connection** | Authenticated access to an external app, used by scenarios to read and write that app's data. | ## Building on top | Concept | What it is | |---|---| | **[MCP](/ai/mcp/server/connect-via-mcp)** | Lets AI agents read, write, and query your data in natural language over the Model Context Protocol — within the connecting user's permissions. | | **[AI features](/ai)** | AI built into your records: AI fields, text manipulation, and whole-column transformation and validation. | | **[REST API](/api-reference)** | The programmatic surface. One base URL per tenant: `https://{system}.boost.space/api`. | | **[SDKs](/sdk)** | Typed clients for TypeScript, Python, PHP, and Go. | | **System** | Your Boost.space tenant, identified by its name (e.g. `acme` → `acme.boost.space`). | Want the full vocabulary? See the **[Glossary](/glossary)**. Ready to try it? See the **[Quickstart](/quickstart)**. --- title: Build a module with AI description: >- Let AI create a module tailored to your needs — describe the purpose or paste a sample record, or start from a ready-made template. --- # Build a module with AI The fastest way to a new [module](/guides/modules): describe what you want to track, and AI generates the module with a fitting set of typed [fields](/guides/fields). No schema design up front — generate, review, refine. ## Generate a module When you create a module, Boost.space opens the **Build a module with AI** screen: 1. **Describe the purpose or give a sample record** in the AI Prompt field — e.g. *"A recruitment pipeline: candidates with role, stage, salary expectation, CV attachment, and interviewer."* Pasting a sample record (even raw JSON) works too — AI derives the structure from it. 2. Or start from a **template** — one click on **Contacts, Products, Deals, Tasks, Order, Campaigns, Emails,** or **Shipments** pre-fills a proven structure you can adjust. 3. Click **Generate**. 4. **Review the proposal** — edit or delete any field, or prompt again to refine — then save. Prefer to design everything by hand? Choose **From scratch** — see [Create a module](/guides/modules/boostspace-bs-custom-module-2). > AI generation runs on [AI credits](/guides/billing/boost-space-4-0-ai-pricing). ## Why start with AI - **Typed from day one** — AI picks real [field types](/guides/fields/custom-field-types-in-boost-space) (dates, selects, links, money), so the data is filterable, automatable, and [agent-ready](/ai/mcp/server/for-agents) immediately. - **You keep control** — everything AI generates is a normal module; tune fields any time in [field settings](/guides/fields/custom-fields-creation-usage). - **Works from what you have** — a pasted sample record or JSON becomes a matching structure. ## Next - [Create a module](/guides/modules/boostspace-bs-custom-module-2) (manual) · [Field types](/guides/fields/custom-field-types-in-boost-space) · [Import data from a file](/guides/working-with-data/import-data-from-file) --- title: Module settings description: >- Boost.space is modular — admins add, remove, and configure modules in System settings, and each module has its own settings for lists, types, statuses, and labels. --- # Module settings Boost.space is **modular**: choose which [modules](/guides/modules) you need, and add more as you grow. Modules work independently, so you can adopt the system one module at a time. ## Install and remove modules **System administrators** add and remove modules at any time in **System settings → Modules**. A newly added module is **automatically connected** to your other modules, so data flows between them without manual setup. ![Managing modules in System settings](/img/guides/modules/setting-up-individual-modules-admin-1.webp) ## Per-module settings Every module has its own settings, found in **System settings**. What's available depends on the module — for example: - lists and categories (e.g. a catalog's categories and attributes) - custom item and record types - [statuses](/guides/fields/statuses) and [labels](/guides/fields/labels) - module-specific options ![A module's settings in System settings](/img/guides/modules/setting-up-individual-modules-admin-2.webp) To build a module from scratch — including its spaces, key field, and fields — see [Create a module](/guides/modules/boostspace-bs-custom-module-2). --- title: Space settings description: >- Everything you configure on a space — status, key field, description, vectorization, field groups, statuses, and native automations. --- # Space settings Every [space](/guides/spaces) has its own settings, tailored to what it holds. Open them by **editing the space** (the pencil or **⋮** next to the space name). Use **Go to Module Settings** for settings that apply to the whole [module](/guides/modules). ## Basics - **Status** — the space's own status (e.g. *Active*), so you can archive or pause a space without deleting it. - **Key field (avoid duplicates)** — the [key field](/guides/fields/key-column) used to match incoming records so imports and syncs update the right record instead of creating duplicates. - **Space description** — a short description of what the space holds. Besides documenting it for your team, the description **gives AI agents context** about the space over [MCP](/ai) — worth filling in for any space an agent will work with. ## Vectorization Switch on **Vectorization** to embed the space's records so AI and search can match them **by meaning**. Every text and rich text field in the space is embedded automatically — there is nothing to choose field by field, and no upkeep once it is on. This is the Enterprise **[vector database](/ai/ai-features/vector-database)** — ideal for giving agents relevant context from large spaces. ## Structure - **Field groups** — connect [field groups](/guides/fields/field-groups) to the space to decide which fields it has. You can reuse a group **from another module**, not just this one. - **Statuses** — manage the [statuses](/guides/fields/statuses) available in this space. ## Automation & history - **Triggers and actions** — the space's **native** [actions and triggers](/guides/automation/actions-and-triggers): when a record changes, send a **webhook**, **notification**, or **email**. This runs inside Boost.space — it's separate from [Make scenarios](/guides/automation/views). - **Logs** — a history of changes made in the space, for auditing. ## Next - [Create and manage a space](/guides/spaces/how-do-i-create-a-space) · [Space roles and permissions](/guides/spaces/space-roles-members-managers-and-owners) - [Key fields](/guides/fields/key-column) · [Field groups](/guides/fields/field-groups) --- title: Records overview description: >- Records are the rows of your Boost.space database — the data inside a space. Learn what records are, how they're displayed, and everything you can do with them. --- # Records overview Records are the **rows of your database** — the actual data inside a [space](/guides/spaces). What a record represents depends on its [module](/guides/modules): in a CRM you've built, a record is a company, a deal, or a ticket. Any user with access to a space can create and manage its records — and so can [AI agents over MCP](/ai/mcp/server/for-agents) and your code over the [API](/api-reference), within the same permissions. > Your plan sets a **record limit** — the maximum number of records across all your databases. > Free up room by deleting old records. ## Anatomy of a record Every record carries the system-maintained **[basic fields](/fields/custom-field-types-in-boost-space#basic-fields)** (ID, Space, Status, Labels, Created time, Created by user, Remote ID) plus the **[fields](/guides/fields)** its space's field groups define. Its [status](/guides/fields/statuses) tracks progress, [labels](/guides/fields/labels) categorize it, and [links](/guides/fields/linked-records) connect it to records in other modules. ## Views Records display in a **table** by default — filter, sort, and calculate on columns. Modules can offer additional layouts for their data, and saved filters become reusable **[Views](/guides/working-with-data/how-do-i-filter-records)** shared with your team. ## Working with records - **Create, edit & delete** — [Manage records](/guides/records/manage-records) - **Import** — [Import data from a file](/guides/working-with-data/import-data-from-file) - **Organize** — [Filtering & Views](/guides/working-with-data/how-do-i-filter-records) · [Segmenter](/guides/working-with-data/segmenter) · [Labels](/guides/fields/labels) · [Statuses](/guides/fields/statuses) - **Relate & compute** — [Linked records](/guides/fields/linked-records) · [Calculations on columns](/guides/working-with-data/calculations-on-columns) - **At scale** — [Bulk actions and exporting](/guides/working-with-data/bulk-actions-and-exporting) · [Data consolidation](/guides/working-with-data/api-token-prioritization-data-consolidation) - **Collaborate** — [Comments](/guides/collaboration/comments) · [Notifications](/guides/collaboration/notifications) --- title: Spaces overview description: >- Spaces group the records inside a module into clear, access-controlled containers — with their own settings, roles, and structure. --- # Spaces overview A **space** is a container that groups records inside a [module](/guides/modules). Each module can hold an unlimited number of spaces and subspaces, so it stays organized and clear even with a large amount of data. ## Where spaces sit in the data model | Level | What it is | Example | |---|---|---| | **[Module](/guides/modules)** | A type of data — the table. | Deals | | **Space** | A container that groups records within that module. | EU pipeline | | **[Record](/guides/records)** | A single row of data. | One deal | See [Hierarchy – modules, spaces and records](/guides/modules/hierarchy-modules-spaces-and-records) for the full picture. ## Why use spaces - **Keep a module readable** — split its data into logical groups: by team, client, region, or dataset. - **Control access per space** — only the creator and invited users can open a space; what each can do is set by their [space role](/guides/spaces/space-roles-members-managers-and-owners). - **Give each space its own setup** — statuses, connected [field groups](/guides/fields/field-groups), a [key field](/guides/fields/key-column) for deduplication, and native automations. See [Space settings](/guides/spaces/space-settings). ## One module, one kind of data Because a module can hold any number of spaces, it is tempting to make one module the home for everything and separate the different kinds of data into spaces — products in one, contacts in another, contracts in a third. It works, right up until someone opens the module's own view of all its records. That view is the union of every field in every space beneath it. Spaces holding the same kind of data share their fields, so the view stays tight and readable. Spaces holding *different* kinds of data have almost no fields in common, so the union becomes a very wide table where nearly every cell is blank — a contact has no delivery weight, a contract has no stock level — and the one view that should give you the overview becomes the least usable screen in the system. **So give each kind of data its own module, and use spaces for variations of it.** Five spaces for five product ranges is exactly what spaces are for; the records still look alike, so the module view still reads. Products, contacts, and contracts are three modules. Small structural differences between spaces in one module are fine and normal. It is the mixing of genuinely unrelated record shapes that costs you the module view. ## Spaces and agents A space is also the unit an [AI agent](/ai/mcp/server/for-agents) works in: its **description** tells the agent what the data holds, its **key field** makes agent writes deduplicate safely, and **[vectorization](/ai/ai-features/vector-database)** makes its records semantically searchable. ## Parent and child spaces Spaces can nest inside a module: a **parent space** stands on its own, a **child space** belongs to it — for example a parent *Clients* space with a child space per region. You choose this when [creating a space](/guides/spaces/how-do-i-create-a-space). ## Next - [Create and manage a space](/guides/spaces/how-do-i-create-a-space) - [Space settings](/guides/spaces/space-settings) · [Space roles and permissions](/guides/spaces/space-roles-members-managers-and-owners) - [Add records](/guides/records/manage-records) --- title: The record detail description: >- What's inside a record's detail — basic information, field groups, attachments — and the actions you can take from it. --- # The record detail Open any record (the **pen icon** on its row) and you land in its **detail** — everything the record holds, ready to edit. ## What you'll find - **Basic information** — the system-maintained [basic fields](/fields/custom-field-types-in-boost-space#basic-fields): Status, Labels, Remote ID, Created time, and Created by user, with the record's **Space** up top. - **Your fields**, organized by [field group](/guides/fields/field-groups) — every group connected to the record's space renders as its own collapsible section. Empty fields are tucked away with an **Empty (N)** counter, so the detail stays focused on what's filled; expand to see them all. - **Attachments** — the record's files and images, in their own section. - **[Comments](/guides/collaboration/comments)** — on modules that support them, the discussion and activity trail. ## What you can do - **Edit** — the detail opens ready to edit: change any field and hit **Save**. - **Follow** — the **tracking icon** subscribes you to [notifications](/guides/collaboration/notifications) for a record you're not assigned to. - **Delete** — the trash icon, always with a confirmation; see [Manage records](/guides/records/manage-records). > The detail shows exactly what the [API](/api-reference) and > [agents over MCP](/ai/mcp/server/for-agents) see — the same fields, statuses, labels, and files, scoped by > the same permissions. The **Remote ID** even shows which external system a record came from > (`application: id`). ## Next - [Manage records](/guides/records/manage-records) · [Fields overview](/guides/fields) · [Field groups](/guides/fields/field-groups) # Create and manage fields **Fields** hold the data on your records. They were formerly called _custom fields_, and the term still appears in a few places, but the concept is the same: a typed column you define. Fields are part of your system's structure, so **only admins create them**; every user can then fill them in. Each field belongs to at least one **[field group](/guides/fields/field-groups)** — the container that organizes fields within a module. [Fields](https://fast.wistia.net/embed/iframe/s19bt5n7xz?seo=true\&videoFoam=true) ## Two ways to create fields Open **System settings → \[your module] → Fields**, pick or create a [field group](/guides/fields/field-groups), then either: 1. **Add one field** — click **New field** and define it in the field editor (below). 2. **Generate many with AI** — describe what you need in plain language (or paste JSON) and let AI propose a set of fields. Review, edit, or delete the suggestions, and prompt again to refine. ![Generating fields with AI](/img/guides/fields/custom-fields-creation-usage-1.webp) ## The field editor Every field has a **type** and a **name**; the rest depends on the type. * **Type** — what the field stores. See [Field types](/guides/fields/custom-field-types-in-boost-space). * **Name** — the label users see. Boost.space derives a stable API name from it (editable under **Advanced settings → API values**). * **Field group(s)** — the [group](/guides/fields/field-groups) the field belongs to. Type-specific options appear as you choose a type — for example: * **Select / Multi select / Radio** — the list of **options** (color, label, stored value). * **Money** — the **currency**; **Percent** — an optional **0–100** limit. * **Link a single/multiple record** — the **target module** and **spaces**, and an optional **counterpart** field created on the other side of the relation. * **Lookup / Rollup** — the relation to follow and the value or aggregation to pull. * **[Formula](/guides/fields/custom-fields-formula)** — the expression. * **[AI field](/ai/ai-features/ai-fields)** — the prompt, execution mode (automatic or manual), and tone/length/formatting/creativity. * **Button** — the action to trigger. ### Advanced settings * **Help text** — a tooltip shown next to the field. * **API values** — the field's system name for the API and imports. * **Required** — the field must be filled before a record can be saved. * **Enable multiple field groups** — lets the field belong to **more than one** [field group](/guides/fields/field-groups). With it off, the field lives in a single group. * **Primary label** — use this field as the record's title (the label shown wherever the record is referenced). Available for text-like and select fields on supported modules. ## Update or delete a field Reopen a field from its group to change its settings, move it between groups, or adjust which spaces it appears in. To remove it, open it and choose **Delete**. > Basic fields (ID, Space, Status, Labels, Created time, Created by user, Remote ID) are system fields — you can't edit or delete them. See [Field types](/fields/custom-field-types-in-boost-space#basic-fields). ## Next * [Field types](/guides/fields/custom-field-types-in-boost-space) · [Field groups](/guides/fields/field-groups) * [Key fields](/guides/fields/key-column) · [Linked records](/guides/fields/linked-records) --- title: Text fields description: >- The text field types in Boost.space — Text, Long text (Wysiwyg), Email, and Website — what each stores, how it behaves, and when to use it. --- # Text fields Text fields store written content, from a short single line to formatted rich text. Boost.space has four. ## Text A single line of plain text with no formatting — the workhorse field. - **Stores:** one line of text. - **Behaves:** shows inline; filter with *contains / starts with / ends with / equals*; sorts alphabetically. Can be a record's **primary label** and its **[key field](/guides/fields/key-column)**. - **Use for:** names, titles, SKUs, reference numbers, short notes. ## Long text (Wysiwyg) Multi-line **rich text** with formatting — bold, lists, links, and inline images. - **Stores:** formatted multi-line content. - **Behaves:** opens a rich editor; supports inline **[AI text tools](/ai/ai-features/ai-powered-text-manipulation)** (shorten, rephrase, translate…). Not meant for sorting or exact-match filtering. - **Use for:** descriptions, meeting notes, long-form content. - **Text vs. Long text:** pick **Text** for short values you'll filter and sort on; pick **Long text** when you need paragraphs or formatting. ## Email An email address, validated and rendered as a clickable `mailto:` link. - **Stores:** one email address. - **Behaves:** click to compose; usable as a **[key field](/guides/fields/key-column)** (great for matching contacts on re-sync) and in [automation](/guides/automation). - **Use for:** contact email. ## Website A web address (URL), rendered as a clickable link. - **Stores:** one URL. - **Behaves:** opens in a new tab when clicked. - **Use for:** websites, social profiles, links to external documents. > **Forms** add more text-based fields for submissions — First name, Last name, Phone, and Address > parts. See [Field types](/fields/custom-field-types-in-boost-space#form-fields). ## Next - [Field types](/guides/fields/custom-field-types-in-boost-space) · [Number fields](/guides/fields/number-fields) · [Selection fields](/guides/fields/selection-fields) --- title: Selection fields description: >- Choice-based field types in Boost.space — Single select, Multi select, Radio button, and Checkbox — how to configure their options and when to use each. --- # Selection fields Selection fields let a record pick from a defined set of choices. They keep data consistent, filterable, and automation-friendly — far better than free text for anything with a fixed set of values. ## Defining options **Single select**, **Multi select**, and **Radio button** share an options list. Each option has: - a **color** — the colored chip shown on records, - a **label** — what people see, - a **value** — what's stored and sent to the [API](/api-reference) (set when the option is created). Keep a stable **value** while renaming a **label** and your filters, automations, and integrations keep working. ## Single select One option from the list, shown as a dropdown. - **Use for:** category, type, priority, stage — longer lists of mutually exclusive choices. - Can serve as a record's **primary label** or **[key field](/guides/fields/key-column)**. ## Multi select Several options from the list. - **Behaves:** shows multiple colored chips; filter with *is any of / is none of*. - **Use for:** tags, attributes, applicable regions. ## Radio button One option, shown as inline radio buttons rather than a dropdown. - **Use for:** short, always-visible either/or choices (2–4 options). - **Single select vs. Radio button:** both store one choice — radio shows every option inline; single select saves space with a dropdown. ## Checkbox A single true/false value. - **Behaves:** a simple toggle; filter by checked/unchecked; can drive [automation](/guides/automation/actions-and-triggers). - **Use for:** flags like *Active*, *Approved*, *Done*. For several independent yes/no flags, use several checkboxes or a Multi select. ## Next - [Field types](/guides/fields/custom-field-types-in-boost-space) · [Text fields](/guides/fields/text-fields) · [Number fields](/guides/fields/number-fields) --- title: Lookup fields description: >- A Lookup field displays a value from a record's linked records — read-only, always in sync with the source, chosen by relation and property. --- # Lookup fields A **Lookup** field pulls a value **from a record's linked records** and shows it here — read-only, without copying. It always reflects the source, so when the linked record changes, the lookup updates automatically. Lookups keep related data visible where you need it without duplicating it. > A Lookup **shows** a value; a **[Rollup](/guides/fields/rollup)** *aggregates* many linked values into > one. Both read through a [link field](/guides/fields/linked-records). ## Configure a Lookup Create a field, choose the **Lookup** type, and set two things: 1. **Relation** — the [link field](/guides/fields/linked-records) (Link single or multiple record) to read through. 2. **Property** — which field on the linked record(s) to display. > Example: on an **Order** linked to a **Customer**, add a Lookup with Relation = *Customer* and > Property = *Email* to show the customer's email on every order — always current, never retyped. ## How it behaves - **Read-only** — you can't edit a lookup directly; change the value on the linked record and the lookup follows. - **Single vs. multiple** — through a *Link single record* relation a lookup shows one value; through *Link multiple records* it shows the value from each linked record. - **Live** — it reflects the source in real time, and can be shown in the table, filtered, and used by [automation](/guides/automation). - **Not stored on the record** — because it's derived, it isn't a separate value you can overwrite; to change it, edit the source or the link. ## Lookup vs. Rollup vs. Formula | Need | Use | |---|---| | Show a value from a linked record as-is | **Lookup** | | Aggregate many linked values (sum, count, min/max…) | **[Rollup](/guides/fields/rollup)** | | Compute from fields **on the same record** | **[Formula](/guides/fields/custom-fields-formula)** | ## Next - [Linked records](/guides/fields/linked-records) · [Rollup fields](/guides/fields/rollup) · [Field types](/guides/fields/custom-field-types-in-boost-space) --- title: Files & people fields description: >- Field types for attachments and people in Boost.space — File, Image, and Users — what each stores, how it behaves, and when to use it. --- # Files & people fields These field types attach documents and images to a record, or link it to people in your system. ## File One or more file attachments of any type. - **Stores:** attached files (documents, PDFs, spreadsheets, archives…). - **Behaves:** lists the attachments on the record; upload, download, and remove them. With **custom file categories** enabled in [System settings](/guides/settings/system-settings), files can be organized by category (e.g. *contract*, *final*). - **Use for:** contracts, invoices, specs, any document that belongs to the record. ## Image Image attachments, previewed as thumbnails. - **Stores:** image files. - **Behaves:** shows thumbnails inline; accepts only images (otherwise identical to File). - **Use for:** product photos, logos, avatars, screenshots. - **File vs. Image:** use **Image** when you want thumbnail previews and only images; use **File** for any file type. ## Users One or more [users](/guides/settings/system-roles-users-and-admins) from your system. - **Stores:** links to real people (not free text). - **Behaves:** a user picker; assignments drive [notifications](/guides/collaboration/notifications) and can be used in [automation](/guides/automation/actions-and-triggers) — e.g. notify the assignee on a status change. - **Use for:** owner, assignee, reviewer, account manager. > To link a record to **another record** (not a user), use a relationship field — see > [Linked records](/guides/fields/linked-records). ## Next - [Field types](/guides/fields/custom-field-types-in-boost-space) · [Linked records](/guides/fields/linked-records) --- title: Formula fields description: >- Formula fields compute a value from other fields — read-only, validated live, and always up to date. Full function reference: math, logic, text, dates, arrays, conversion, and record metadata. --- # Formula fields A **Formula** field calculates its value from other fields in the same record. It's read-only and recomputes automatically whenever the fields it depends on change — totals, derived text, conditional logic, date math, and more. > Formula fields are available on higher plans — see the [pricing page](https://boost.space/pricing/). > To aggregate values *across linked records* instead, use a **[Rollup](/guides/fields/rollup)** field. ## Build a formula Create a field and choose the **Formula** type (see [Create and manage fields](/guides/fields/custom-fields-creation-usage)). In the editor you **insert other fields** and combine them with **functions** and operators (`+`, `-`, `*`, `/`, comparisons, and parentheses for grouping). Functions can be nested, and the editor **validates the formula live** — showing whether it's valid before you save. ## Function reference ### Math & numbers | Function | What it does | |---|---| | **Sum** | Adds two or more numeric values. | | **Subtract** | Subtracts the second value from the first. | | **Multiply** | Multiplies two or more values together. | | **Divide** | Divides the first value by the second. | | **Modulo** | Returns the remainder after division. | | **Power** | Raises a base to an exponent. | | **Square root** | Returns the square root of a number. | | **Absolute value** | Returns the non-negative value of a number. | | **Round** | Rounds to a given number of decimal places. | | **Round up** / **Round down** | Rounds away from / toward zero. | | **Ceil** / **Floor** | Rounds up / down to the nearest integer. | | **Average** | The arithmetic mean of the values. | | **Max** / **Min** | The largest / smallest value. | | **Count** | Counts non-empty numeric values. | | **Count all** | Counts all values, including empty ones. | ### Logic & comparison | Function | What it does | |---|---| | **If** | Returns one value if a condition is true, otherwise another. | | **Switch** | Compares an expression to multiple cases and returns the match. | | **AND** / **OR** | True if all / at least one value is truthy. | | **NOT** | Returns the opposite boolean. | | **XOR** | True if an odd number of arguments are truthy. | | **Equals** | True if two values are equal. | | **Greater than** / **Less than** | Compares two values. | | **Is empty** / **Is not empty** | Tests whether a value is empty. | | **Is error** | True if the value is an error. | ### Text | Function | What it does | |---|---| | **Concat** | Joins two or more text values into one string. | | **Length** | Number of characters in a text value. | | **Lowercase** / **Uppercase** | Changes text case. | | **Trim** | Removes leading, trailing, and duplicate whitespace. | | **Contains** | True if the text contains a substring. | | **Starts with** / **Ends with** | Tests a prefix / suffix. | | **Replace** | Replaces all occurrences of a substring. | | **Substring** | A part of the text from a start position and length. | | **Left** / **Right** | The first / last N characters. | | **Split** | Splits text into an array by a delimiter. | | **Index of** | Position of the first occurrence, or -1. | | **Format** | Fills a template by replacing `{0}`, `{1}`, … placeholders. | | **Regex match** | True if the text matches a regular expression. | | **Regex extract** | Returns the first regex match. | | **Regex replace** | Replaces regex matches with replacement text. | ### Date & time | Function | What it does | |---|---| | **Now** | Current date and time. | | **Today** | Current date, no time. | | **Date add** / **Date subtract** | Adds / subtracts a duration to a date. | | **Date difference** | Difference between two dates in a given unit. | | **Format date** | Formats a date as text using a pattern. | | **Year** / **Month** / **Day** | The year, month (1-12), or day (1-31). | | **Weekday** | Day of the week (1 = Monday … 7 = Sunday). | | **Is after** / **Is before** | Compares two dates. | | **Workdays** | Working days between two dates (Mon-Fri). | ### Arrays | Function | What it does | |---|---| | **Array join** | Joins array values into text with a separator. | | **Array unique** | Returns the unique values from an array. | | **Array length** | Number of items in an array. | ### Conversion | Function | What it does | |---|---| | **To number** | Converts a value to a number. | | **To string** | Converts a value to text. | | **To boolean** | Converts a value to a boolean. | | **To date** | Parses a value into a date. | ### Record | Function | What it does | |---|---| | **Record ID** | The unique ID of the current record. | | **Created at** / **Updated at** | When the record was created / last updated. | | **Created by user ID** | ID of the user who created the record. | | **Created by user name** | Name of the user who created the record. | ## Examples - **Line total** — `Round(Quantity * Price, 2)` - **Full name** — `Concat(First name, " ", Last name)` - **Fallback text** — `If(Is empty(Owner), "Unassigned", Owner)` - **Age in days** — `Date difference(Created at, Now, "days")` ## Next - [Rollup fields](/guides/fields/rollup) — aggregate across linked records - [Field types](/guides/fields/custom-field-types-in-boost-space) · [Number fields](/guides/fields/number-fields) --- title: Field groups description: >- Field groups organize the fields in a module. Learn how they work, the Basic information group, and how a single field can belong to several groups. --- # Field groups A **field group** is a named collection of [fields](/guides/fields) within a [module](/guides/modules). Groups keep a module's structure organized — related fields sit together, and you connect a group to a [space](/guides/spaces) to make its fields available there. **Every field belongs to at least one group.** Some modules ship with ready-made groups you can connect in a click; you can also build your own. ## The Basic information group Every module has a built-in **Basic information** group holding the [basic fields](/fields/custom-field-types-in-boost-space#basic-fields) — ID, Space, Status, Labels, Created time, Created by user, and [Remote ID](/guides/working-with-data/remote-ids). This group is managed by the system and can't be edited or removed. ## A field in more than one group A field can belong to **several groups at once**. When editing a field, turn on **Enable multiple field groups** (in Advanced settings) and pick every group it should appear in — useful when the same attribute is relevant to more than one part of a module. See [Create and manage fields](/guides/fields/custom-fields-creation-usage). ## Connect groups to a space Connecting a field group to a space makes its fields available on that space's records. Open the space's field settings to add or remove groups; expand a group to preview the fields it contains before connecting it. ## Control field visibility Connecting a group makes its fields *available*; you still choose which appear in the table. Click the **settings icon** at the top-right of the records table and toggle individual fields on or off. ![Toggling field visibility in the table](/img/guides/fields/field-groups-1.webp) ## Create a field group 1. Open **System settings → [your module] → Fields**. 2. Click **New field group**, give it a **name**, and choose the **spaces** it applies to. 3. Save, then add [fields](/guides/fields/custom-fields-creation-usage) to it. ## Next - [Create and manage fields](/guides/fields/custom-fields-creation-usage) · [Field types](/guides/fields/custom-field-types-in-boost-space) - [Key fields](/guides/fields/key-column) --- title: Import data from a file description: >- Import your data into Boost.space using CSV, XML, or XLSX files. Map fields, preview your data, and create fields automatically with AI assistance. --- # Import data from a file Import your own data into any [space](/guides/spaces) from a file — map it to existing [fields](/guides/fields) or create new ones automatically. With a [key field](/guides/fields/key-column) set on the space, an import **updates** matching records instead of duplicating them. ## Supported file formats You can upload the following file types: * **CSV** * **XLSX** * **XML** These formats allow you to import structured datasets from most external systems. ## How it works The import process consists of a few simple steps: 1. **Select Data destination.** Open the desired Module and choose the Space where your data will be imported. Then click **+ New Data source**. ![](/img/guides/working-with-data/import-data-from-file-1.webp) 2. **Choose source type.** Select the **Upload a file** option. ![](/img/guides/working-with-data/import-data-from-file-2.webp) 3. **Upload your data file** (e.g. CSV, XML, XLSX) and click **Continue**. ![](/img/guides/working-with-data/import-data-from-file-3.webp) 4. **Map Fields.** Boost.space uses AI to analyze your data structure and suggest the most suitable field setup. During the import process, you define how data from your file is mapped to fields in Boost.space. * Your uploaded data (e.g. CSV) is analyzed automatically * AI proposes matching **field types** * Each **source field** (from your file) is matched to a **target field** (in Boost.space) * You can map data to existing fields or create new ones * Unmapped columns can be created as new fields. ![](/img/guides/working-with-data/import-data-from-file-4.webp) 5. **Data preview.** Before importing, you can **review** your data: * See how fields are mapped * Validate values and formats * Identify missing or incorrect mappings Only valid data will be imported, helping you avoid errors. Click **Continue** to proceed. ![](/img/guides/working-with-data/import-data-from-file-5.webp) 6. **Start import.** Confirm and start the import process. ![](/img/guides/working-with-data/import-data-from-file-6.webp) 7. **View your Data.** Once the import is complete, your data will appear in the **selected Space** and is immediately ready to use. ![](/img/guides/working-with-data/import-data-from-file-7.webp) # Labels Label records to organize and find them faster. Boost.space has two types of labels: personal and shared. [Shared/personal labels](https://fast.wistia.net/embed/iframe/tco7vojopi?seo=true\&videoFoam=true) Labels can be set by both user and admin. The difference is that the admin has access to settings, so they can set labels globally or across multiple spaces. A user can only add labels in a space where they are a Manager or Owner — see [Space roles and permissions](/guides/spaces/space-roles-members-managers-and-owners). ## Personal labels Personal labels are user-specific and only visible to the user who created them, allowing for an individualized organization that is not visible to others. Personal labels are always located above the spaces at the module level. ## Shared labels Shared labels are assigned to spaces and are visible to all users. Each space can have a unique set of labels. If no label is assigned to a space in the settings (i.e., if nothing is marked), the label is considered global and will be visible across all spaces. **Personal and shared labels are available in the filtration panel or inside the record detail after clicking on the EDIT button.** ![](/img/guides/fields/labels-1.webp) ![](/img/guides/fields/labels-2.webp) --- title: Segmenter description: >- The Segmenter helps Boost.space users handle large datasets by creating filtered segments. This speeds up data loading and lets you reuse the same filter elsewhere in Boost.space. --- # Segmenter The Segmenter is a helpful feature for users who work with large datasets inside Boost.space. When a module contains many records, loading the full dataset can take time. The Segmenter helps by allowing you to load and view only a part of the data at once. Segments can be created only by administrators, ensuring consistent data management across the platform. ## When the segmenter is active The Segmenter can be: * **Turned on manually** in the System Settings, or * **Automatically activated** when a module contains **more than 70,000 records**. When it's active, the system loads only selected parts of your data instead of the whole module at once. This makes the interface faster and more responsive. ![](/img/guides/working-with-data/segmenter-1.webp) ## Creating a segment When you open a module, you will see a button at the top that says **"+ Segment"**. ![](/img/guides/working-with-data/segmenter-2.webp) You can create multiple segments, each with its own filter. Boost.space keeps the **last 5 opened segments** in the local cache. If you open a sixth one, the oldest one is removed from the cache. ![](/img/guides/working-with-data/segmenter-3.webp) When you add a New segment, a filter table appears. You can choose: * **Field** – e.g. Product ID, Creator, etc. * **Operator**– e.g. equals, greater than, starts with * **Value** – the value to compare This allows you to define exactly what records should be included in the segment. In addition, you can add multiple conditions to refine your segment even further. Conditions can also be grouped together, and for each group you can choose whether they should be connected by **AND** or **OR**: * **AND** means that records must meet _all_ selected conditions at the same time. * **OR** means that records can meet _any_ of the conditions to be included in the results. ![](/img/guides/working-with-data/segmenter-4.webp) Once saved, the segment appears in the top bar. Clicking it shows only the filtered records. You can also assign users who will be able to view this segment, making it easy to share relevant data with the right team members. ![](/img/guides/working-with-data/segmenter-5.webp) ## Segment actions Right-clicking on a segment opens a menu. One useful option here is **Copy filter**. This copies the segment's filter rules so you can reuse them elsewhere in Boost.space — for example when [filtering records](/guides/working-with-data/how-do-i-filter-records) in another view. ![](/img/guides/working-with-data/segmenter-6.webp) ## Two ways to use a segment Most people treat a segment as furniture: you build it once and it stays. That is one of its two jobs, and the less interesting one. **A standing queue.** A segment whose filter describes *work that needs doing* becomes a permanent attention list — records with a validation error, items waiting for approval, anything parked in a status a human has to clear. Because the filter is evaluated live, the list maintains itself: fix a record so it no longer matches and it leaves the segment on its own. Watching the count fall to zero is the progress bar. Put the ones people should check every day [in their menu](/guides/settings/menu-editor) so they do not have to remember to look. **A throwaway.** A segment can equally exist for an afternoon. "These 40 products need new photos" — make the segment, hand the link to whoever is doing it, delete it when the work is done. Creating one is cheap and there is nothing to clean up afterwards but the segment itself. Opening a segment puts it in the address bar, so **copying the URL shares that exact filtered view** — no export, no screenshot, no explaining which filter to set. Whoever opens it needs access to the space and to be assigned the segment; they then land on the same records you were looking at. Nothing removes an empty segment for you. A segment that has emptied out is exactly what a finished standing queue looks like, so Boost.space cannot tell the difference between *done for now* and *done forever* — deleting is a decision you make, not something that happens to you. **Name it after the job, not the filter.** *Needs photos* tells the next person what to do; *status = 3 AND image IS NULL* makes them work it out. This matters most for the throwaway segments, which are the ones somebody else opens from a link with no context. ## The human-in-the-loop pattern Put those pieces together and you get the shape most Boost.space work with AI ends up taking. Software handles what it can and hands the rest to a person, in a form that person can act on immediately. 1. **A filter describes the leftovers.** Whatever the automation could not decide — missing data, a status only a human can set, anything flagged for review. Save it as a segment. 2. **Tell the people who have to act.** An [automation](/guides/automation/actions-and-triggers) emails or notifies them when a record lands in that state, and `{$entityLink}` puts a link to the exact record in the message. No hunting. 3. **Keep the queue in sight.** Add the segment to their [menu](/guides/settings/menu-editor) so it is there every time they open the app, rather than something to remember to check. 4. **The queue empties itself.** Each fixed record stops matching the filter and leaves. Nobody marks anything as done — the count falling is the progress. 5. **Then decide whether it lives.** A recurring kind of leftover stays as a standing queue. A one-off gets deleted, by whoever made it. Nothing here is a feature you switch on. It is a filter, a notification, and a menu entry — the value is in wiring them together, and it works the same whether the records were flagged by an automation, by an [agent](/ai/mcp/server/for-agents), or by a person noticing a problem. --- title: Bulk actions and exporting description: >- Boost.space's Bulk Actions and Exporting features allow you to update multiple records at once, edit fields in bulk, and export your data. These tools save time and simplify your data management process, making your workflow faster and more efficient. --- # Bulk actions and exporting ## Using bulk actions Bulk actions allow you to select multiple records and apply changes across them at once. Here's how to use bulk actions: 1. **Select Records**: You can select one or more records within your space. Once you select the records, a _Bulk Actions_ button will appear at the right side of the screen. ![](/img/guides/working-with-data/bulk-actions-and-exporting-1.webp) 2. **Apply Bulk Action**: After selecting your records, click on the Bulk Actions button. ![](/img/guides/working-with-data/bulk-actions-and-exporting-2.webp) 3. A dropdown menu will appear for you to choose from. For example, you can bulk **add a label** to all the selected records. This action will be applied to every record you have chosen, and you'll see it reflected in your database after a brief moment. You can also update multiple fields at once using the **Bulk Edit** feature. Simply click on **Bulk Edit**, and add the fields you'd like to change. This makes it quick and efficient to apply updates across many items simultaneously. ![](/img/guides/working-with-data/bulk-actions-and-exporting-3.webp) 4. When searching for records or fields within the Bulk Actions and Exporting interface, you no longer need to scroll through the list manually. Simply **start typing what you are looking for**, and the system will automatically filter and display matching results as you type.![](/img/guides/working-with-data/bulk-actions-and-exporting-4.webp) ## Exporting Boost.space offers a straightforward way to **export your data**. Once you've selected your data, you can export it directly to an Excel file. The exported file will include the columns you currently have visible in your viewport, and the order of the columns will be the same as it appears on the screen. This ensures that the exported data matches the layout you're working with. ![](/img/guides/working-with-data/bulk-actions-and-exporting-5.webp) --- title: Code automations description: >- Run your own Python code as an automation step — written by you, your LLM, or the Agent Chat — in a secure, isolated sandbox with Secrets kept safe. --- # Code automations When notifications, emails, and webhooks aren't enough, write the logic yourself. The **Code** action runs a **Python** script as an automation step — against your data, in a **secure, isolated sandbox**. What the script does is up to you: the possibilities are as wide as code. ## Three ways to write the code - **Describe it in the [Agent Chat](/ai/ai-features/agent-chat)** — the agent writes the script, wires the [trigger](/guides/automation/actions-and-triggers), stores the Secrets, tests it, and deploys. This is the **vibecoded** path: automation in minutes, no developer required. - **Let your own LLM write it** — any agent [connected over MCP](/ai/mcp/server/connect-via-mcp) can create and edit code automations the same way. - **Write it by hand** — a code editor in the automation's settings, for developers who want full control. ## How a Code step works ```python def main(input): # your logic — work with the record that triggered the run, # call an external API, compute, decide… return {"status": "processed"} ``` - **Inputs are detected from your code** — reference what you need and the editor picks it up. - **The output schema comes from a test run** — run the step once and its output becomes typed data the next steps in the automation can use. - **Runs are logged** — every execution keeps its output and result, in the automation's log (the [Agent Chat](/ai/ai-features/agent-chat) can read it too — ask it *"why did last night's run fail?"*). ## Secrets stay secret API keys and credentials the code needs live in the **secure vault**, never in the code: - Add a Secret in the automation's settings — or through the Agent Chat, where it's entered in a **secure form** so the value never touches the chat. - At runtime the Secret is **injected into the sandbox** — it doesn't appear in the code, the chat, or the logs. ## The sandbox Each run executes in an **isolated environment** that exists only for that run — separated from other automations, other users, and other systems. It gets your inputs and Secrets, does its work, returns its output, and is gone. ## Trigger it however you need A Code step runs from any [trigger](/guides/automation/actions-and-triggers): when a **record is created, updated, or deleted**, **at a scheduled time**, or on demand — including straight from the [Agent Chat](/ai/ai-features/agent-chat). ## What people build with it - **Enrichment** — on new record, call an external API (key stored as a Secret) and fill in the missing fields. - **Scheduled digests** — every morning, aggregate yesterday's records and post the summary where the team lives. - **Guardrails** — validate incoming data with real logic, beyond what [formulas](/guides/fields/custom-fields-formula) can express, and flag what fails. - **Custom sync** — push changes to an internal system that has an API but no [Make](/guides/automation/views) app. ## Next - [Actions and triggers](/guides/automation/actions-and-triggers) — wire the trigger - [Agent Chat](/ai/ai-features/agent-chat) — build it by describing it - [Automation overview](/guides/automation) — how it all fits together --- title: Remote IDs description: >- Remote IDs pair Boost.space records with their identifiers in external applications, so syncs and agents always update the right record. --- # Remote IDs Remote ID is a table in the database for pairing third party records with Boost.space records where one Boost.space record can have several Remote IDs from external systems. Remote IDs are good to use both when synchronizing data and when working with third party applications. With the help of remote IDs you can easily query specific records. Remote IDs consist of two fields – _**Remote ID**_ and **_Remote Application_**. In the _Remote ID_ field, enter the record's ID in the external system, and in the _Remote Application_ field, enter the name of that external application. The Remote Application matters when you sync several tools, so their IDs don't collide. In [automation](/guides/automation/views), the Boost.space app's actions in Make — such as _Create a record_, _Update a record_, and _Search records_ — already expose fields for the Remote ID. ![](/img/guides/working-with-data/remote-ids-1.webp) On the output when getting the log data, the Remote ID structure looks just like an array with objects of individual Remote IDs. ![](/img/guides/working-with-data/remote-ids-2.webp) --- title: Comments description: >- Discuss work directly on a record — leave notes, ask questions, and see the automatic activity trail. --- # Comments **Comments** let your team discuss work right where it lives — on the record. Leave a note, ask a question, or post an update, and everyone with access to the record sees it in context. Boost.space also adds **automatic comments** for key events — who created the record, who assigned users — so every record carries its own activity trail. ![Comments on a record](/img/guides/collaboration/comments-1.webp) ## Where to find them On modules that support comments, open a record's **detail** — the comments section sits at the bottom. ![The comments section in a record detail](/img/guides/collaboration/comments-2.webp) ## Add a comment Type your message in the comment box and send it. It's immediately visible to everyone who can open the record. ![Writing a comment](/img/guides/collaboration/comments-3.webp) > Visibility follows permissions: a person sees and writes comments only on records they can > access — the same [space roles](/guides/spaces/space-roles-members-managers-and-owners) as the data > itself. ## Next - [Notifications](/guides/collaboration/notifications) · [Manage records](/guides/records/manage-records) --- title: Automation overview description: >- Keep your Boost.space data current automatically — native triggers and actions, your own code in a secure sandbox, and Make scenarios across apps. --- # Automation overview Automation keeps your data current without manual work. Boost.space gives you three complementary kinds — and one conversational way to build them all: | | Native actions & triggers | Code automations | Make scenarios | |---|---|---|---| | **What runs** | Notification, email, webhook | **Your own Python**, in a secure sandbox | Flows on your connected Make account | | **Good for** | Reacting to record changes and schedules | Any logic you can express in code | Moving data between Boost.space and 2,600+ apps | | **Set up in** | [Actions & triggers](/guides/automation/actions-and-triggers) | [Code automations](/guides/automation/code-automations) | The [Connect / Enrich / Share](/guides/automation/views) views | ## Native actions and triggers A **trigger** fires the automation — when a record is **created, updated, or deleted** (scoped to a module, optionally specific spaces), or **at a scheduled time** (minutes to months, or once). An **action** is what runs: a system notification, an email, a webhook — or code. See [Actions and triggers](/guides/automation/actions-and-triggers). ## Code automations The most powerful action is your own: a **Python script** running in a **secure, isolated sandbox** against your data, with credentials kept in a **secret vault** that never leaks into code or chat. Write it by hand, or don't write it at all — see the vibecoded path below. Full guide: **[Code automations](/guides/automation/code-automations)**. ## Vibecoded: built by describing You don't have to configure any of this by hand. Tell the **[Agent Chat](/ai/ai-features/agent-chat)** what should happen — *"every Monday at 8:00, summarize last week's orders and email me"* — and the agent creates the automation, wires the trigger, writes the code, stores the Secrets, tests it, and deploys. It can also list your automations, edit them, run them, and read their logs when something needs a look. The same works from [any agent connected over MCP](/ai/mcp/server/for-agents). ## Make scenarios For moving data in and out of other apps, Boost.space connects to **[Make](https://www.make.com)**. You link your own Make account once, then build **scenarios** that import data into a module, enrich existing records, or share data out — surfaced directly on the module as the **Connect**, **Enrich**, and **Share** views. See [Make scenarios and views](/guides/automation/views). ## Keeping data clean Every kind of automation writes to the same records, so consolidation matters: the [key field](/guides/fields/key-column) decides whether incoming data updates a record or creates one, and [API token prioritization](/guides/working-with-data/api-token-prioritization-data-consolidation) decides which source wins when values conflict. --- title: Log in to Boost.space description: >- Discover how to effortlessly log into your Boost.space account, either through the Gate or directly via your system's URL, with our concise step-by-step guide. --- # Log in to Boost.space There are two ways to log into your Boost.space system. ## Via Gate ![](/img/guides/account/logging-in-1.webp) 1. Go to the [gate.boost.space](https://gate.boost.space) page 2. Here, you will need to fill in your [system name](/guides/settings/system-name-system-key), username, and [password](/guides/account/password-change-reset) 3. After filling in these details, you are automatically redirected into the system ## Via your system URL ![](/img/guides/account/logging-in-2.webp) 1. Type your URL into the URL bar – e.g., https://_**MYSYSTEMNAME**_.boost.space 2. On this page, just fill in your username/email and your [password](/guides/account/password-change-reset) 3. After filling in these details, you are automatically redirected into the system > Not sure what your system name is? See [System name and system key](/guides/settings/system-name-system-key). --- title: Invite users and set up teams description: >- As an admin, invite or create users, deactivate them without losing data, and organize people into teams and categories to control access across modules and spaces. --- # Invite users and set up teams As an **admin**, you manage everyone in the system — inviting users, creating teams, and assigning roles. Open the **settings** icon at the bottom left of the home screen and choose **Users and teams**. ![The Users and teams settings](/img/guides/settings/inviting-users-and-setting-up-teams-admin-1.webp) ![The Users and teams list](/img/guides/settings/inviting-users-and-setting-up-teams-admin-2.webp) ## Add users There are two ways to add a colleague: - **Invite by email** — enter their email and [role](/guides/settings/system-roles-users-and-admins) (user or admin). When they accept, they log in, fill in their details, and can be assigned to teams. The number of (non-admin) users is unlimited. ![Inviting a user by email](/img/guides/settings/inviting-users-and-setting-up-teams-admin-3.webp) - **Create manually** — fill in the user's details yourself and add them to teams or categories. They get access as soon as they log in. ![Creating a user manually](/img/guides/settings/inviting-users-and-setting-up-teams-admin-4.webp) ## Deactivate a user The **Users** section lists every active and inactive user. To stop working with someone, **deactivate** their profile — this removes their access but **preserves their data**. You can also anonymize a user's data if needed. ![Deactivating a user](/img/guides/settings/inviting-users-and-setting-up-teams-admin-5.webp) ## Teams and categories Create **teams** and **categories** to organize people. Teams can be assigned to modules (via the [Menu editor](/guides/settings/menu-editor)), to [spaces](/guides/spaces) — while [creating the space](/guides/spaces/how-do-i-create-a-space), or afterwards from the space's own people dialog, the same place you assign individual users — and to individual records. Every new user joins the **Everyone** category by default; add your own categories as needed. **Set access up teams-first.** Create the teams, give the *teams* their [space roles](/guides/spaces/space-roles-members-managers-and-owners), then put people into teams. Access then follows membership: someone joining a team inherits every space that team can reach, and someone leaving loses it — one change instead of one grant per person per space. Granting each user each space individually works on day one and becomes unmaintainable by the tenth space. Note the direction: a space chooses its teams, not the other way round. Settings → Teams manages *who is in a team*; which spaces that team can reach is set from each space. ![Creating a category](/img/guides/settings/inviting-users-and-setting-up-teams-admin-6.webp) ## Assign people to a space 1. Choose the module. 2. Open the space where you want to assign people. 3. Click **User settings** at the top. 4. Assign the colleagues and set their [space roles](/guides/spaces/space-roles-members-managers-and-owners). ![Assigning users to a space](/img/guides/settings/inviting-users-and-setting-up-teams-admin-7.webp) > **Tip:** organize teams around departments — marketing, developers, designers, finance — to > mirror how your company actually works. --- title: Two-factor authentication (2FA) description: >- Two-Factor Authentication (2FA) in Boost.space adds a simple extra layer of security to your account. Learn what it is, why it matters, and how to set it up in just a few steps. --- # Two-factor authentication (2FA) **Two-Factor Authentication (2FA)** adds an extra layer of protection to your account, keeping your data safe even if your password is compromised. ## What is two-factor authentication (2FA)? 2FA is a security feature that requires not just your password, but also a second form of verification to access your account. This dramatically reduces the risk of unauthorized access, especially in the case of stolen or leaked credentials. While passwords can be guessed or exposed, the second factor — typically a time-based code from an authentication app — ensures that only you, with access to your personal device, can log in. ## How to enable 2FA in Boost.space 1. Click your **avatar** in the bottom-left corner and go to **Profile Settings**. 2. In the security section, choose to **enable Two-Factor Authentication**. ![Enabling 2FA in profile settings](/img/guides/account/two-factor-authentication-2fa-1.webp) 3. Download an authentication app (**Google Authenticator**, **Authy**, or **Microsoft Authenticator**) on your phone. ![Choosing an authentication app](/img/guides/account/two-factor-authentication-2fa-2.webp) 4. Scan the **QR code** on screen with the app — it starts generating time-based codes. ![Scanning the QR code](/img/guides/account/two-factor-authentication-2fa-3.webp) 5. Save the **backup codes** somewhere safe — they let you regain access if you lose your device. ![Backup codes](/img/guides/account/two-factor-authentication-2fa-4.webp) That's it — 2FA is now active. ### What happens next? The next time you log in to Boost.space: * Enter your email or user name and password as usual. ![](/img/guides/account/two-factor-authentication-2fa-5.webp) * Then, you'll be asked to enter a **6-digit code** from your authentication app. ![](/img/guides/account/two-factor-authentication-2fa-6.webp) * Once verified, you'll be granted access to your account. This simple extra step greatly increases your security and helps prevent unauthorized access to your data. --- title: Menu editor description: >- The Menu Editor in Boost.space allows admins to create, edit, and manage menus, enhancing user navigation and organizational workflow. Customize visibility, add users, and incorporate modules, folders, shortcuts, or embedded content to optimize your interface. --- # Menu editor The Menu Editor is an essential interface where users navigate according to the structure set by an admin. As an admin, you have the authority to create, edit, and manage menus, as well as control user access within these menus. ## Creating and editing menus Admins can easily create and modify menus. To create a new menu, simply open your primary menu and click on the "New Module" button. This will open a sidebar where you'll find the "Menu Editor" option at the bottom. Click on it to access the Menu Editor. Alternatively, you can reach the Menu Editor through "System Settings" by selecting the "Menu Editor" option in the left column. ![](/img/guides/settings/menu-editor-1.webp) ## Features of the menu editor Within the Menu Editor, you can create a new menu by naming it and adding a description. Once created, the menu will appear in a customizable format. Here, you can add users, ensuring they have access to the necessary sections. ![](/img/guides/settings/menu-editor-2.webp) Each menu item can be configured for visibility, allowing you to control which items are seen by users. You can edit or delete any item within the menu, providing flexibility and control. Additionally, you can create new entries at the bottom of the menu, including: * **Modules**: Add specific functionalities or tools to the menu. * **Folders**: Organize modules into categories, such as business or marketing. * **Shortcuts**: Include direct links to frequently accessed pages. * **Embed/iFrame**: Insert embedded content or iFrames to enhance functionality. ![](/img/guides/settings/menu-editor-3.webp) ## Several menus at once A menu is not a single global thing you edit — you can keep several, and a person can be in more than one. When they are, they see **all** of their menus, in the order the menus sit in the Menu Editor list. Drag the list to change that order; it is what every affected user sees. Assignment is not limited to individual people either: a menu can be given to **teams** and **categories**, which is what makes per-audience menus practical to maintain. ## Three things menus are good for **Cut a menu down to one audience.** Give a group only what they act on. A team that translates product copy does not need billing, warehouse, or CRM entries — build them a menu with the one space and the one view they work in, and their whole system becomes that job. This is the most underused thing in the editor and the fastest way to make Boost.space feel simple to someone who only has one task in it. **Put the queue people should check in the menu.** When a [segment](/guides/working-with-data/segmenter) exists precisely so a human keeps an eye on it — records with errors, items waiting for review — leaving it inside a data view means remembering to go look. As a menu shortcut it is simply there every time they open the app. **Bring outside tools inside.** A shortcut takes any external URL, so a dashboard you built on the [API](/api-reference) belongs in the menu next to everything else. To the person using it there is no seam. --- title: System name and system key description: >- Your system name is the unique identifier of your Boost.space instance — it forms your login URL and identifies your system to integrations. --- # System name and system key Your **system name** uniquely identifies your Boost.space instance — for example `mysystem` in `mysystem.boost.space`. It forms your login URL at [gate.boost.space](https://gate.boost.space) and identifies your system when you connect it to other tools. In that integration context it's also called the **system key** — it's the same value. > The system name **can't be changed** after installation, so choose it carefully. ![The system name and key](/img/guides/settings/system-name-system-key-1.webp) ## Where to find it - **In the URL** — when you're logged in, it's the part before `.boost.space`. - **In your setup email** — if you created the system, it's in the message from `system@boost.space`. - **Otherwise** — ask your system's administrator, or contact [support@boost.space](mailto:support@boost.space) if you can't log in. --- title: System settings description: >- Where admins configure Boost.space — system name, languages, currency, table and detail behavior, email, and design — plus where to manage your own profile. --- # System settings Boost.space separates **personal settings** (any user) from **system settings** (admins only). Admins open **System settings** from the bottom of the sidebar. ## Your profile Click your **avatar** (bottom-left) to open your profile and update your **name**, **phone number**, **profile picture**, **interface language**, and **[password](/guides/account/password-change-reset)**. Your account **email** can't be changed in-app — contact [support@boost.space](mailto:support@boost.space). ## About the system The **Main settings** card holds your system's core configuration: | Setting | What it is | |---|---| | **Version** | The Boost.space version this system runs (read-only). | | **System name** | Your system's display name. | | **Interface language (default)** | The default UI language for the system. | | **Currency (default)** | The default currency for money values. | ### Advanced settings | Setting | What it does | |---|---| | **Available languages** | Which languages users can switch between. | | **Disable client cache** *(not recommended)* | The client cache stores data browser-side and greatly speeds up the system and sync. Turning it off slows everything down. | | **Enable performance profiling** | Collects technical performance data to find bottlenecks and troubleshoot — no personal or sensitive data. | | **Use Boost.space Legacy Integrations** *(not recommended)* | Older integrations that are no longer updated. Prefer the newer alternatives. | | **Show SMTP and system email settings** | Adds the SMTP section (below) so you can set the sender address and your own mail server. | | **Multiple currency support** | Lets modules hold multiple currencies without automatic conversion. | ## Tables & Details Settings Control how record tables and detail views behave across the system: | Setting | What it does | |---|---| | **Segments Mode – on-demand data** | Loads only the records that pass your saved filters; the rest stays on the server, so large tables open faster and use far less memory. This is what enables the **[Segmenter](/guides/working-with-data/segmenter)**. | | **Do not save table filters when leaving a module** | Applied filters reset as soon as you leave the module. | | **Do not save table sorting when leaving a module** | Sorting resets each time you leave and return to the module. | | **Clear saved table filters when returning to desktop** | Filters on table spaces are cleared when you return to the desktop. | | **Clear saved table sorting when returning to desktop** | Custom record order is reset when you return to the desktop. | | **Empty custom fields in Detail are hidden by default** | Empty fields are hidden on the record detail for performance; reveal them with the detail's toggle. | | **Show extended row counts** | Shows more detailed row counts. Note: many records on one page can slow the system depending on your device. | | **Automatically start edit mode in record detail** | Opens a record's detail ready to edit. | | **Enable custom file categories** | Adds a section in Main settings to define categories for uploaded files (e.g. design, final, contract). | | **Enable personal labels** | Lets users create [labels](/guides/fields/labels) visible only to them. | ## Email (SMTP) When **Show SMTP and system email settings** is on, configure your mail server — host, port, credentials, sender name and address, and security (None / SSL / TLS). See [SMTP setup](/guides/settings/smtp-setup-guide). ## Design Personalize the system's look — logos, login background, favicon, colors/theme, and the chat panel. See [Company design settings](/guides/settings/company-design-settings). ## More admin areas - **[Modules](/guides/modules/setting-up-individual-modules-admin)** — add, configure, and remove modules. - **[Menu editor](/guides/settings/menu-editor)** — control navigation and the homepage. - **[Actions and triggers](/guides/automation/actions-and-triggers)** — native automation and webhooks. - **[Users and teams](/guides/settings/inviting-users-and-setting-up-teams-admin)** and roles. - **[Plans and billing](/guides/billing/plans-tiers-usage-limits)** — usage and upgrades. --- title: Plans and usage limits description: >- What actually affects your Boost.space usage — records, AI credits, administrators, and operations — and where to manage your plan. --- # Plans and usage limits Boost.space offers several plans, from a free tier to Enterprise. Rather than repeat the feature matrix here, compare plans and prices on the **[pricing page](https://boost.space/pricing/)** — it is always current. What matters day to day is your **usage limits**, set by your plan and tier: | Limit | What it covers | |---|---| | **Records** | How much data you store across all your databases. Delete old records to free room. | | **AI credits** | Consumed by [AI features](/ai). Included in every plan in different amounts — see [AI credits](/guides/billing/boost-space-4-0-ai-pricing). | | **Administrators** | How many admins can manage the system. | | **Operations** | Consumed by automation ([scenarios](/guides/automation/views)). | You can change your **tier** at any time as your needs grow. ## Manage your plan Administrators manage everything in the **Billing** section — from the homepage or via **Profile settings → Billing**. From there you can monitor records, AI credits, operations, and admin usage, and upgrade your plan or change tiers. ![Billing and limits](/img/guides/billing-and-policy/billing/plans-tiers-usage-limits-1.webp) --- title: Overview description: >- AI inside Boost.space — the built-in Agent Chat and the AI features that enrich, transform, and validate your data, scoped to your permissions. --- # AI Boost.space brings AI directly to your data: the built-in **Agent Chat** operates your system in plain language, and **AI features** enrich, transform, and validate the data itself. Connecting an external agent — Claude, ChatGPT, Cursor, or your own — is covered in **[MCP](/ai/mcp)**. **AI always acts within your permissions — it can read, write, and query only the data you can, nothing more.** > **Start here:** the **[Agent Chat](/ai/ai-features/agent-chat)** — the agent chat built into the > app, zero setup. Bringing your own agent instead, or building *for* agents? That lives in the > **[MCP](/ai/mcp)** tab, starting with **[Boost.space for AI agents](/ai/mcp/server/for-agents)**. ## AI inside your data | Feature | What it does | |---|---| | **[Agent Chat](/ai/ai-features/agent-chat)** | The built-in agent chat — ask, act, and build automations in plain language | | **[Vector database](/ai/ai-features/vector-database)** | Embed spaces so agents and search match records by meaning | | **[AI fields](/ai/ai-features/ai-fields)** | Fields whose values are generated or enriched from a prompt | | **[AI text manipulation](/ai/ai-features/ai-powered-text-manipulation)** | Shorten, extend, translate, and rephrase text inline | | **[AI data transformation](/ai/ai-features/boost-space-data-transformation)** | Clean and standardize a whole column with AI | | **[AI data validation](/ai/ai-features/boost-space-data-validation)** | Check a column against a rule and surface what fails | AI features run on **[AI credits](/guides/billing/boost-space-4-0-ai-pricing)**. ## Bring your own agent External agents connect over the **[Remote MCP Server](/ai/mcp)** and get the same capabilities as Agent Chat — search and write records, build structure, run AI operations — within the connected user's permissions. Start with **[Connect via MCP](/ai/mcp/server/connect-via-mcp)**; per-client guides live in **[MCP clients](/ai/mcp/server/common-mcp-clients)**. ## How they fit together Your data lives in Boost.space. AI features act on it from the inside; [MCP](/ai/mcp) lets outside agents read and write it too — both within your permission boundaries. The same operations are available to your own code over the **[REST API](/api-reference)** and **[SDKs](/sdk)**. # Agency account Every Boost.space customer gets their **own system on its own domain** — `yourcompany.boost.space` — with its own database, its own users, and its own [MCP endpoint](/ai/mcp). Systems are isolated from each other by design; there is no shared tenancy to opt out of. That isolation is why agencies run **one system per client** rather than one system with everything in it. Each client's data stays in its own system, and the people who work across several clients move between systems instead of having access widened. **Linking is automatic and takes no setup.** Create a user with the **same email address** in each system and Boost.space recognises it as one person across all of them. Nothing to configure, no request to file — a switcher simply appears. That is the whole mechanism, so if you were expecting a longer procedure, there isn't one. Set up an [admin](/guides/settings/system-roles-users-and-admins) user with that shared email address on each system in [system settings](/guides/settings/system-settings). [Agency Account](https://fast.wistia.net/embed/iframe/gf1svm94ew?seo=true\&videoFoam=true) ## Switching between systems in Boost.space Then click on your avatar in the bottom left corner and click on the icon to switch between systems. ![](/img/guides/settings/agency-account-1.webp) Here, you can choose which system you want to log into. Just fill in your login details for that system, and you're done. The switcher lists the systems **this browser has signed into**, so on a new machine you sign in once per system and they accumulate from there. Sharing an email address links the accounts; it does not sign you in everywhere. ![](/img/guides/settings/agency-account-2.webp) ## Switching between Make organizations If you have multiple Make organizations connected, you can switch between them by clicking the name of your organization in the [Make](/guides/automation/views) area. ![](/img/guides/settings/agency-account-3.webp) --- title: Legacy & older plans description: >- On an older Boost.space plan, the classic modules, the Integrator, or the legacy API? Where those features are documented, and where they map to today. --- # Legacy & older plans Boost.space has evolved. If you're on an **older plan**, using the **classic named modules**, the **Integrator**, or the **legacy API**, this page tells you where each is documented and what it maps to today. > **Looking for legacy documentation?** It lives in a separate space: > **[legacy-api.boost.space](https://legacy-api.boost.space)** — > the Integrator, classic modules, the app marketplace, and the **full legacy API reference**. ## What's legacy, and where it went | Legacy | What it was | Today | |---|---|---| | **Classic named modules** — Tasks, Contacts, Products, Invoices, Business Orders, Warehouses, Projects, Calendar, and the other fixed add-ons | Pre-built modules with a fixed structure | Replaced by custom **[Modules](/guides/modules)** you design yourself (or [generate with AI](/guides/modules/build-with-ai)) — any structure you need | | **Integrator** — Boost.space's own scenario builder | Where you built automation scenarios inside Boost.space | Automation now runs on **[Make](/guides/automation/views)** (Connect / Enrich / Share views) and native **[actions & triggers](/guides/automation/actions-and-triggers)** | | **Marketplace / AppFlows** | Pre-packaged app templates and flows | The app catalog and AppFlows are documented in the [legacy docs](https://legacy-api.boost.space) | | **Legacy API** (`apidoc.boost.space`) | The older API surface and its endpoints | The current, supported API is the **[REST API](/api-reference)**; the older reference stays in the [legacy docs](https://legacy-api.boost.space) | ## Older plans and lifetime deals If you're on an earlier plan — **Scale**, **Grow**, or a **lifetime deal** (AppSumo, SaaSMantra, and similar) — your plan stays honored. Current tiers and limits are on **[Plans and usage limits](/guides/billing/plans-tiers-usage-limits)**; for anything specific to a legacy or lifetime plan (limits, upgrades, or how a feature maps to your plan), contact [support@boost.space](mailto:support@boost.space) with your system name. ## Setting up an Integrator scenario Questions about building or fixing a **scenario in the Integrator** are answered in the **[legacy documentation](https://legacy-api.boost.space)**. If you're starting fresh, use [Make scenarios and views](/guides/automation/views) instead — it's where automation lives now. --- title: Vector database description: >- Turn your Boost.space spaces into a vector database so AI agents retrieve records by meaning, not keywords — lean, relevant context at scale, over the API and MCP. --- # Vector database Large datasets are hard for an AI agent to use well: it can't read a whole space, and keyword search misses anything phrased differently. Boost.space's **vector database** solves this. It turns the text in your records into **embeddings** — numeric representations of meaning — so an agent can retrieve the **most relevant records by meaning**, not exact words. The result: agents (and your own code) get **lean, on-point context** from even a huge space — exactly what retrieval-augmented generation (RAG) needs — instead of dumping thousands of rows into a prompt. ## Why it matters - **Search by meaning.** "Unhappy enterprise customers" finds the right records even if none contain those words. - **Context at scale.** An agent pulls the handful of records that matter before it acts, so answers are grounded in *your* data and stay within the context window. - **Same permissions.** Vector search is scoped to a space and the acting user's access — an agent only ever retrieves what that user can see. - **Find the unusual, too.** Surface outliers — records that *don't* fit a description — for anomaly detection and data-quality review. ## Enabling it The vector database is an **Enterprise** feature — **[contact support](https://boost.space/contact)** to unlock it. Once it's available, you turn it on where the data lives: In a **[space's settings](/guides/spaces/space-settings)**, switch on **Vectorization** ("Embed this space's records so AI and search match them by meaning"). That is the whole setup — there is nothing to pick field by field. **What gets embedded.** Every **text** and **rich text** field on the records in that space, and only those. Numbers, dates, checkboxes, and selection fields are left out: a date has no meaning to compare, so embedding one would cost tokens and return noise. Rich text is stripped to its prose before it is embedded, so markup never competes with the actual words. Only records in **custom modules** are embedded. The scope you control is therefore the **space**, not the field. Switch vectorization on where the text worth searching lives, and leave it off elsewhere. **Keeping it current** needs no work at all. Saving a text value embeds it as part of the same write, so a record is searchable the moment it is saved — no queue to watch, no nightly job, no re-indexing step. It adds a small delay to writes in a vectorized space, and nothing else. ## Using it Once a space is vectorized, three operations are available over the **[REST API](/api-reference)**: | Operation | What it does | Use it for | Over MCP | |---|---|---|---| | **Similar** | The records most semantically **similar** to a query, ranked by relevance. | Semantic search, "find records like this", RAG retrieval | yes | | **Outliers** | The records **furthest** from a query. | Anomaly detection, data-quality review | yes | | **Context** | A **compact, lean** list of the most relevant records — trimmed field values, built for agents that need context before acting. | Grounding an agent's answer on your data | REST only | All three are scoped to one space, accept a natural-language **query**, and can be **pre-filtered** by a [filter](/guides/working-with-data/how-do-i-filter-records) or a saved [segment](/guides/working-with-data/segmenter) first. You can also set a relevance threshold to keep only strong matches. ## What people actually use it for Three operations do not sound like much until you see what they replace. These are patterns in real use, not hypotheticals. **Agents finding the right records.** The most common use by a distance, and the one that makes everything else an agent does possible. An agent asked to *"look at our unhappy enterprise customers"* has no keyword to search for — "unhappy" appears in none of your fields. Semantic search is how it finds the records a human would have picked, which is why a vectorized space is worth so much more to an [agent](/ai/mcp/server/for-agents) than a plain one. **Categorising new records from the ones you already sorted.** A supplier sends products with no categories. Instead of writing rules, search your existing catalogue for the records most similar to each new one and read the categories and tags off the matches. Your own past decisions become the classifier, so it already knows your taxonomy, your naming, and your edge cases — and it gets better every time somebody categorises something by hand. **Finding the prospects who look like your buyers.** Take the customers who actually bought as the description of what a good customer looks like, then search the rest of your database for the records most similar to them. What comes back is a ranked list of prospects that resemble people who already said yes — a far better basis for deciding whether to spend on a campaign than demographics you guessed at. **Finding the records that are quietly broken.** This one runs the search backwards. Query with a description of your *best* records and ask for the **outliers** — the ones furthest from it. Poor descriptions, thin data, mistyped entries, and quietly wrong records all surface together, because what they have in common is not resembling anything good. It is the fastest way to build a data-quality worklist without writing a single validation rule. Save it as a [segment](/guides/working-with-data/segmenter) and it stays a standing queue. > Every one of these gets sharper with a filter in front of it. Categorise within one product range, > look for lookalikes within one region, hunt outliers within one catalogue — narrower candidates, > better ranking, and for outliers, dramatically less work. ## Filter first, then search **Narrow the records with a real filter, then let semantic search rank what is left.** This is the one habit that decides whether semantic search feels sharp or vague, and it is worth building into every query you or your agents write. It works because that is genuinely the order things happen: the filter resolves the candidate records first, and only those are ranked by meaning. If the filter matches nothing, no embedding call is made at all. So a filter is not a post-processing step you bolt on — it decides what the search is even looking at. Two things follow: - **Accuracy.** "Enterprise customers unhappy about onboarding" searched across every record will surface whatever is loosely similar anywhere. Filter to the enterprise segment first and the same query ranks only records that were already the right kind of record. - **Speed, especially for outliers.** Similarity search is index-backed; **outliers are not** — finding what is *least* similar means scanning the whole candidate set, because an index built to find near neighbours cannot shortcut to far ones. On a large space, filtering first is not a nicety for outliers, it is the difference between a usable query and a slow one. > Over MCP, this is the **semantic search** an agent reaches for when it needs the right context > from a large space without reading all of it. Tell your agents the same rule: filter, then rank. > See [what an agent can do](/ai/mcp/server/for-agents). ## Next - [Connect via MCP](/ai/mcp/server/connect-via-mcp) — let an agent query your data - [API reference](/api-reference) · [AI overview](/ai) --- title: AI text manipulation description: >- Boost.space's AI-powered text manipulation tools revolutionize how you work with text content. Whether you're shortening, extending, simplifying, translating, or adding emojis, these tools save time and improve efficiency across tasks and modules. --- # AI text manipulation _**Note: To access this feature, you'll need [AI Credits](/guides/billing/boost-space-4-0-ai-pricing).**_ Managing and editing text content can be time-consuming, especially when you need precision and efficiency. That's where **AI-powered text manipulation** in **Boost.space** comes in, offering tools that simplify and supercharge your text workflows. Whether you're working with records, fields, or any module that uses the text editor, AI tools are here to save the day. ### How to use AI tools Let's illustrate the capabilities with a practical example: a record titled **Onboarding** with a short description. 1. Open the module that you want to use. 2. Locate the record in the appropriate space. 3. Click on the _Edit_ option to open the text editor. 4. Highlight the text you want to work on. As soon as you highlight the text, you'll notice an _AI Tools_ button pop up. This is where the magic happens. ![The AI Tools button on highlighted text](/img/guides/ai-tools-mcp/ai-features/ai-powered-text-manipulation-1.webp) ### What can you do with AI tools? The AI-powered features give you a variety of options to tailor your text with just a few clicks. Here's a glimpse of what's possible: * **Shorten**: Need to make a lengthy description more concise? The AI tool will trim your text while keeping its core message intact. * **Extend**: Want to add more details or context? Extend your text to make it richer and more informative. * **Simplify**: Transform complex language into something clear and easy to understand, perfect for improving readability. * **Translate**: Instantly convert your text into another language, ideal for global teams or multilingual projects. * **Add Emojis**: simply type the command, highlight it, and let the AI take over. * **Others**: Fix spelling and grammar, Continue writing, Rephrase, TL;DR, Adjust tone, Summarize, and more. These options allow you to refine your content quickly and effortlessly, ensuring it aligns with your goals. ![](/img/guides/ai-tools-mcp/ai-features/ai-powered-text-manipulation-2.webp) The versatility of Boost.space's AI tools extends beyond individual tasks. Any module that involves text management can benefit, allowing you to refine, enhance, or adapt content without time-consuming manual edits. --- title: AI data validation description: >- Validate, sort, and manage your data with Boost.space's AI Data Validation feature. --- # AI data validation **_Note: To access this feature, you'll need [AI Credits](/guides/billing/boost-space-4-0-ai-pricing)._** **Data Validation** is an AI function that helps you validate your data effectively within the Boost.space system. This article guides you through using it. ## What is data validation? Data Validation is a process that ensures the **data entered into the system meets specific criteria**, thus maintaining data quality. By implementing this feature, you can check for accuracy, consistency, and completeness, reducing the likelihood of errors in your applications. ## How to use data validation Using data validation is straightforward: 1. Open the [space](/guides/spaces) where you want to use it. Select the column, click the three dots, and choose **Data validation**. ![Opening data validation on a column](/img/guides/ai-tools-mcp/ai-features/boost-space-data-validation-1.webp) 2. Let's define how your Data Validation will be carried out. You can either choose from our **pre-made templates** or create your own **custom validation**. For example, you might enter a command like, "**Filter all names that contain an "A"**. Once you've made your selection, simply click "**Save and Run**". ![](/img/guides/ai-tools-mcp/ai-features/boost-space-data-validation-2.webp) 3. Your template for Data Validation has been saved. Now, it's time to activate it. You can also select the option **Sort by Data Validation** so that the data matching the validation criteria will appear first in the table. ![](/img/guides/ai-tools-mcp/ai-features/boost-space-data-validation-3.webp) 4. Review the results — each row is checked against your rule, so you can spot and fix the ones that don't pass. --- title: Connect via MCP description: >- Connect Claude, ChatGPT, Cursor, or any MCP client to your Boost.space system and let it read and write your data over the Remote MCP Server. --- # Connect via MCP The **Remote MCP Server** lets an AI agent work with your Boost.space system in real time — read and search records, create and update data, build modules and fields, and run Boost.space's AI operations. It runs on Boost.space infrastructure, so there is nothing to host yourself. > **An agent connected over MCP acts with exactly your Boost.space permissions — it can read, > write, and query only the data you can, nothing more.** **MCP is the surface for when an agent decides what to do.** You describe an outcome and it works out the steps. If instead *you* already know the steps and want to write them down, you want the **[SDK](/sdk)** — or the **[REST API](/api-reference)** if your language has no SDK yet. Same data, same permissions; the difference is who is authoring the sequence. Bulk writes and deletes exist only on those two. ## Two ways to work with an agent - **In the app** — open the **[Agent Chat](/ai/ai-features/agent-chat)** (the **Agent** button in the sidebar): the built-in agent chat, scoped to one module or all of them. No setup at all. - **Your own client** — connect Claude, ChatGPT, Cursor, v0, Lovable, or any MCP client to your data. That's what this guide covers. ## The fastest way: the Connect AI window Boost.space has a built-in **Connect AI** window — a guided control panel that connects an external agent to your data. It creates the MCP token for you, gives you the connection URL, and shows the exact steps for your chosen client. Open it from the **Connect AI** button on a custom module, or from your user menu → **API / MCP tokens → Create new**. Then: 1. Choose **MCP token** (the default) over an API token. 2. Pick your **AI model** — or choose **Other** and select **OAuth** or **API key**. 3. **Copy the MCP URL** and follow the on-screen steps for that client. 4. Optionally try the example prompts, then finish — your token is created. Prefer to wire it up by hand? Use the steps below. ## What you need Two things, both from your Boost.space instance: 1. Your **connection URL** — copy it from the **Connect AI / MCP token** screen (don't build it by hand) — it looks like `https://mcp.boost.space/v2/{system}/sse`, where `{system}` is your system name. 2. Either an **MCP token** or an **OAuth** sign-in, depending on how your client connects. See **[API tokens and MCP tokens](/ai/mcp/server/token-creation)** for how to create the token and find your URL. > Treat an MCP token like a password — anyone who has it can act on your data through the assistant, > up to the token's permissions. ## Two ways to connect Modern clients support both; pick whichever the client offers. | Method | How it works | Best for | |---|---|---| | **URL + token** | Paste the connection URL and your MCP token into the client's connector settings | Claude, ChatGPT, Cursor, VS Code — any client with a "custom connector / MCP server" field | | **OAuth** | Paste the URL only; the client sends you to a Boost.space sign-in and receives its own token | Clients that support OAuth for remote MCP — no token to copy or store | Both connect to the same server. OAuth avoids handling a token by hand; URL + token works everywhere. Client-specific steps are in **[Common MCP clients](/ai/mcp/server/common-mcp-clients)**. ## What you can do once connected The agent works with your whole data model, not just reads. Within its token's permissions it can: - **Records** — search, read, create, and update records across your spaces, one record at a time. - **Structure** — create and change modules, fields, field groups, spaces, statuses, and labels. - **Files, users, teams** — upload and manage files, and read or manage users and teams. - **AI operations** — generate and enrich field values, transform or validate whole columns, and generate module definitions. - **Semantic search** — find the records most relevant to a natural-language query. The tool list is not fixed. Your server advertises the tools for the modules **your** system has active, so two systems can legitimately offer different sets — an agent is better off without warehouse tools on a system that has no warehouses. The live server is the only accurate list, so the way to see yours is to ask: *"what Boost.space tools do you have?"* **Where MCP stops.** Deleting records and writing in bulk are not MCP operations — use the **[REST API](/api-reference)** or an **[SDK](/sdk)** for those, and for anything where you want to push thousands of rows in one call rather than have an agent walk them one by one. --- title: API tokens and MCP tokens description: >- What API tokens and MCP tokens are, how they differ, how to create them, and how their permissions keep access scoped. --- # API tokens and MCP tokens Boost.space uses two kinds of tokens: **API tokens** (for integrations and the REST API) and **MCP tokens** (for AI agents connecting over MCP). Both authenticate as a [user](/guides/settings/system-roles-users-and-admins) and **can never have more rights than that user**. ## MCP token An MCP token authorizes an **AI agent** to connect to your Boost.space [MCP server](/ai/mcp/server/for-agents). The easiest way to create one is the in-app **Connect AI** window (see [Connect via MCP](/ai/mcp/server/connect-via-mcp)) — it mints the token and gives you the **connection URL** `https://mcp.boost.space/v2/{system}/sse` a client needs. - An MCP token acts as the user who created it — it can never do anything that user can't. - Some clients connect with **OAuth** instead of a token: you paste only the connection URL and sign in. The access model is the same. ## API token An API token authenticates a user with the [REST API](/api-reference) and integrations — the token acts as that user's login for programmatic access. ![Creating an API token](/img/guides/ai-tools-mcp/mcp/token-creation-1.webp) ## Permissions When you create an **API token**, choose a **permission type**: - **Read** — read-only access. - **All** — full access, within the user's own rights. - **Custom** — pick exactly which modules the token can touch, and whether it can **read**, **create**, **edit**, or **delete** in each. Every token is still bounded by the user's own rights — a token can never do more than its owner. To grant different access, create a new token. > Treat any token like a password — anyone who has it can act on your data up to the token's > permissions. ## Which token do I need? | Use case | Token | |---|---| | Build an integration or call the REST API | **API token** | | Connect an AI agent over MCP (Claude, ChatGPT, Cursor, …) | **MCP token** (or OAuth) | Next: **[Connect via MCP](/ai/mcp/server/connect-via-mcp)** · **[Common MCP clients](/ai/mcp/server/common-mcp-clients)** --- title: Overview description: >- Connect any AI agent to Boost.space over the Model Context Protocol — the hosted Remote MCP Server, per-client setup guides, and token scoping. --- # MCP Boost.space hosts a **Remote MCP Server** — connect Claude, ChatGPT, Cursor, or any MCP client to your system and it can read and search records, create and update data, build modules and fields, and run Boost.space's AI operations. It runs on Boost.space infrastructure; there is nothing to host yourself. **An agent connected over MCP acts with exactly your Boost.space permissions — it can read, write, and query only the data you can, nothing more.** ## Two servers | Server | What it's for | URL | |---|---|---| | **Your data** | Read, write, and query your Boost.space system | `https://mcp.boost.space/v2/{system}/sse` | | **These docs** | Let an agent search and read this documentation | `https://docs.boost.space/mcp` | ## Start here | Guide | What you'll do | |---|---| | **[Connect via MCP](/ai/mcp/server/connect-via-mcp)** | Point any MCP client at your system with the Connect AI window | | **[MCP clients](/ai/mcp/server/common-mcp-clients)** | Per-client setup: Claude, ChatGPT, Cursor, VS Code, Claude Code, v0, Lovable, CLI | | **[API tokens and MCP tokens](/ai/mcp/server/token-creation)** | Tokens, OAuth, and how access stays scoped | Want the full picture first — what an agent can actually do here, and the agent-readable doc surfaces like `/llms.txt`? **[Boost.space for AI agents](/ai/mcp/server/for-agents)** is the next page. ## No client at all? The app ships with **[Agent Chat](/ai/ai-features/agent-chat)** — the built-in agent chat behind the **Agent** button in the sidebar. Zero setup, same data, same permissions. --- title: Claude Code description: >- Connect Claude Code to Boost.space over MCP — one CLI command and the agent can read and write your data from the terminal. --- # Connect Claude Code Add Boost.space to Claude Code with one command: ```bash claude mcp add --transport sse boostspace \ https://mcp.boost.space/v2/{system}/sse \ --header "Authorization: Bearer YOUR_MCP_TOKEN" ``` Replace `{system}` with your system name and `YOUR_MCP_TOKEN` with your [MCP token](/ai/mcp/server/token-creation) — both from the **Connect AI** window ([Connect via MCP](/ai/mcp/server/connect-via-mcp)). Run `/mcp` in a session to confirm the Boost.space tools are connected. > The agent acts within your Boost.space permissions — the same access as the user who created the token. **Try it:** > "Pull the schema of my Tickets space and scaffold an import script for it." See [what an agent can do](/ai/mcp/server/for-agents) once connected. --- title: Cursor description: >- Connect Cursor to Boost.space over MCP — one mcp.json entry and your data is available to the agent while you build. --- # Connect Cursor Cursor reads MCP servers from an `mcp.json` config (**Settings → MCP → Add new server**): ```json { "mcpServers": { "boostspace": { "url": "https://mcp.boost.space/v2/{system}/sse", "headers": { "Authorization": "Bearer YOUR_MCP_TOKEN" } } } } ``` Replace `{system}` with your system name and `YOUR_MCP_TOKEN` with your [MCP token](/ai/mcp/server/token-creation) (get both from the **Connect AI** window — see [Connect via MCP](/ai/mcp/server/connect-via-mcp)), then reload. Boost.space appears in Cursor's MCP tools list. > The agent acts within your Boost.space permissions — the same access as the user who created the token. **Try it:** > "Read the schema of my Products space and generate a typed client for it." See [what an agent can do](/ai/mcp/server/for-agents) once connected. --- title: CLI agents (Codex, Gemini) description: >- Connect command-line agents like Codex or Gemini CLI to Boost.space over MCP with a config-file entry. --- # Connect CLI agents Command-line agents (OpenAI **Codex**, **Gemini CLI**, and similar) read MCP servers from a config file. Add an HTTP/SSE entry pointing at your connection URL with a `Bearer` token header — for example in `~/.codex/config.toml`: ```toml [mcp_servers.boostspace] url = "https://mcp.boost.space/v2/{system}/sse" headers = { Authorization = "Bearer YOUR_MCP_TOKEN" } ``` Replace `{system}` with your system name and `YOUR_MCP_TOKEN` with your [MCP token](/ai/mcp/server/token-creation) — both from the **Connect AI** window ([Connect via MCP](/ai/mcp/server/connect-via-mcp)). Other CLIs use the same pattern with their own config format. > The agent acts within your Boost.space permissions — the same access as the user who created the token. **Try it:** > "Export every record from my Deals space created this month as CSV." See [what an agent can do](/ai/mcp/server/for-agents) once connected. --- title: v0 description: >- Connect v0 to Boost.space over MCP so your generated apps work with live, permission-scoped data. --- # Connect v0 Building UI in **v0**? Connect it to Boost.space so the generated app works against your live data instead of mocks. 1. In Boost.space, open the **Connect AI** window, pick **v0**, and follow the on-screen steps — it creates your [MCP token](/ai/mcp/server/token-creation) and shows the exact flow. See [Connect via MCP](/ai/mcp/server/connect-via-mcp). 2. In v0, add Boost.space as an **MCP server**: paste your **connection URL** `https://mcp.boost.space/v2/{system}/sse` and authenticate with **OAuth** or the token. 3. Ask v0 to build against your data. > The agent acts within your Boost.space permissions — the same access as the user who created the token. **Try it:** > "Build a dashboard over my Deals space: pipeline by stage, top 10 by value." See [what an agent can do](/ai/mcp/server/for-agents) once connected. # The data hub for humans and agents **Boost.space is the platform where humans and AI agents run a business together.** It aggregates data from every tool you use into **one live operational context** — typed, linked, deduplicated, synced in both directions — and puts everything to work on top of it: an app your team steers from, automation that keeps every system current, built-in AI that enriches and validates the data, and **MCP access so any agent can search, act, and write results back** in natural language — always within your permissions. > **Connecting an agent?** Start at [Boost.space for AI agents](/ai/mcp/server/for-agents) — two minutes to a working connection. New to the product? [What is Boost.space?](/what-is-boostspace) ## Choose how you work One hub, three ways in — agents, people, and code work on the same live data. | | For | Start | | --------------------- | ---------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | | **With an AI agent** | Operate everything in natural language — Claude, ChatGPT, Cursor, or any MCP client, scoped to your permissions. | [Agent Chat](/ai/ai-features/agent-chat) → [Connect your own](/ai/mcp/server/connect-via-mcp) | | **In the app** | Teams and admins who organize data, build modules, and invite people — no code. | [Quickstart](/quickstart) → [Modules](/guides/modules) → [Fields](/guides/fields) | | **On the API & SDKs** | Developers building integrations on the REST API or a typed SDK. | [API](/api-reference) → [SDK](/sdk) | ## How Boost.space is structured Four levels — learn these and everything else follows: | Concept | What it is | | ----------------------------- | -------------------------------------------------------------------------------------------------- | | **[Module](/guides/modules)** | A type of data — the tables of your database. You build the ones you need. | | **[Space](/guides/spaces)** | A container that groups records within a module, with its own roles and access. | | **[Record](/guides/records)** | A single row of data — one contact, one task, one order. | | **[Field](/guides/fields)** | A typed attribute on a record — text, number, date, a link to another record, or a computed value. | Typed fields and relational links are what make the data reliable for both people and agents. See [Core concepts](/core-concepts) for the full vocabulary, or the [Glossary](/glossary) for every term. ## Product guides * **[Modules](/guides/modules)** · **[Spaces](/guides/spaces)** · **[Records](/guides/records)** · **[Fields](/guides/fields)** — the data model * **[Working with data](/guides/working-with-data)** — import, filter, views, and consolidate * **[Automation](/guides/automation)** — keep data in sync with Make scenarios * **[System settings](/guides/settings)** · **[Billing](/guides/billing)** — administration ## Build with Boost.space * **[Boost.space for AI agents](/ai/mcp/server/for-agents)** — the agent-ready surface: MCP, agent-readable docs, semantic search * **[AI](/ai)** — AI features inside your records, and the built-in Agent Chat * **[MCP](/ai/mcp)** — connect Claude, ChatGPT, Cursor, or any agent to your data * **[API](/api-reference)** — the REST API, one base URL per tenant * **[SDK](/sdk)** — typed clients for TypeScript, Python, PHP, and Go * **[Changelog](/changelog)** — every API and SDK change ## Get help **Ask AI** is the fastest answer — it sits at the top of every page and answers from these docs. [System status](https://status.boost.space) · [Trust Center](https://trust.boost.space) · [Blog](https://boost.space/blog) · [FAQ & support](/support) — anything else, [get in touch](https://boost.space/contact) --- title: Overview description: >- Official Boost.space SDKs for TypeScript, Python, PHP, and Go — typed clients generated from the REST API spec. --- # SDK **One typed client for the Boost.space REST API, in four languages.** TypeScript, Python, PHP, and Go are all generated from the same [OpenAPI spec](/api-reference) that powers the API Reference — so the client surface always matches the API. Each ships **74 resources**, fully typed models, and **165 relationship-navigation methods**. > Generated from the SDK's own source of truth, so these docs always match the shipped packages. ## Should you use the SDK? **If you are writing code against Boost.space in TypeScript or Python, yes** — there is no reason to hand-roll HTTP. You get the same endpoints plus typed models, automatic retries, pagination you can iterate over instead of managing offsets, filters you compose instead of string-building, and bulk helpers that chunk a large batch and report per-chunk failures. Reach for the **[REST API](/api-reference)** directly when your language has no SDK yet, or when you need the exact wire format. Reach for **[MCP](/ai/mcp/server/connect-via-mcp)** when an AI agent is deciding what to do rather than you writing the steps out. ## Get started in two steps **1. Install** (TypeScript and Python are on the public registries; PHP and Go are coming soon): ```bash npm install @boost-space/sdk # TypeScript pip install boostspace-sdk # Python ``` **2. Make your first call:** ```ts import { BoostSpace } from "@boost-space/sdk"; // `system` is your tenant, e.g. "acme" → https://acme.boost.space/api const bs = new BoostSpace({ token: process.env.BS_TOKEN!, system: "acme" }); const space = await bs.spaces.get(42); ``` Full auth options (tokens, providers, OAuth, MCP) are in **[Authentication](/sdk/guides/authentication)**. ## Guides Concepts that apply across all four languages: | Guide | What's inside | |---|---| | **[Authentication](/sdk/guides/authentication)** | API tokens, token providers, OAuth, MCP | | **[Filtering](/sdk/guides/filtering)** | The full filter grammar with tested examples | | **[Ordering & pagination](/sdk/guides/ordering-pagination)** | Sort grammar and Paginator idioms | | **[Errors & retries](/sdk/guides/errors-retries)** | Typed errors and automatic retries | | **[Record handles](/sdk/guides/record-handles)** | Lazy `ref` handles, caching, call costs | | **[Relations & expand](/sdk/guides/relations-expand)** | Relationship navigation and expansion | | **[Delta sync & bulk](/sdk/guides/delta-sync-bulk)** | Change feeds and bulk operations | | **[Testing & mocking](/sdk/guides/testing-mocking)** | Test against the SDK safely | ## Reference One page per resource — Records, Fields, Files, Labels, Modules, Spaces, Users, and more — generated from the spec: **[SDK API reference](/sdk/reference)**. ## What every SDK guarantees - **Bearer authentication** with your API token - **Automatic retries** with backoff - **Header-driven pagination** (`X-BoostSpace-FoundRecords`), exposed as native iteration - **Typed errors** carrying both the HTTP status and the internal Boost.space `code` Base URL is per-tenant: `https://{system}.boost.space/api` (`system` = your system name). ## SDK vs. REST | Use… | When | |---|---| | **An [SDK](/sdk/guides/authentication)** | You're in TypeScript, Python, PHP, or Go — get types, retries, pagination, and relationship helpers | | **The [REST API](/api-reference)** | Any other language — copy-paste code samples per endpoint | Packages: [npm](https://www.npmjs.com/package/@boost-space/sdk) · [PyPI](https://pypi.org/project/boostspace-sdk/) · [SDK changelog](/changelog/updates/sdk-changelog). --- title: "Record handles (`ref`)" --- # Record handles (`ref`) One rule makes the whole surface guessable: > **`bs.records` is a collection. `bs.records.ref(42)` is a record handle. > A record's relation is again a collection.** ## What `ref` is `ref(id)` returns a lightweight handle to **one** record. It is **lazy** — it makes **no API call** until you ask for something. You can also pass a model you already have, which seeds the handle's cache. ```python c = bs.records.ref(42) # 0 API calls — just a reference c = bs.records(42) # Python sugar for .ref(42) rec = c.get() # 1 call — fetch + cache c.field_values() # 0 calls if cached, else 1 ``` ```ts const c = bs.records.ref(42); // .ref() everywhere (PHP/TS/Go); Python also bs.records(42) ``` ```php $c = $bs->records->ref(42); ``` ```go c := bs.Records.Ref(42) // or Ref(existingModel) ``` ## What a handle can do | Method | Cost | Notes | |--------|------|-------| | `get()` | 1 | fetch and cache the record | | `update(data)` | 1 | update and re-cache | | `delete()` | 1 | delete by id | | `field_values()` | 0 cached / 1 | field values keyed by field name | | `expand([...])` | 1 per relation | eager-load related records (phase 3) | | `()` e.g. `c.space()` | 1 (0 if cached) | follow a foreign key to the related record | | `()` e.g. `c.labels()` | — | a **relation-collection** (see relations-expand.md) | ## Why a handle and not `of()` The earlier `of(entity)` navigator required you to fetch the model first and read backwards. `ref` reads forward ("record 42 → its labels"), works from a bare id without a fetch, and groups everything about one record under one autocomplete. `of()` remains as a `@deprecated` alias during the transition. Models stay **pure data** — no hidden I/O on a model object. The handle holds the cache and every method documents its API-call cost. --- title: "Filtering" --- # Filtering **Use the `Filter` builder — you shouldn't have to know the grammar.** It composes a valid filter from readable helpers (`eq`, `gt`, `like`, `in`, `and`, `or`) and handles operators, escaping and grouping for you. The raw DSL below is the reference for power users and for reading what the builder produces. ## Filter builder (recommended) ```python from boostspace import Filter bs.spaces.list(filter=Filter.equals("color", "#4A90D9").and_(Filter.greater_than_or_equal("id", 3))) bs.spaces.list(filter=Filter.any_of(Filter.equals("name", "Acme"), Filter.equals("name", "Globex"))) bs.spaces.list(filter=Filter.contains("name", "acme")) # ~ %acme% ``` ```ts import { Filter } from "@boost-space/sdk"; bs.spaces.list({ filter: Filter.equals("color", "#4A90D9").and(Filter.greaterThanOrEqual("id", 3)).build() }); bs.spaces.list({ filter: Filter.contains("name", "acme").build() }); ``` ```php use BoostSpace\Sdk\Runtime\Filter; $bs->spaces->list(filter: (string) Filter::equals('color', '#4A90D9')->and(Filter::greaterThanOrEqual('id', 3))); ``` ```go bs.Spaces.List(ctx, boostspace.ListParams{ Filter: boostspace.FilterEquals("color", "#4A90D9").And(boostspace.FilterGreaterThanOrEqual("id", "3")).String(), }) ``` Readable helpers, one per operator: `equals`, `notEquals`, `greaterThan`, `greaterThanOrEqual`, `lessThan`, `lessThanOrEqual`, `in`, `isNull`, and `like`/`notLike` (raw `%` control). Plus **wildcard shortcuts so you never type `%`**: `contains` (→ `~ %v%`), `startsWith` (→ `~ v%`), `endsWith` (→ `~ %v`). Combine with `and`/`or` (OR nested in AND is parenthesised automatically). A plain string is still accepted anywhere a filter is expected, so the raw DSL remains an escape hatch. ## Raw grammar (reference) Every `list` endpoint accepts a `filter` string in the Boost.space filter DSL. The SDK URL-encodes it for you — you never encode `>`, `;`, `|` or `%` yourself. ``` filter = condition ( (";" | "&" | "|") condition )* condition = field operator value ``` - **`;` or `&`** join conditions with **AND**. - **`|`** joins with **OR**. - Parentheses group: `(a|b);c` = *(a OR b) AND c*. ### Operators | Operator | Meaning | Example | |----------|---------|---------| | `=` | equals (empty value also matches NULL) | `status=1` | | `!=` | not equals | `status!=1` | | `>` `>=` `<` `<=` | numeric / date comparison | `id>3` | | `~` | LIKE — `%` is the wildcard (empty matches NULL/empty) | `name~%acme%` | | `!~` | NOT LIKE | `name!~%test%` | | `...` | IN a comma-separated set | `id...3,5,7` | > These **nine** operators are the whole grammar (from the API's `FormulaOperator`). > There is **no user-facing "NOT IN"** — negate with `!=` or compose with `!~`. > IN takes a comma-separated list after `...` (`id...3,5,7`). The SDK > URL-encodes the whole expression (`~`, `%`, `...`, `|`, spaces) for you — the > builder produces the raw string, the HTTP layer encodes it. Verified live: > `Filter.in_("id",[3,5,7])` → `id...3,5,7` → rows 3,5,7; `not_like("name","%a%")` > → `name!~%a%`. ## Verified examples Run live against the seeded API (`GET /space`), results are record IDs: | Filter | Result | |--------|--------| | `id>3` | `5,6,7,8` | | `id>=3;id<=6` | `3,5,6` (range, AND) | | `name~%a%` | `1,2,3,5,6` (LIKE) | | `id=1\|id=7` | `1,7` (OR) | ## Per language ```python bs.spaces.list(filter="id>=3;id<=6") # Python ``` ```ts bs.spaces.list({ filter: "id>=3;id<=6" }); // TypeScript ``` ```php $bs->spaces->list(filter: 'id>=3;id<=6'); // PHP ``` ```go bs.Spaces.List(ctx, boostspace.ListParams{Filter: "id>=3;id<=6"}) // Go ``` > The full grammar lives in the API's shared `filter` parameter description, so > it also appears in every `list` method's generated doc comment and in > `sdk-catalog.json`. --- title: "Delta sync & bulk operations" --- # Delta sync & bulk operations ## Delta sync — records changed since a timestamp `records` supports incremental sync directly on `list`: pass `updated_since` (a Unix timestamp) and the paginator streams only the records changed at or after that moment, so you don't re-pull the whole dataset. Pair it with `list_deleted` to also learn which records were removed since the same point. ```python since = "1704067200" # Unix timestamp of your last sync for record in bs.records.list(updated_since=since): # streams changed records reindex(record) for deleted_id in bs.records.list_deleted(updated_since=since): drop(deleted_id) ``` ```ts for await (const r of bs.records.list({ updatedSince: 1704067200 })) { reindex(r); } for await (const id of bs.records.listDeleted({ updatedSince: 1704067200 })) { drop(id); } ``` > `list_deleted` returns just the deleted record IDs (not full models), so a sync > can prune its local copy without a second lookup. ## Bulk with chunking Bulk is not a separate method — **the verb is polymorphic and the argument shape decides**: `delete(42)` deletes one record, `delete([1, 2])` deletes many in one request; `update(42, data)` vs `update([rec1, rec2])` likewise. (Go has no overloads, so the list shape is `DeleteMany` / `UpdateMany` there.) For large inputs the `*Chunked` variant splits the array into chunks and reports **per-chunk** outcomes instead of failing all-or-nothing: ```python result = bs.records.update_chunked(batch, chunk_size=100) print(result.succeeded, result.failed) # BulkResult: successes + per-chunk errors for err in result.errors: print(err.chunk_index, err.error) ``` ```ts const result = await bs.records.updateChunked(batch, 100); ``` ```go result, _ := bs.Records.UpdateManyChunked(ctx, batch, 100) ``` A plain bulk `update([records])` is a single request (all-or-nothing); `updateChunked` trades atomicity for resilience + progress on big batches. Each chunk is one API call — see the method's `Cost:` line. --- title: "Testing & mocking" --- # Testing & mocking Every client accepts an injected transport, so you can unit-test code that uses the SDK **without a live API** — using each language's standard mocking tool. No network, fully deterministic. ## Python — `httpx.MockTransport` ```python import httpx from boostspace import BoostSpace def handler(request: httpx.Request) -> httpx.Response: return httpx.Response(200, json={"id": 1, "name": "Mock Inc"}) bs = BoostSpace("token", system="acme", http_client=httpx.Client(transport=httpx.MockTransport(handler))) assert bs.spaces.get(1).name == "Mock Inc" ``` ## TypeScript — a mock `fetch` ```ts const bs = new BoostSpace({ token: "t", system: "acme", fetch: async () => new Response(JSON.stringify({ id: 1, name: "Mock Inc" }), { status: 200, headers: { "content-type": "application/json" } }), }); ``` ## PHP — Guzzle `MockHandler` ```php use GuzzleHttp\{Client, HandlerStack}; use GuzzleHttp\Handler\MockHandler; use GuzzleHttp\Psr7\Response; $http = new Client(['handler' => HandlerStack::create(new MockHandler([ new Response(200, [], json_encode(['id' => 1, 'name' => 'Mock Inc'])), ]))]); $bs = new BoostSpace('t', system: 'acme', http: $http); ``` ## Go — a custom `RoundTripper` ```go rt := roundTripFunc(func(r *http.Request) (*http.Response, error) { body := `{"id":1,"name":"Mock Inc"}` return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(body)), Header: http.Header{}}, nil }) bs := boostspace.NewClient("t", boostspace.WithSystem("acme"), boostspace.WithHTTPClient(&http.Client{Transport: rt})) ``` The injected transport still gets the SDK's base URL + auth applied, so your handler sees exactly the request the SDK would send in production. Each language's test suite includes a mock-transport test as a worked example. ## Fixtures — sample model instances Rather than hand-write a full payload for every mock response, use the generated fixture factory: it returns an instance of a resource model with its **required** fields pre-filled. One factory per resource model. ```python from boostspace import fixtures space = fixtures.space(name="Acme") # overrides merged in ``` ```ts const space = fixtures.space({ name: "Acme" }); // spread overrides ``` ```php $space = \BoostSpace\Sdk\Fixtures::space(); // then mutate public props $space->name = 'Acme'; ``` ```go space := boostspace.FixtureSpace() // then mutate the struct space.Name = "Acme" ``` Combine the two: return `fixtures.space(...)` (serialised) from your mock handler to get a valid response body with almost no boilerplate. Fixtures fill only required fields (deterministic sample values); set anything else the test cares about via overrides / mutation. --- title: "Labels" description: "Boost.space Labels API — 16 operations, model `Label`." --- > Auto-generated from the OpenAPI spec. Method names shown are the manifest > (canonical) names; per-language casing is applied by each SDK. **Record handle:** `ref(id)` → a lazy handle to one Label (get/update/delete, field values, related records). See [record handles](/sdk/guides/record-handles). ## `bulkDelete` `DELETE /label` Bulk delete labels | Parameter | In | Required | Description | |---|---|---|---| | `body` | body | yes | Labels - array of IDs to be deleted | **Returns:** `list` · **Cost:** 1 API call. ## `bulkUpdate` `PUT /label` Bulk update labels | Parameter | In | Required | Description | |---|---|---|---| | `body` | body | yes | Label - array of Label records to be updated | **Returns:** `list