# Export a Month of Time Records
Source: https://beebole.com/help/api/examples/example-1

End-to-end Beebole GraphQL example: authenticate, query getTimeRecords with a typed filter and date window, and read durations in milliseconds.

This example walks through a complete read workflow with the [Beebole GraphQL API](/help/api/introduction): exporting one month of logged time for reporting. You authenticate with your API key, query `getTimeRecords` for a date window, narrow the results with a typed filter, select the fields you need, and read the returned durations — which Beebole expresses in milliseconds.

<Info>
  This is a read-only workflow. `getTimeRecords` never modifies data. To create or edit entries, see [Log time entries programmatically](/help/api/examples/example-2).
</Info>

***

## What this example does

It fetches every worked time record for one person across a calendar month, returning each record's duration, day, billable flag, and the related person and projects. The result is the raw data you would feed into a report, an invoice, or a data warehouse.

The query uses three pieces of the API:

* The `startTime` and `endTime` top-level arguments to bound the period (Unix timestamps in milliseconds).
* The `time: true` argument to return only worked time, excluding absence entries.
* The `filter` argument — a list of typed input objects — to restrict results to one person.

***

## Step 1 — Send the request with your API key

Every request is a `POST` to `https://app.beebole.com/graphql` with your key in the `apikey` HTTP header. Here is the full call with `curl`:

```bash theme={null}
curl -X POST https://app.beebole.com/graphql \
  -H "Content-Type: application/json" \
  -H "apikey: YOUR_API_KEY" \
  -d '{
    "query": "query ($start: BeeboleTimestamp, $end: BeeboleTimestamp, $filter: [BeeboleTimeRecordFilter]) { getTimeRecords(startTime: $start, endTime: $end, time: true, filter: $filter) { id duration startTime { ts iso } nonBillable person { id name } projects { id name } } }",
    "variables": {
      "start": 1717200000000,
      "end": 1719791999999,
      "filter": [{ "personId": "64a1b2c3d4e5f6a7b8c9d0e1" }]
    }
  }'
```

The two timestamps bracket June 2024: `1717200000000` is June 1 at 00:00 UTC and `1719791999999` is the last millisecond of June 30.

***

## Step 2 — The query

The same operation written as a standalone GraphQL document:

```graphql theme={null}
query ExportTimeRecords {
  getTimeRecords(
    startTime: 1717200000000
    endTime: 1719791999999
    time: true
    filter: [{ personId: "64a1b2c3d4e5f6a7b8c9d0e1" }]
  ) {
    id
    duration
    startTime {
      ts
      iso
    }
    nonBillable
    person {
      id
      name
    }
    projects {
      id
      name
    }
  }
}
```

Each object in the `filter` array sets a single matching field. To combine conditions — for example, one person on a specific project — chain them with a `following` value of `AND` or `OR`:

```graphql theme={null}
query {
  getTimeRecords(
    startTime: 1717200000000
    endTime: 1719791999999
    time: true
    filter: [
      { personId: "64a1b2c3d4e5f6a7b8c9d0e1", following: AND }
      { projectIds: ["64a1b2c3d4e5f6a7b8c9d0e2"] }
    ]
  ) {
    id
    duration
    projects {
      id
      name
    }
  }
}
```

<Info>
  The Beebole query API has no pagination — there are no `limit`, `offset`, or cursor arguments. `getTimeRecords` returns every record matching its arguments. Size the result first with `countTimeRecords`, which takes the same arguments and returns an integer.
</Info>

***

## Step 3 — Read the response

A successful response returns the matching records under `data.getTimeRecords`:

```json theme={null}
{
  "data": {
    "getTimeRecords": [
      {
        "id": "665b1f8e0a1c2d3e4f5a6b70",
        "duration": 7200000,
        "startTime": {
          "ts": 1717372800000,
          "iso": "2024-06-03T00:00:00.000Z"
        },
        "nonBillable": false,
        "person": {
          "id": "64a1b2c3d4e5f6a7b8c9d0e1",
          "name": "Alice Martin"
        },
        "projects": [
          {
            "id": "64a1b2c3d4e5f6a7b8c9d0e2",
            "name": "Website Redesign"
          }
        ]
      },
      {
        "id": "665b1f8e0a1c2d3e4f5a6b71",
        "duration": 27000000,
        "startTime": {
          "ts": 1717459200000,
          "iso": "2024-06-04T00:00:00.000Z"
        },
        "nonBillable": true,
        "person": {
          "id": "64a1b2c3d4e5f6a7b8c9d0e1",
          "name": "Alice Martin"
        },
        "projects": [
          {
            "id": "64a1b2c3d4e5f6a7b8c9d0e3",
            "name": "Internal"
          }
        ]
      }
    ]
  }
}
```

***

## Reading the milliseconds duration

`duration` is an integer count of **milliseconds**. To present it as hours, divide by `3600000` (1000 × 60 × 60):

* `7200000` ms ÷ `3600000` = **2 hours**
* `27000000` ms ÷ `3600000` = **7.5 hours**

`startTime` is an object with two fields: `ts` (a Unix timestamp in milliseconds, marking the day the time was logged) and `iso` (the same instant as an ISO 8601 string). Use `ts` with your language's date utilities (for example, `new Date(record.startTime.ts)` in JavaScript), or read `iso` directly. The `nonBillable` flag tells you whether the entry counts as billable when you build invoicing reports.

***

## Related content

<CardGroup>
  <Card title="API Introduction" icon="book" href="/help/api/introduction">
    Authenticate with your API key and send your first request.
  </Card>

  <Card title="Queries" icon="magnifying-glass" href="/help/api/queries">
    Every read operation, with the typed filter input and date arguments.
  </Card>

  <Card title="Mutations" icon="pen" href="/help/api/mutations">
    The write operations that create and update records.
  </Card>
</CardGroup>


# Log Time Entries Programmatically
Source: https://beebole.com/help/api/examples/example-2

End-to-end Beebole GraphQL example: add a time record with a millisecond duration, adjust it, clone a week, and submit the timesheet for approval.

This example walks through a complete write workflow with the [Beebole GraphQL API](/help/api/introduction): logging time on behalf of a team member and moving it through the approval flow. You authenticate with your API key, create a time record with `addTimeRecord`, adjust it, clone a full week with `cloneTimeRecords`, and submit the period with `submitTimesheet`. Every duration in Beebole is expressed in milliseconds.

<Info>
  These are write operations — they create and change data. For read-only reporting, see [Export a month of time records](/help/api/examples/example-1).
</Info>

***

## Step 1 — Log a time entry

`addTimeRecord` creates one logged entry for a person on a given day. The required arguments are `startTime` (a Unix timestamp in milliseconds), `duration` (milliseconds), and `personId`. Pass `taskId`, `absenceId`, or `projectIds` to link the entry. Here the call logs 2 hours against a task.

<Info>
  Durations are in **milliseconds**. To log 2 hours, pass `7200000` (2 × 60 × 60 × 1000) — not `120` and not `2`.
</Info>

```bash theme={null}
curl -X POST https://app.beebole.com/graphql \
  -H "Content-Type: application/json" \
  -H "apikey: YOUR_API_KEY" \
  -d '{
    "query": "mutation { addTimeRecord(startTime: 1717200000000, duration: 7200000, personId: \"64a1b2c3d4e5f6a7b8c9d0e1\", taskId: \"64a1b2c3d4e5f6a7b8c9d0e3\") { id duration startTime { ts iso } } }"
  }'
```

The same operation as a GraphQL document:

```graphql theme={null}
mutation LogTime {
  addTimeRecord(
    startTime: 1717200000000
    duration: 7200000
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
    taskId: "64a1b2c3d4e5f6a7b8c9d0e3"
  ) {
    id
    duration
    startTime {
      ts
      iso
    }
  }
}
```

The mutation returns the created record, including its `id`:

```json theme={null}
{
  "data": {
    "addTimeRecord": {
      "id": "665b1f8e0a1c2d3e4f5a6b70",
      "duration": 7200000,
      "startTime": {
        "ts": 1717200000000,
        "iso": "2024-06-01T00:00:00.000Z"
      }
    }
  }
}
```

Store the returned `id` — you will need it to update the record.

***

## Step 2 — Adjust the entry

Each editable field has its own mutation. To correct the logged duration, call `editTimeRecordDuration` with the record `id` and the new millisecond value. This changes the entry from 2 hours to 3 hours (`10800000` ms):

```graphql theme={null}
mutation {
  editTimeRecordDuration(
    id: "665b1f8e0a1c2d3e4f5a6b70"
    duration: 10800000
  ) {
    id
    duration
  }
}
```

Related per-field mutations follow the same shape: `editTimeRecordStartTime`, `editTimeRecordProjects`, `editTimeRecordTask`, `editTimeRecordComment`, and `editTimeRecordNonBillable`. Each takes the record `id` plus the one value to change and returns the updated record.

***

## Step 3 — Clone a full week

When a person's week repeats a regular pattern, `cloneTimeRecords` copies their entries from a source period to a target period in one call. Set `replaceExisting: true` to clear the target period before cloning.

```graphql theme={null}
mutation CloneWeek {
  cloneTimeRecords(
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
    sourceStartTime: 1717200000000
    sourceEndTime: 1717718400000
    targetStartTime: 1717804800000
    targetEndTime: 1718323200000
    replaceExisting: true
  ) {
    id
    startTime {
      ts
      iso
    }
    duration
  }
}
```

The mutation returns the list of newly created records:

```json theme={null}
{
  "data": {
    "cloneTimeRecords": [
      {
        "id": "665b2a110a1c2d3e4f5a6b80",
        "startTime": {
          "ts": 1717804800000,
          "iso": "2024-06-08T00:00:00.000Z"
        },
        "duration": 10800000
      },
      {
        "id": "665b2a110a1c2d3e4f5a6b81",
        "startTime": {
          "ts": 1717891200000,
          "iso": "2024-06-09T00:00:00.000Z"
        },
        "duration": 7200000
      }
    ]
  }
}
```

***

## Step 4 — Submit the timesheet

Once the period is complete, `submitTimesheet` sends it into the approval workflow. It takes the `personId` and the `startTime` / `endTime` of the period, and returns a submit event whose `id` you pass to `approveTimesheet` or `rejectTimesheet` later.

```graphql theme={null}
mutation SubmitMonth {
  submitTimesheet(
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
    startTime: 1717200000000
    endTime: 1719791999999
  ) {
    id
    status
    stage
  }
}
```

```json theme={null}
{
  "data": {
    "submitTimesheet": {
      "id": "665b3c920a1c2d3e4f5a6b90",
      "status": "s",
      "stage": 0
    }
  }
}
```

The `status` field reports the period's approval state — `d` (draft), `s` (submitted), `a` (approved), or `r` (rejected). Beebole determines the current approval `stage` automatically.

<Warning>
  Deletions made through the API cannot be undone. `cloneTimeRecords` with `replaceExisting: true` first deletes the existing records in the target period — make sure the target window is correct before sending it.
</Warning>

***

## Related content

<CardGroup>
  <Card title="API Introduction" icon="book" href="/help/api/introduction">
    Authenticate with your API key and send your first request.
  </Card>

  <Card title="Mutations" icon="pen" href="/help/api/mutations">
    Every write operation, with full argument signatures.
  </Card>

  <Card title="Queries" icon="magnifying-glass" href="/help/api/queries">
    Read back the records you create with these mutations.
  </Card>
</CardGroup>


# API Documentation
Source: https://beebole.com/help/api/introduction

Get started with the Beebole GraphQL API: how the endpoint works, how to authenticate with an API key, and how to send your first query or mutation.

Beebole exposes a [GraphQL](https://graphql.org/) API that gives you full programmatic access to your account data. You can read time records, people, projects, and tasks, and you can create or update records directly — all over a single HTTP endpoint.

For a guided overview of what you can build with the API, see [Custom Integrations](/help/integrations/custom-integrations).

***

## Endpoint

All API requests go to:

```text theme={null}
POST https://app.beebole.com/graphql
```

The API accepts `application/json` bodies containing a `query` string and an optional `variables` object.

***

## Authentication

Beebole uses API key authentication. Include your API key as a request header named `apikey`:

```http theme={null}
apikey: YOUR_API_KEY
```

<Steps>
  <Step title="Open your API key">
    In Beebole, click the button with your initials at the bottom of the left sidebar, then click **API Key**.
  </Step>

  <Step title="Open API settings">
    Go to **Settings** > **API** in your Beebole account.
  </Step>

  <Step title="Copy your API key">
    Your **API Key** is displayed on this page. Click **Copy** to copy it to the clipboard.
  </Step>

  <Step title="Include the key in every request">
    Add the `apikey` header to all HTTP requests you send to the endpoint.
  </Step>
</Steps>

The panel shows a single active API key, and it does not expire. The key authenticates as the person it belongs to, so requests inherit that person's role and permissions.

<Warning>
  Keep your API key secure. Do not include it in client-side code or commit it to public repositories. Store it in an environment variable or a secrets manager. If a key is compromised, open the **API Key** panel and click **Reset** to revoke the current key and generate a new one.
</Warning>

***

## Making a request

A GraphQL request is a POST with a JSON body containing a `query` field (and optionally `variables`). Here is a minimal example using `curl`:

```bash theme={null}
curl -X POST https://app.beebole.com/graphql \
  -H "Content-Type: application/json" \
  -H "apikey: YOUR_API_KEY" \
  -d '{"query": "{ currentPerson { name email } }"}'
```

A successful response looks like this:

```json theme={null}
{
  "data": {
    "currentPerson": {
      "name": "Alice Martin",
      "email": "alice@example.com"
    }
  }
}
```

***

## Queries and mutations

The Beebole API uses standard GraphQL conventions:

* **Queries** read data without side effects. Use them to fetch people, projects, tasks, time records, expense records, and more.
* **Mutations** write data. Use them to create, update, archive, or delete entities.

See the full reference pages for details:

* [Queries](/help/api/queries) — all available read operations
* [Mutations](/help/api/mutations) — all available write operations
* [Schema explorer](/help/api/schema-explorer) — how to explore the schema with introspection and a GraphQL client

***

## Error handling

GraphQL responses follow the standard shape: results come back under `data`, and any operation-level errors come back in an `errors` array.

```json theme={null}
{
  "errors": [
    {
      "message": "AccountIsInactive"
    }
  ]
}
```

### Authentication errors

If the `apikey` header is missing or invalid, Beebole cannot resolve the linked person. You may see one of these authentication messages in the `errors` array:

| Message                                  | Cause                                                |
| ---------------------------------------- | ---------------------------------------------------- |
| `APIKeyError:InvalidKey`                 | The API key is missing or not recognized             |
| `APIKeyError:CantFindLinkedAccount`      | The person linked to this key no longer exists       |
| `APIKeyError:CantFindLinkedOrganisation` | The organization linked to this key no longer exists |

### Permission handling

Beebole resolves permissions per operation. If a request asks for data or an action the linked person is not authorized for, Beebole omits the affected fields from `data` and lists their paths in a `permissionsErrors` array, rather than failing the whole request:

```json theme={null}
{
  "data": {},
  "permissionsErrors": ["Query.currentPerson", "BeebolePerson.*"]
}
```

When an account's subscription is inactive, API-key requests are blocked with HTTP `402 Payment Required` and an `AccountIsInactive` error. Browser sessions are not blocked the same way, so this only affects API access.

***

## Rate limits

Beebole does not apply a general rate limit to GraphQL API traffic. Rate limiting is reserved for a small set of sensitive operations — such as sign-in, sign-up, inviting people, and loading public holidays — which are not part of a typical integration workflow. For very high request volumes, batch related operations into fewer requests where possible, and contact [support@beebole.com](mailto:support@beebole.com) if you have specific throughput needs.

***

## Related content

<CardGroup>
  <Card title="Queries" icon="magnifying-glass" href="/help/api/queries">
    All available GraphQL read operations in the Beebole API.
  </Card>

  <Card title="Mutations" icon="pen" href="/help/api/mutations">
    All available GraphQL write operations in the Beebole API.
  </Card>

  <Card title="MCP server" icon="plug" href="/help/integrations/mcp-server">
    Let Claude, ChatGPT, or Claude Code work with your Beebole data.
  </Card>

  <Card title="Webhooks" icon="webhook" href="/help/integrations/webhooks">
    Receive signed, real-time event notifications on your own endpoints.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I use any programming language with the API?">
    Yes. The API is standard GraphQL over HTTPS. Any language with an HTTP client — Python, JavaScript, Ruby, Go, Java, and others — can make requests.
  </Accordion>

  <Accordion title="Where do I find my API key?">
    In Beebole, click the button with your initials at the bottom of the left sidebar, then click **API Key**. Beebole creates the key automatically, and you can **Copy** or **Reset** it from that panel.
  </Accordion>

  <Accordion title="Can I use the API to read and write time records?">
    Yes. The API supports both queries (reading time records) and mutations (creating and editing time entries). See [Queries](/help/api/queries) and [Mutations](/help/api/mutations) for the full list of operations.
  </Accordion>

  <Accordion title="How do I explore the API schema?">
    The Beebole API supports GraphQL introspection, so any standard GraphQL client can fetch the full schema — types, queries, mutations, and their arguments. See the [Schema explorer](/help/api/schema-explorer) page for how to connect a GraphQL client.
  </Accordion>
</AccordionGroup>


# GraphQL Mutations to Create and Update
Source: https://beebole.com/help/api/mutations

Reference for Beebole GraphQL mutations: log time and expenses, submit and approve timesheets, and manage people, projects, tasks, and organization settings.

Mutations are the GraphQL write operations of the Beebole API. They create, update, archive, or delete data in your Beebole account — logging time and expenses, running the timesheet approval workflow, and managing people, projects, tasks, and organization settings. Send every mutation as a `POST` request to `https://app.beebole.com/graphql` with your key in the `apikey` HTTP header (see [Introduction](/help/api/introduction#authentication)).

Each mutation returns the affected object so you can read back fields in the same request. Object IDs are exposed as `id` (not `_id`). For read-only operations, see [Queries](/help/api/queries).

<Info>
  Time durations in Beebole are expressed in **milliseconds**. To log 2 hours, pass `7200000` (2 × 60 × 60 × 1000), not `120`.
</Info>

***

## Time records

A time record is one logged entry for a person on a given day, linked to projects, a task, or an absence type. Durations are in milliseconds.

| Mutation                    | Key arguments                                                                                                  |
| --------------------------- | -------------------------------------------------------------------------------------------------------------- |
| `addTimeRecord`             | `startTime`, `duration`, `personId`, optional `endTime`, `taskId`, `absenceId`, `projectIds`                   |
| `editTimeRecordStartTime`   | `id`, `startTime`                                                                                              |
| `editTimeRecordEndTime`     | `id`, `endTime`                                                                                                |
| `editTimeRecordDuration`    | `id`, `duration` (milliseconds)                                                                                |
| `editTimeRecordProjects`    | `id`, `projectIds`                                                                                             |
| `editTimeRecordTask`        | `id`, `taskId`                                                                                                 |
| `editTimeRecordAbsence`     | `id`, `absenceId`                                                                                              |
| `editTimeRecordComment`     | `id`, `comment`                                                                                                |
| `editTimeRecordNonBillable` | `id`, `nonBillable`                                                                                            |
| `editTimeRecordWfh`         | `id`, `wfh`                                                                                                    |
| `deleteTimeRecords`         | `ids` (array)                                                                                                  |
| `cloneTimeRecords`          | `personId`, `sourceStartTime`, `sourceEndTime`, `targetStartTime`, `targetEndTime`, optional `replaceExisting` |

`startTime` and `endTime` are Unix timestamps in milliseconds. `duration` is an integer count of **milliseconds**.

### Log a time entry

This logs 2 hours (`7200000` milliseconds) for a person against a task:

```graphql theme={null}
mutation {
  addTimeRecord(
    startTime: 1717200000000
    duration: 7200000
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
    taskId: "64a1b2c3d4e5f6a7b8c9d0e3"
  ) {
    id
    duration
    startTime {
      ts
      iso
    }
  }
}
```

### Clone a week of time records

`cloneTimeRecords` copies a person's entries from a source period to a target period. Set `replaceExisting: true` to clear the target period first.

```graphql theme={null}
mutation {
  cloneTimeRecords(
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
    sourceStartTime: 1717200000000
    sourceEndTime: 1717718400000
    targetStartTime: 1717804800000
    targetEndTime: 1718323200000
    replaceExisting: true
  ) {
    id
    startTime {
      ts
      iso
    }
    duration
  }
}
```

***

## Expense records

An expense record is an actual expense logged against a person and/or a project. The amount is sent as `value` with an optional `currency`; if you omit the currency, Beebole uses the person's or organization's default.

| Mutation                          | Key arguments                                                                             |
| --------------------------------- | ----------------------------------------------------------------------------------------- |
| `addExpenseRecord`                | `date`, `expenseTypeId`, `value`, optional `currency`, `personId`, `projectId`, `comment` |
| `deleteExpenseRecord`             | `id`                                                                                      |
| `editExpenseRecordDate`           | `id`, `date`                                                                              |
| `editExpenseRecordExpense`        | `id`, `expenseTypeId`                                                                     |
| `editExpenseRecordPerson`         | `id`, `personId` (null to remove)                                                         |
| `editExpenseRecordProject`        | `id`, `projectId` (null to remove)                                                        |
| `editExpenseRecordAmountValue`    | `id`, `value`                                                                             |
| `editExpenseRecordAmountCurrency` | `id`, `currency`                                                                          |
| `editExpenseRecordComment`        | `id`, `comment`                                                                           |

<Info>
  At least one of `personId` or `projectId` is required on `addExpenseRecord` — both are otherwise optional.
</Info>

### Log an expense

```graphql theme={null}
mutation {
  addExpenseRecord(
    date: 1717200000000
    expenseTypeId: "64a1b2c3d4e5f6a7b8c9d0e4"
    value: 4250
    currency: "EUR"
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
  ) {
    id
    amount {
      value
      currency
    }
    date {
      ts
      iso
    }
  }
}
```

***

## Timesheets and approvals

The approval workflow runs through three mutations. There is no single "add approval event" call — submitting, approving, and rejecting are distinct operations that return a `BeeboleApprovalEvent`.

| Mutation                | Key arguments                                  |
| ----------------------- | ---------------------------------------------- |
| `submitTimesheet`       | `personId`, `startTime`, `endTime`             |
| `approveTimesheet`      | `id` (the submit event ID)                     |
| `rejectTimesheet`       | `id` (the submit event ID), `stage`, `comment` |
| `sendTimesheetReminder` | `personIds` (array), `startTime`, `endTime`    |

Beebole determines the current approval stage automatically. `submitTimesheet` returns the submit event whose `id` you pass to `approveTimesheet` or `rejectTimesheet`.

### Submit a timesheet for a period

```graphql theme={null}
mutation {
  submitTimesheet(
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
    startTime: 1717200000000
    endTime: 1719792000000
  ) {
    id
    status
    stage
  }
}
```

### Approve or reject

```graphql theme={null}
mutation {
  approveTimesheet(id: "64a1b2c3d4e5f6a7b8c9d0e5") {
    id
    status
  }
}
```

```graphql theme={null}
mutation {
  rejectTimesheet(
    id: "64a1b2c3d4e5f6a7b8c9d0e5"
    stage: 0
    comment: "Please add the client meeting on Tuesday."
  ) {
    id
    status
    comment
  }
}
```

***

## People

| Mutation                              | Key arguments                               |
| ------------------------------------- | ------------------------------------------- |
| `addPerson`                           | `name`, `email`, `roleId`, optional `color` |
| `deletePerson`                        | `id`, optional `check` (dry-run)            |
| `duplicatePerson`                     | `id`, `name`, optional `email`, `roleId`    |
| `archivePerson` / `unarchivePerson`   | `id`                                        |
| `archivePersons` / `unarchivePersons` | `ids` (array)                               |
| `editPersonName`                      | `id`, `name`                                |
| `editPersonEmail`                     | `id`, `email`                               |
| `editPersonRole`                      | `id`, `roleId`                              |
| `editPersonStartDate`                 | `id`, `startDate`                           |
| `editPersonColor`                     | `id`, `color`                               |
| `editPersonLang`                      | `id`, `lang`                                |

`deletePerson` accepts `check: true` to validate references without deleting.

### Create a person

```graphql theme={null}
mutation {
  addPerson(
    name: "Alice Martin"
    email: "alice@example.com"
    roleId: "64a1b2c3d4e5f6a7b8c9d0e1"
  ) {
    id
    name
  }
}
```

***

## Projects

| Mutation                                | Key arguments                                      |
| --------------------------------------- | -------------------------------------------------- |
| `addProject`                            | `name`, optional `categoryId`, `parentId`, `color` |
| `deleteProject`                         | `id`, optional `check` (dry-run)                   |
| `deleteProjects`                        | `ids` (array)                                      |
| `duplicateProject`                      | `id`, `name`, optional `parentId`                  |
| `archiveProject` / `unarchiveProject`   | `id`                                               |
| `archiveProjects` / `unarchiveProjects` | `ids` (array)                                      |
| `editProjectName`                       | `id`, `name`                                       |
| `editProjectParent`                     | `id`, `parentId`                                   |
| `editProjectColor`                      | `id`, `color`                                      |
| `editProjectAvailability`               | `id`, `availability`                               |
| `addProjectCategory`                    | `name`                                             |
| `deleteProjectCategory`                 | `id`                                               |
| `editProjectCategoryName`               | `id`, `name`                                       |
| `editProjectCategoryLevelNames`         | `id`, `levelNames`                                 |

To create a subproject, pass the parent project's `parentId`. The subproject inherits the parent's category unless you set a different `categoryId`.

### Create a project

```graphql theme={null}
mutation {
  addProject(
    name: "Website Redesign"
    categoryId: "64a1b2c3d4e5f6a7b8c9d0e2"
  ) {
    id
    name
  }
}
```

***

## Tasks

Tasks are independent planning entities you create, schedule, and track time against. Categories organize tasks into workflow statuses.

| Mutation                          | Key arguments                                                  |
| --------------------------------- | -------------------------------------------------------------- |
| `addTask`                         | `name`, optional `categoryId`, `parentId`, `color`, `statusId` |
| `deleteTask`                      | `id`, optional `check` (dry-run)                               |
| `archiveTask` / `unarchiveTask`   | `id`                                                           |
| `archiveTasks` / `unarchiveTasks` | `ids` (array)                                                  |
| `editTaskName`                    | `id`, `name`                                                   |
| `editTaskParent`                  | `id`, `parentId`                                               |
| `editTaskColor`                   | `id`, `color`                                                  |
| `editTaskStatus`                  | `id`, `statusId`                                               |
| `editTaskPeriod`                  | `id`, optional `startTime`, `endTime`, `effort`                |
| `editTaskDuration`                | `id`, `effort` (minutes)                                       |
| `moveTasksToStatus`               | `taskIds`, `targetStatusId`, `orderedTaskIds`                  |

Task categories and their workflow statuses are managed with the category mutations:

| Mutation                                   | Key arguments                    |
| ------------------------------------------ | -------------------------------- |
| `addTaskCategoryStatus`                    | `categoryId`, `name`             |
| `deleteTaskCategoryStatus`                 | `categoryId`, `statusId`         |
| `editTaskCategoryStatusName`               | `statusId`, `name`               |
| `editTaskCategoryStatusColor`              | `statusId`, `color`              |
| `editTaskCategoryStatusMaxConcurrentTasks` | `statusId`, `maxConcurrentTasks` |
| `editCategoryTaskMove`                     | `categoryId`, `taskMove`         |

To move a task between categories or statuses, use `editTaskStatus` (single task) or `moveTasksToStatus` (one or more tasks). `editCategoryTaskMove` sets a category's task-move behavior.

### Create a task

```graphql theme={null}
mutation {
  addTask(
    name: "Write copy"
    categoryId: "64a1b2c3d4e5f6a7b8c9d0e3"
  ) {
    id
    name
  }
}
```

***

## Organization

Organization settings are edited on the single current organization, so these mutations take no `id`. The GraphQL field names keep the British spelling `Organisation`.

| Mutation                | Key arguments                      |
| ----------------------- | ---------------------------------- |
| `editOrganisationName`  | `name`                             |
| `editOrganisationColor` | `color`                            |
| `editGoogleSSO`         | `google` (input)                   |
| `editMicrosoftSSO`      | `microsoft` (input)                |
| `editCustomSSO`         | `customSSO` (input, null to clear) |

### Rename the organization

```graphql theme={null}
mutation {
  editOrganisationName(name: "Acme Corp") {
    id
    name
  }
}
```

***

<Warning>
  Mutations that delete data cannot be undone through the API. Where a `check` argument is available (`deletePerson`, `deleteProject`, `deleteTask`), pass `check: true` first to validate references without deleting anything.
</Warning>

<Tip>
  When creating records, store the returned `id` values so you can reference or update them in follow-up mutations. Batch mutations such as `archivePersons`, `deleteProjects`, and `deleteTimeRecords` accept arrays — prefer them over looping single-item calls.
</Tip>

***

## Related content

<CardGroup>
  <Card title="API Introduction" icon="book" href="/help/api/introduction">
    Authenticate with your API key and send your first request.
  </Card>

  <Card title="Queries" icon="magnifying-glass" href="/help/api/queries">
    Read time records, people, projects, and tasks over GraphQL.
  </Card>

  <Card title="Schema explorer" icon="diagram-project" href="/help/api/schema-explorer">
    Browse the full GraphQL schema interactively.
  </Card>
</CardGroup>


# Querying time records, projects, and people
Source: https://beebole.com/help/api/queries

Reference for Beebole GraphQL queries — read organizations, people, projects, tasks, tags, time records, and expenses, with typed filter inputs.

Beebole queries are the read operations of the [Beebole GraphQL API](/help/api/introduction). They return data from your account — your organization, people, projects, tasks, tags, time records, and expenses — without modifying anything. Every query is sent as a `POST` request to `https://app.beebole.com/graphql` with your API key in the `apikey` HTTP header.

<Info>
  Queries never change data. To create, update, archive, or delete records, use [Mutations](/help/api/mutations) instead. For authentication setup, see the [API introduction](/help/api/introduction#authentication).
</Info>

Field names follow GraphQL conventions exactly as defined in the schema. Every entity exposes its identifier as `id` (not `_id`), and the organization-level query is spelled `currentOrganisation` (British spelling, as in the schema).

***

## Organization

Read account-level data with `currentOrganisation` and `getAuditTrails`.

| Query                 | Arguments                                                                   | Returns                                              |
| --------------------- | --------------------------------------------------------------------------- | ---------------------------------------------------- |
| `currentOrganisation` | none                                                                        | The organization linked to the authenticated API key |
| `getAuditTrails`      | `startTime`, `fromPersonId`, `operations`, `argumentMatch`, `responseMatch` | Audit trail entries for the organization             |

```graphql theme={null}
query {
  currentOrganisation {
    id
    name
    locked
  }
}
```

`getAuditTrails` returns mutations performed in the account. With no `startTime`, it covers the last seven days; `startTime` selects a different seven-day window.

```graphql theme={null}
query {
  getAuditTrails(operations: ["addTimeRecord", "deleteTimeRecords"]) {
    operationName
    timestamp
    person {
      id
      name
    }
    arguments {
      name
      value
    }
  }
}
```

***

## People

Read team members with `currentPerson`, `getPerson`, `getPersons`, `countPersons`, and `filterPersonIds`. `getPotentialProjectOwners` lists the people allowed to own a given project.

| Query                       | Arguments            | Returns                            |
| --------------------------- | -------------------- | ---------------------------------- |
| `currentPerson`             | none                 | The person linked to the API key   |
| `getPerson`                 | `id`                 | A single person                    |
| `getPersons`                | `filter`, `archived` | A list of people                   |
| `countPersons`              | `filter`, `archived` | The number of matching people      |
| `filterPersonIds`           | `filter`, `archived` | Only the IDs of matching people    |
| `getPotentialProjectOwners` | `projectId`          | People eligible to own the project |

```graphql theme={null}
query {
  getPersons {
    id
    name
    email
    archived
  }
}
```

```graphql theme={null}
query {
  getPerson(id: "64a1b2c3d4e5f6a7b8c9d0e1") {
    id
    name
    email
    role {
      id
      name
    }
  }
}
```

By default `getPersons` returns only active people. Pass `archived: true` to include archived ones.

```graphql theme={null}
query {
  getPersons(archived: true) {
    id
    name
    archived
  }
}
```

***

## Projects

Read projects with `getProject`, `getProjects`, `countProjects`, and `filterProjectIds`. `getProjectCategories` lists the top-level groupings projects are organised into.

| Query                  | Arguments                          | Returns                           |
| ---------------------- | ---------------------------------- | --------------------------------- |
| `getProject`           | `id`                               | A single project                  |
| `getProjects`          | `filter`, `archived`, `categoryId` | A list of projects                |
| `countProjects`        | `filter`, `archived`, `categoryId` | The number of matching projects   |
| `filterProjectIds`     | `filter`, `archived`, `categoryId` | Only the IDs of matching projects |
| `getProjectCategories` | none                               | All project categories            |

```graphql theme={null}
query {
  getProjects {
    id
    name
    level
    category {
      id
      name
    }
  }
}
```

The `level` field is the project's depth in the hierarchy, where `0` is a top-level project. Restrict results to one category with `categoryId`:

```graphql theme={null}
query {
  getProjects(categoryId: "64a1b2c3d4e5f6a7b8c9d0e1") {
    id
    name
  }
}
```

```graphql theme={null}
query {
  getProjectCategories {
    id
    name
    levelNames
  }
}
```

***

## Tasks

Read tasks with `getTask`, `getTasks`, `countTasks`, and `filterTaskIds`. `getTaskCategories` lists the categories (boards) tasks belong to.

| Query               | Arguments                          | Returns                        |
| ------------------- | ---------------------------------- | ------------------------------ |
| `getTask`           | `id`                               | A single task                  |
| `getTasks`          | `filter`, `archived`, `categoryId` | A list of tasks                |
| `countTasks`        | `filter`, `archived`, `categoryId` | The number of matching tasks   |
| `filterTaskIds`     | `filter`, `archived`, `categoryId` | Only the IDs of matching tasks |
| `getTaskCategories` | none                               | All task categories            |

```graphql theme={null}
query {
  getTasks {
    id
    name
    startTime {
      ts
      iso
    }
    endTime {
      ts
      iso
    }
    status {
      id
      name
    }
  }
}
```

```graphql theme={null}
query {
  getTask(id: "64a1b2c3d4e5f6a7b8c9d0e1") {
    id
    name
    effort
    dependencies {
      id
      name
    }
  }
}
```

***

## Tags

Read tags with `getTag`, `getTags`, `countTags`, and `filterTagIds`. `getTagCategories` lists the categories tags are grouped into.

| Query              | Arguments                          | Returns                       |
| ------------------ | ---------------------------------- | ----------------------------- |
| `getTag`           | `id`                               | A single tag                  |
| `getTags`          | `filter`, `archived`, `categoryId` | A list of tags                |
| `countTags`        | `filter`, `archived`, `categoryId` | The number of matching tags   |
| `filterTagIds`     | `filter`, `archived`, `categoryId` | Only the IDs of matching tags |
| `getTagCategories` | none                               | All tag categories            |

```graphql theme={null}
query {
  getTags {
    id
    name
    level
  }
}
```

***

## Time records

A time record is a logged time entry for one person on a specific day, linked to projects, a task, or an absence type. Read them with `getTimeRecord`, `getTimeRecords`, and `countTimeRecords`. `getAbsenceConsumed` returns how much of an absence type a person has used in a window.

| Query                | Arguments                                                  | Returns                                            |
| -------------------- | ---------------------------------------------------------- | -------------------------------------------------- |
| `getTimeRecord`      | `id`                                                       | A single time record                               |
| `getTimeRecords`     | `startTime`, `endTime`, `time`, `absence`, `wfh`, `filter` | A list of time records                             |
| `countTimeRecords`   | `startTime`, `endTime`, `time`, `absence`, `wfh`, `filter` | The number of matching time records                |
| `getAbsenceConsumed` | `personId`, `absenceId`, `startTime`, `endTime`            | Absence consumed in the window, in the type's unit |

`getTimeRecords` and `countTimeRecords` accept top-level arguments alongside `filter`:

* **`startTime`** / **`endTime`** — Unix timestamps in milliseconds bounding the period.
* **`time`** — when `true`, return only worked time (entries without an absence type).
* **`absence`** — when `true`, return only absence entries (entries with an absence type).
* **`wfh`** — when `true`, return only entries logged as working from home.
* **`filter`** — a typed filter array (see [Filtering results](#filtering-results)).

```graphql theme={null}
query {
  getTimeRecords(startTime: 1704067200000, endTime: 1706745600000, time: true) {
    id
    duration
    startTime {
      ts
      iso
    }
    nonBillable
    person {
      id
      name
    }
    projects {
      id
      name
    }
  }
}
```

`duration` is an integer in milliseconds. `startTime` and `endTime` are `BeeboleTime` objects — select their subfields `ts` (a Unix timestamp in milliseconds) and `iso` (an ISO 8601 string). The `person`, `projects`, `task`, and `absence` fields resolve the related entities inline.

```graphql theme={null}
query {
  getAbsenceConsumed(
    personId: "64a1b2c3d4e5f6a7b8c9d0e1"
    absenceId: "64a1b2c3d4e5f6a7b8c9d0e2"
    startTime: 1704067200000
    endTime: 1735689600000
  )
}
```

***

## Expense records

An expense record is an expense logged by a person against a project and an expense type. Read them with `getExpenseRecord` and `getExpenseRecords`.

| Query               | Arguments                        | Returns                   |
| ------------------- | -------------------------------- | ------------------------- |
| `getExpenseRecord`  | `id`                             | A single expense record   |
| `getExpenseRecords` | `startTime`, `endTime`, `filter` | A list of expense records |

```graphql theme={null}
query {
  getExpenseRecords(startTime: 1704067200000, endTime: 1706745600000) {
    id
    date {
      ts
      iso
    }
    amount {
      value
      currency
    }
    comment
    expenseType {
      id
      name
    }
    project {
      id
      name
    }
  }
}
```

`date` is a `BeeboleTime` object (`ts` in milliseconds, `iso` as an ISO 8601 string). `amount` is an object with `value` (an integer in the currency's smallest unit) and `currency`.

***

## Absence types

Absence types are the kinds of leave people can log against, such as vacation or sick leave. Read them with `getAbsenceType`, `getAbsenceTypes`, and `countAbsenceTypes`.

| Query               | Arguments            | Returns                              |
| ------------------- | -------------------- | ------------------------------------ |
| `getAbsenceType`    | `id`                 | A single absence type                |
| `getAbsenceTypes`   | `filter`, `archived` | A list of absence types              |
| `countAbsenceTypes` | `filter`, `archived` | The number of matching absence types |

```graphql theme={null}
query {
  getAbsenceTypes {
    id
    name
    unit
    involveCosts
  }
}
```

***

## Filtering results

The `filter` argument is **a list of typed input objects** — not a list of `field`/`value` pairs. Each entity has its own filter input type, such as `BeeboleTimeRecordFilter`, `BeebolePersonFilter`, or `BeeboleProjectFilter`. You set the named fields you want to match directly on each object.

```graphql theme={null}
query {
  getTimeRecords(filter: [{ personId: "64a1b2c3d4e5f6a7b8c9d0e1" }]) {
    id
    duration
    startTime {
      ts
      iso
    }
  }
}
```

Each object in the array should set a single matching field. To combine conditions, add a `following` value of `AND` or `OR` to chain one condition to the next:

```graphql theme={null}
query {
  getProjects(
    filter: [
      { categoryId: "64a1b2c3d4e5f6a7b8c9d0e1", following: AND }
      { archived: false }
    ]
  ) {
    id
    name
  }
}
```

### Time record filter fields

`BeeboleTimeRecordFilter` accepts these fields (each optional):

| Field                                          | Type         | Matches                                                         |
| ---------------------------------------------- | ------------ | --------------------------------------------------------------- |
| `id` / `notId`                                 | ID           | A specific time record, or all but one                          |
| `personId` / `notPersonId`                     | ID           | Records for (or excluding) one person                           |
| `personIds`                                    | `[ID]`       | Records for any of several people                               |
| `startTime` / `endTime`                        | Timestamp    | Records starting after / ending before a millisecond timestamp  |
| `projectIds` / `notProjectIds`                 | `[ID]`       | Records on (or excluding) projects, including their subprojects |
| `taskIds` / `notTaskIds`                       | `[ID]`       | Records on (or excluding) tasks                                 |
| `projectTagIds` / `projectNotTagIds`           | `[ID]`       | Records whose projects carry (or lack) given tags               |
| `personTagIds` / `personNotTagIds`             | `[ID]`       | Records whose person carries (or lacks) given tags              |
| `projectCategoryIds` / `notProjectCategoryIds` | `[ID]`       | Records by project category                                     |
| `taskCategoryIds` / `notTaskCategoryIds`       | `[ID]`       | Records by task category                                        |
| `isAbsence`                                    | Boolean      | Whether the record is an absence                                |
| `following`                                    | `AND` / `OR` | Logical operator chaining this condition to the next            |

Other entities expose filter types tuned to their own fields — for example `BeebolePersonFilter` supports `roleId`, `tagIds`, and `name` (a case-insensitive match), while `BeeboleProjectFilter` supports `categoryId`, `managedById`, and `subProjectId`. Browse every filter type and its fields in the [Schema explorer](/help/api/schema-explorer).

***

## Counting and ID-only queries

For each major entity, alongside the full `get…` query you also get a counterpart that returns just a count, and (for people, projects, tasks, and tags) one that returns only matching IDs.

* **`count…`** queries (`countPersons`, `countProjects`, `countTasks`, `countTags`, `countTimeRecords`, `countAbsenceTypes`) return an integer. Use them to size a result set before fetching it.
* **`filter…Ids`** queries (`filterPersonIds`, `filterProjectIds`, `filterTaskIds`, `filterTagIds`) return an array of IDs instead of full objects, which is lighter when you only need identifiers.

```graphql theme={null}
query {
  countTimeRecords(startTime: 1704067200000, endTime: 1706745600000)
}
```

<Info>
  The Beebole query API has no pagination — there are no `limit`, `offset`, `first`, or `cursor` arguments. A list query returns every record that matches its arguments. Narrow large result sets with `filter`, the `startTime` / `endTime` window, or `categoryId`, and use a `count…` query first to gauge the size.
</Info>

***

## Related content

<CardGroup>
  <Card title="API Introduction" icon="book" href="/help/api/introduction">
    Authenticate with an API key and send your first request.
  </Card>

  <Card title="Mutations" icon="pen" href="/help/api/mutations">
    The write operations that create, update, archive, and delete records.
  </Card>

  <Card title="Schema explorer" icon="sitemap" href="/help/api/schema-explorer">
    Browse every query, type, field, and filter input interactively.
  </Card>
</CardGroup>


# GraphQL Schema Explorer & Introspection
Source: https://beebole.com/help/api/schema-explorer

Explore the Beebole GraphQL schema with introspection — connect a GraphQL client to the endpoint to browse types, queries, mutations, and field docs.

The Beebole GraphQL API is self-describing through introspection, so you can explore the full schema — every type, query, mutation, argument, and field — directly from a GraphQL client. Beebole does not ship a separate hosted schema browser; instead, you point any standard GraphQL tool at the API endpoint and let introspection reveal the schema.

<Info>
  Introspection is enabled for API-key requests against the Beebole GraphQL endpoint. There is nothing to turn on in your account — any GraphQL client that supports introspection can read the schema as soon as it can authenticate.
</Info>

***

## The endpoint and authentication

Schema exploration uses the same endpoint and authentication as every other API call:

```
POST https://app.beebole.com/graphql
```

Authenticate by sending your API key in the `apikey` HTTP header:

```http theme={null}
apikey: YOUR_API_KEY
```

For where to find your key, see [Introduction to the Beebole API](/help/api/introduction).

***

## Exploring the schema with introspection

Introspection is a built-in GraphQL feature: the schema can be queried like any other data. A minimal introspection query lists every type the API exposes:

```graphql theme={null}
{
  __schema {
    types {
      name
      kind
    }
  }
}
```

You can also introspect a single type to see its fields, their types, and any descriptions:

```graphql theme={null}
{
  __type(name: "Person") {
    name
    description
    fields {
      name
      description
      type {
        name
        kind
      }
    }
  }
}
```

Most GraphQL clients run a full introspection query automatically when you connect, so you rarely write these queries by hand — the client uses the result to power autocomplete, type-aware validation, and a browsable schema view.

***

## Connecting a GraphQL client

Any GraphQL client or IDE that supports introspection can explore the Beebole schema. Configure it with the endpoint URL and the `apikey` header:

<Steps>
  <Step title="Set the endpoint URL">
    Point the client at `https://app.beebole.com/graphql`.
  </Step>

  <Step title="Add the API key header">
    In the client's HTTP headers configuration, add a header named `apikey` with your key as the value.
  </Step>

  <Step title="Load the schema">
    Run the client's introspection or "refresh schema" action. The client fetches the schema and enables documentation browsing, autocomplete, and validation.
  </Step>
</Steps>

This works with desktop GraphQL IDEs, GraphQL plugins for code editors, and command-line tools that fetch a schema for code generation. Because the schema comes from introspection, it always reflects the live API — there is no separate schema file to download or keep in sync.

***

## Built-in GraphiQL at the endpoint

Beebole serves a GraphiQL IDE — including the schema Explorer panel — directly at the API endpoint. Open `https://app.beebole.com/graphql` in a browser to load it. GraphiQL provides a query editor, a documentation explorer for browsing types and fields, and an Explorer panel for building queries by clicking through the schema.

<Info>
  GraphiQL sends requests to the same `POST /graphql` endpoint, so it follows the same authentication rules. Use GraphiQL's headers editor to add your `apikey` header before running introspection or queries.
</Info>

***

## Related content

<CardGroup>
  <Card title="Introduction" icon="book-open" href="/help/api/introduction">
    The endpoint, API-key authentication, and how to send your first request.
  </Card>

  <Card title="Queries" icon="magnifying-glass" href="/help/api/queries">
    All available GraphQL read operations in the Beebole API.
  </Card>

  <Card title="Mutations" icon="pen" href="/help/api/mutations">
    All available GraphQL write operations in the Beebole API.
  </Card>
</CardGroup>


# Account settings for your organization
Source: https://beebole.com/help/documentation/account-settings

Configure your Beebole organization's defaults from Account Settings: localization, billing, cost, public holidays, work schedule, SSO, and more.

Beebole's **Account Settings** is where administrators set the organization-wide defaults that cascade to everyone in the account. From this page you manage your organization's identity, regional formats, billing and cost rates, work schedule, approval workflow, and sign-in options.

<Info>
  Account Settings is admin-only. The defaults you set here apply across the whole organization, but most can be overridden lower down — on a tag, a person, or a project.
</Info>

## Open Account Settings

You reach Account Settings from the user menu, not from the sidebar's top-level features.

<Steps>
  <Step title="Open the user menu">
    Click the button with your initials at the bottom of the left sidebar.
  </Step>

  <Step title="Choose Account Settings">
    In the menu that opens, click **Account Settings**.
  </Step>
</Steps>

The other items in this menu — **Subscription**, **Person Roles**, **Work Schedules**, **Integrations**, **Master data review**, **Time Off**, **Expense Types**, **Custom Fields**, **Release Notes**, and **Delete Account** — open their own dedicated screens.

## Organization identity

The header at the top of Account Settings holds your organization's name, logo, and accent color. Each edit saves automatically.

### Name

Click the organization name in the header and type a new one. The change is saved automatically.

### Logo

Click the logo area in the header. You can **Paste, drop, or click to add the logo of your organization**. Beebole crops the logo to fit the header, and a crop tool lets you adjust the framing before it saves. The logo appears in the sidebar and in emails Beebole sends. To remove it, open the logo again and clear it.

### Accent color

Click the color swatch in the header and pick a color from the palette. The accent color updates immediately for everyone in the organization — it colors buttons, highlights, and other branded elements. To clear it, open the picker again and click the swatch that is currently selected.

<Info>
  Each person can also choose a personal interface color from the user menu (**Pick your color**), which overrides the organization accent color for them alone.
</Info>

## Settings panels

Below the header, Account Settings is organized into panels. Each panel sets a default for the organization, and every edit saves automatically. The panels available are:

| Panel                               | What it controls                                                                               |
| ----------------------------------- | ---------------------------------------------------------------------------------------------- |
| **Localization**                    | Time zone, currency, number formats, time and date formats, and first day of the week          |
| **Show or hide by default**         | Which optional elements are visible across the account by default                              |
| **Timesheet and Planning Settings** | How your team logs time — periodicity, duration format, entry rules, categories, and reminders |
| **Billing**                         | The default billing rate for the organization                                                  |
| **Cost**                            | The default cost rate for the organization                                                     |
| **Work schedule**                   | The expected working hours assigned at the organization level                                  |
| **Public holidays**                 | The default public holiday calendar                                                            |
| **Approval workflow**               | The default sequence of approval stages for submitted timesheets                               |
| **Single Sign-On**                  | Google, Microsoft, and custom SSO sign-in for your members                                     |
| **Notifications**                   | The default notification settings for the account                                              |
| **Email templates**                 | The wording of emails Beebole sends on the organization's behalf                               |

<Info>
  Billing rates, costs, custom fields, approval workflow, and Single Sign-On depend on your subscription and may not appear on every account.
</Info>

### Localization

The **Localization** panel sets the regional defaults for the whole organization:

* **Language** — The interface language. Beebole is available in English, Czech, German, Spanish, French, Hungarian, Italian, Dutch, Polish, and Portuguese.
* **Time zone** — The default time zone for date and time calculations.
* **Currency** — The currency used for billing rates, costs, budgets, and expenses.
* **First day of the week** — Whether the week starts on Monday, Sunday, or another day. This affects timesheets, calendars, and reports.
* **Date format** — How dates display throughout Beebole.
* **Time format** — A 12-hour or 24-hour clock.
* **Decimal format** — The decimal separator used in numbers.
* **Thousands separator** — The separator used to group large numbers.

A person can override their own language and some regional preferences from their profile.

### Show or hide by default

The **Show or hide by default** panel decides which optional elements are switched on across the account. You can show or hide **Show all projects**, **Show all secondary projects**, **Show all tasks**, **Show all time off**, **Show all expenses**, and **Show all custom fields**. If you disable one globally, you can still enable it for specific tags, people, or projects under their own **Show or hide** settings.

### Timesheet and Planning Settings

The **Timesheet and Planning Settings** panel controls the timesheet experience — default periodicity, duration format, time entry rules, the categories your team tracks against, and reminders. Because it is a deep configuration area, it has its own reference page.

<Info>
  For the full list of timesheet options, see [Timesheet and Planning Settings](/help/documentation/timesheetSettings).
</Info>

## Delete your account <Badge>Admin only</Badge>

You can schedule your Beebole organization for deletion from the **Delete Account** menu item. Beebole does not delete everything instantly — it gives you a grace period so you can change your mind.

<Warning>
  Scheduling deletion removes your entire organization — people, projects, time entries, reports, and configuration — after the grace period passes. Export any data you need first.
</Warning>

<Steps>
  <Step title="Open Delete Account">
    Open the user menu with your initials, then click **Delete Account**.
  </Step>

  <Step title="Schedule the deletion">
    Click **Yes, delete my account**. Beebole schedules the account for deletion and notifies all administrators by email.
  </Step>

  <Step title="Cancel if you change your mind">
    During the 7-day grace period, return to **Delete Account** and click **Cancel deletion** to keep your account. After the grace period, the data is permanently deleted.
  </Step>
</Steps>

## Related content

<CardGroup>
  <Card title="Timesheet and Planning Settings" icon="clock" href="/help/documentation/timesheetSettings">
    Configure how your team logs time — periodicity, duration format, rules, and reminders.
  </Card>

  <Card title="Roles & permissions" icon="user-shield" href="/help/documentation/roles-authorisations">
    Control who can view and change account settings.
  </Card>

  <Card title="Authentication" icon="key" href="/help/documentation/authentication">
    Set up Single Sign-On and sign-in options for your organization.
  </Card>

  <Card title="Subscription" icon="credit-card" href="/help/documentation/subscription">
    Manage your Beebole plan and billing details.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Who can change Account Settings in Beebole?">
    Only administrators can open and edit Account Settings. The defaults set there apply to the whole organization, so changes are restricted to people with the Admin role.
  </Accordion>

  <Accordion title="Do I need to click Save after changing a setting?">
    No. Beebole saves each Account Settings edit automatically as you make it — there is no separate Save button on the page.
  </Accordion>

  <Accordion title="Can a person override the organization's localization defaults?">
    Yes, in part. A person can set their own language and some regional preferences in their profile, while account-wide defaults like currency apply to everyone unless overridden lower down.
  </Accordion>

  <Accordion title="Can I undo deleting my Beebole account?">
    Yes, during the grace period. After you schedule deletion, Beebole waits 7 days before removing your data. Open **Delete Account** and click **Cancel deletion** within that window to keep your account.
  </Accordion>

  <Accordion title="Can I change the currency after I have started tracking costs?">
    Yes. You can change the currency in the **Localization** panel at any time. Beebole does not convert existing values, so review your financial data after switching.
  </Accordion>
</AccordionGroup>


# Time-off accruals: frequency and carry-forward
Source: https://beebole.com/help/documentation/accruals

Configure time-off accrual policies in Beebole: choose accrual frequency, set carry-forward limits, and control when allowances are awarded.

Beebole's accrual policies let you define how time off accumulates for your team on a recurring schedule. Instead of granting the full annual allowance on day one, you can configure policies where leave builds up gradually — monthly, weekly, or at whatever frequency matches your company's rules. Accrued time is reflected on each person's allowance through its editable **Accrued** field.

<Info>
  Accrual policies are linked to absence types. Each absence type can have its own accrual policy with independent settings for frequency, quantity, and award timing.
</Info>

***

## How accruals work

An accrual policy defines three things:

1. **How much** time off is awarded per period (the **Quantity**).
2. **How often** the accrual is awarded (the **Frequency**).
3. **When** within each period the accrual is credited to the person's balance (the **Awarded on** setting).

The policy defines how much time a person earns as each accrual period completes. Earned time is reflected on the person's allowance through its **Accrued** field — an editable adjustment to the accrued balance that appears on their profile and in time-off reports.

***

## Creating an accrual policy

<Steps>
  <Step title="Open the absence type">
    Go to **Settings** > **Time Off** and click the absence type you want to configure accruals for.
  </Step>

  <Step title="Enable accruals">
    In the **Accruals** panel, turn on the toggle to reveal the accrual settings.
  </Step>

  <Step title="Set the accrual amount">
    Enter the number of hours or days to award per accrual period. This amount is added to each person's balance at the configured frequency.
  </Step>

  <Step title="Choose the frequency">
    Select how often the accrual is awarded. Common options include monthly, quarterly, semi-annually, or annually.
  </Step>

  <Step title="Set the award timing">
    Choose when the accrual is credited within each period:

    * **First day of the period** — The balance is credited at the start.
    * **Last day of the period** — The balance is credited at the end.
    * **Day after the period** — The balance is credited on the first day of the next period.
  </Step>

  <Step title="Set the quantity">
    Enter the number of hours or days to award per accrual period in **Quantity**. Every change is saved automatically — the accrual policy is now defined for this absence type.
  </Step>
</Steps>

<Tip>
  Choose **first day of the period** if you want people to use their accrued time immediately. Choose **last day of the period** or **day after the period** if you want them to earn the time before they can use it.
</Tip>

***

## Carry-forward rules

Carry-forward controls what happens to unused time off when an allowance period ends. It is configured on the allowance, not on the accrual policy: each allowance has a **Carry forward limit** field — the maximum number of hours or days that can roll over to the next period. The default is 0, so unused time off expires at the end of the period ("use it or lose it"). Any unused balance above the limit is forfeited.

<Steps>
  <Step title="Open the absence type">
    Go to **Settings** > **Time Off** and click the relevant absence type.
  </Step>

  <Step title="Open the allowance">
    Open the **Absence allowances** panel — on **Settings** > **Account Settings** for the organization default, or on a person or tag — and click the relevant allowance.
  </Step>

  <Step title="Configure carry-forward">
    In the accrual settings, enable carry-forward and set the maximum amount that can roll over (or leave it unlimited for full carry-forward).
  </Step>

  <Step title="Set the limit">
    Enter the maximum amount that can roll over in **Carry forward limit**. The change is saved automatically and applies at the end of the allowance period.
  </Step>
</Steps>

<Warning>
  Changing the **Carry forward limit** mid-period may affect balances that have already rolled over. Review individual balances after making changes to ensure they reflect your intent.
</Warning>

***

## Frequency settings

The accrual frequency determines the cadence at which time off accrues. Choose a frequency that aligns with your organization's leave policy:

| Frequency        | Accrual occurs  | Best for                                                   |
| ---------------- | --------------- | ---------------------------------------------------------- |
| **Daily**        | Once per day    | Leave that builds up with every calendar day               |
| **Weekly**       | Once per week   | Hourly or shift-based teams that accrue with each pay week |
| **Bi-weekly**    | Every two weeks | Organizations on a bi-weekly payroll cycle                 |
| **Semi-monthly** | Twice per month | Organizations that pay on the 15th and end of month        |
| **Monthly**      | Once per month  | Most common; gradual accumulation throughout the year      |

<Info>
  The total annual accrual should match the person's overall allowance for the year. For example, if someone gets 20 days per year with monthly accruals, set the accrual amount to approximately 1.67 days per month.
</Info>

***

## Award timing explained

The **Awarded on** setting controls the exact moment within each accrual period when the time is credited:

* **first day of the period** — Time is available immediately when the period starts. For monthly accruals, this means the 1st of each month.
* **last day of the period** — Time is credited on the final day of the period. The person earns the time at the end of the accrual window.
* **day after the period** — Time is credited on the first day of the following period. This ensures the person has fully completed the period before receiving their accrual.

<Info>
  Award timing affects when a person can use accrued time off. If you choose **day after the period**, January's accrual becomes available on February 1st — not during January.
</Info>

***

## Viewing accrued balances

You can check any person's accrued balance from their profile:

<Steps>
  <Step title="Open the person's profile">
    Go to **People** and click the person's name.
  </Step>

  <Step title="Review the balance">
    The **Absence allowances** panel shows each allowance with its **Available** and **Accrued** amounts. Open an allowance to also see **Consumed** — the time off recorded over the period.
  </Step>
</Steps>

Balances update as time-off entries are recorded on timesheets and when the allowance's **Accrued** field is adjusted.

***

## Related content

<CardGroup>
  <Card title="Time Off" icon="calendar" href="/help/documentation/timeoff">
    Configure absence types and allowances that accrual policies are linked to.
  </Card>

  <Card title="Public Holidays" icon="clock" href="/help/documentation/public-holidays">
    Define non-working days that affect capacity and time-off calculations.
  </Card>

  <Card title="Work Schedule" icon="users" href="/help/documentation/work-schedule">
    Set working hours used to calculate day-based accrual amounts.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I set different accrual rates for different people?">
    Accrual policies are configured at the absence type level and apply to everyone with an allowance for that type. To give someone a different accrual rate, create a separate absence type with its own accrual policy.
  </Accordion>

  <Accordion title="What happens if I change the accrual frequency mid-year?">
    The updated policy applies from the next accrual period onward. Amounts already reflected in the **Accrued** field are not recalculated. Review individual balances to ensure they are correct after the change.
  </Accordion>

  <Accordion title="Can I use accruals with carry-forward at the same time?">
    Yes. Accruals and carry-forward work together. The accrual policy defines how time accumulates throughout the period, and the allowance's **Carry forward limit** determines how much unused time rolls over when the period ends.
  </Accordion>

  <Accordion title="Do accruals apply to all absence types?">
    No. Accrual policies are optional and configured per absence type. You can have some types with accruals (e.g., vacation) and others without (e.g., sick leave with an unlimited or fixed annual grant).
  </Accordion>

  <Accordion title="How do I stop accruals for someone who has left the company?">
    End the person's allowance: open the **Absence allowances** panel on their profile and set the allowance's **Start - end** period to finish on their last day. You can also archive their profile to free the seat — see [People](/help/documentation/people).
  </Accordion>
</AccordionGroup>


# Beebole AI: suggestions, reports, and review assistance
Source: https://beebole.com/help/documentation/ai

Beebole AI drafts time entries from your activity, builds reports from plain language, and flags unusual timesheets before you approve them.

Beebole AI is the set of AI features built into your Beebole account: time entries suggested from your own activity, reports built from a plain-language question, and an extra pair of eyes when you review a submitted timesheet. Everything lives on the **Assistant** page — click **Assistant** in the sidebar when AI features are enabled for your account.

<Info>
  Beebole AI runs on Beebole's own AI models, self-hosted on Beebole-operated servers in the same region as your data. Nothing is sent to a third-party AI provider.
</Info>

***

## Suggested time entries

Beebole drafts time entries for you and shows them in the **Suggested entries** pane next to your timesheet — open it with the ✨ button in the timesheet's top-right corner. Each suggestion carries a badge naming its source:

| Badge       | Source                                                         | How it works                                                                                                                                                                       |
| ----------- | -------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Habit**   | Your logging patterns                                          | After a few weeks of regular use, entries are mined from your own recurring logging habits.                                                                                        |
| **Desktop** | The [desktop app](/help/documentation/desktop-app)             | Time spent in applications and websites on your computer becomes draft entries.                                                                                                    |
| **Web**     | The [browser extension](/help/documentation/browser-extension) | Time on websites you choose to watch becomes draft entries.                                                                                                                        |
| **Planned** | Your planned work                                              | Work planned for you — dates and share of your time set in [Planning](/help/documentation/planning) — becomes suggestions on the scheduled days.                                   |
| **Kanban**  | The Kanban board                                               | Moving a card to its done column proposes the matching entry — when [Auto Timesheet from Planning](/help/documentation/timesheetSettings#auto-timesheet-from-planning) is enabled. |

The sources work together instead of competing. When two sources describe the same work, the suggestions merge into a single card showing every contributing badge, ranked so measured activity wins over assumptions. What you already logged by hand is subtracted, suggestions shrink to fit the room a day still has, and they never land on locked days, public holidays, full-day absences, or already-submitted periods. Planned suggestions rebuild each time you open the timesheet, and habit suggestions refresh daily, so the pane always reflects your current plans.

Each card shows the project or task it is about, with that entity's picture and color rather than a generic icon, so you can tell at a glance what is being proposed.

Suggestions are private — only you see them until you accept. For each one you can:

* **Accept** it (or **Accept all**) — the entry lands on your timesheet.
* **Dismiss** it. If a dismissed suggestion was hiding an overlapping one, the runner-up reappears.
* Start it — the play button on today's suggestions accepts the suggestion and keeps a [timer](/help/documentation/timesheets#using-the-timer) running on it, in one gesture. It is available in the pane, on the calendar ghosts, and in the suggestion popup.
* Click **Why?** to see the evidence: the applications and sites behind a **Desktop** or **Web** suggestion, the planned dates and share of your time behind a **Planned** one, or how many recent weeks a **Habit** was seen. Activity details are only readable where they were captured — elsewhere, Beebole tells you the details are only available in the desktop app or browser that tracked the activity.

Accepting, editing, and dismissing are all undoable with **⌘+Z** (Ctrl+Z on Windows and Linux). Undoing an accept also removes the entries it created — or shrinks the entry it grew.

In the timesheet's [calendar view](/help/documentation/timesheets#calendar-view), suggestions also appear as ghost entries: drag a suggestion to a time slot to schedule it, or accept it as-is. Drop one of your [favorites](/help/documentation/timesheets#favorites) onto a ghost and the suggestion is retargeted to that project or task and accepted in a single move — the ghost highlights as you hover it.

### Suggestions for a task you cannot book

A suggestion can name a planned task your timesheet does not accept time on — a task in a planning left out of **Record time on these plannings** in [Timesheet and Planning Settings](/help/documentation/timesheetSettings). Beebole keeps the suggestion instead of dropping it, and leaves the task on the card so you still see what the proposal is about.

To accept one, pick where the time should land: the card shows **Log this time as** with the note **Choose a project to accept it.**, and the entry is created on the project chain you choose. The link to the planned task is kept behind the entry, so the time still counts toward that task — in the [Planned vs. Real](/help/documentation/reports#planned-vs-real) report and in the approval check that flags a task over its planned time. **Accept all** skips these suggestions — each one needs your choice — and leaves them in the list for you to handle one by one.

### Planned work on future days

**Planned** suggestions also reach beyond today. On days still in the future they appear as read-only forecast cards — a muted, dashed preview of what you are planned to work on — so you can see the shape of your week ahead. A forecast card becomes fully actionable, with accept, edit, and dismiss, once its day arrives.

Reopening a past week that is still open — draft or rejected — regenerates its planned suggestions, so staffing added after the fact still shows up when you go back to that week.

<Info>
  Activity captured by the desktop app stays on that device, is never shared with anyone, and is deleted after a week. Only the entries you accept reach your timesheet.
</Info>

Accepted entries record which source they came from and go through the normal entry path — the lock date, entry restrictions, and approvals all apply. If your organization enables [auto-submit](/help/documentation/timesheetSettings#auto-submit), suggestions still pending at the deadline are converted into real entries and submitted through the normal approval flow.

***

## Report builder

Describe the report you need in plain language and Beebole creates and runs it for you.

* On the **Assistant** page, use **Ask for a report** — the report opens ready to run.
* On the **Reports** page, type what you want to know in the report builder.

The result is a regular saved report, created in a folder named **AI**: refine its filters, move it to another folder, or delete it like any other. See [Reports](/help/documentation/reports). The report builder appears only for roles allowed to manage reports.

### It speaks your organization's vocabulary

You do not have to describe your account's structure — the builder already knows it. It reads the names you gave your project and task categories and each of their levels, along with your custom fields, so a request like "hours by client last month" or "hours per cost center" groups the rows on that level of your hierarchy, or on the values of that custom field. Ask for "people and their Seniority year to date" and each axis becomes a column, in the order you named them. Names you mention are matched against the projects, people, tasks, and tags you are allowed to see; when one cannot be matched, Beebole tells you what it could not find instead of running the wrong report.

With a report already open, the input sits under its title and your request changes that report: add a billing column, group by month, or turn the chart into a pie, and everything you did not mention stays as it is. Ask for a new or separate report and Beebole creates one instead. The button reads **Build** for a new report and **Update** when you are changing one.

### When Beebole asks instead of guessing

Some requests cannot be expressed with the options a report has. Rather than return a plausible-looking wrong answer, Beebole replies with one short question. The most common case is grouping by a tag category: tags filter a report but are not a grouping axis, so "hours by department" comes back as a question about how you want the rows grouped.

### What reaches the model

Only definitions are sent: your question, the structure of the report you have open, and the names of your categories, their levels, and your custom fields. Your time entries, the amounts in them, and the names of your projects, people, and tasks are not part of the request. The model only writes the report definition — every figure is computed by Beebole's own reporting engine, with your permissions applied, exactly as for a report you build by hand.

***

## Approval review

When you review a submitted timesheet, anything unusual is flagged before you decide. The review digest checks the period for:

* **Time on a non-working day**
* **More time than scheduled**
* **Time outside working hours**
* **Time on an archived project** / **Time on an archived task**
* **Entry right after the lock date**
* **Task over its planned time**
* **Period total far from usual**

Approvers are emailed when a timesheet needs their review, with a summary of the submitted time and one-click **Approve** and **Reject** links. See [Approval workflows](/help/documentation/approval).

***

## Already working for you

Some AI touches need no setup at all: timesheet reminders mention how many suggested entries are waiting, and how many hours they add up to — and when auto-submit is on, they announce the deadline in advance, so you know how long you have to review them.

***

## Connect your own AI tools

Beebole also works with the AI assistant you already use. Connect Claude, ChatGPT, or another assistant to your Beebole data — with exactly your permissions — and manage every connection from the **Connected apps** list. See [the Beebole MCP server](/help/integrations/mcp-server) for setup.

***

## Related content

<CardGroup>
  <Card title="MCP server" icon="plug" href="/help/integrations/mcp-server">
    Connect Claude, ChatGPT, and other assistants to your Beebole data.
  </Card>

  <Card title="Desktop app" icon="desktop" href="/help/documentation/desktop-app">
    Draft time entries automatically from what you work on.
  </Card>

  <Card title="Browser extension" icon="puzzle-piece" href="/help/documentation/browser-extension">
    Turn time on the sites you choose into draft entries.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Where suggested entries appear and get accepted.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Does using Beebole AI send my data to OpenAI, Anthropic, or another AI provider?">
    No. Beebole runs its own AI models, self-hosted on Beebole-operated servers in the same region as your data, and nothing is sent to a third-party AI provider.

    What the model sees is also deliberately small. For the report builder it is only definitions — your question, the structure of the report you have open, and the names of your categories and custom fields — never your time entries, their amounts, or your project, person, and task names.

    Connecting your own assistant through Beebole's MCP server works the other way around. That assistant reads your Beebole data with your permissions, and only when you set the connection up yourself.
  </Accordion>

  <Accordion title="Who can see my suggested time entries?">
    Only you. Suggested entries in Beebole are private to you until you accept them — teammates, managers, and admins never see your suggestions or the activity behind them.
  </Accordion>

  <Accordion title="Where do time entry suggestions come from?">
    From five sources: your own recurring logging patterns, the Beebole desktop app and browser extension if you install them, work planned for you in Planning, and Kanban cards you move to a done column. Each suggestion shows its source badge and a **Why?** explanation, overlapping suggestions merge into one card, and you decide what to accept or dismiss.
  </Accordion>

  <Accordion title="How do I write a report with AI in Beebole?">
    Describe what you want to know — on the **Assistant** page under **Ask for a report**, or directly on the **Reports** page. Beebole builds the report and runs it; the result is a normal saved report in a folder named **AI** that you can refine and reuse. Use the words your organization uses: the builder knows your category names and levels and your custom fields, so "by client" or "per cost center" groups on that level or field. With a report open, the same input changes that report instead of creating a new one.

    If a request cannot be expressed with the options a report has, Beebole replies with one short question rather than guessing — grouping rows by a tag category is the usual case, since tags filter a report but are not a grouping axis. Answer in the same input and the report is built.
  </Accordion>

  <Accordion title="What does the approval review digest check?">
    It flags time on non-working days, overtime beyond the schedule, time outside working hours, entries on archived projects or tasks, entries right after the lock date, tasks over their planned time, and period totals far from that person's usual — all before you approve or reject.
  </Accordion>
</AccordionGroup>


# Timesheet and time off approval workflows
Source: https://beebole.com/help/documentation/approval

Set up multi-stage timesheet approval in Beebole: configure approval stages and quorum, approve or reject submissions, and follow up with reminders.

Beebole's approval workflow lets you review and lock your team's timesheets — work time and time off alike — before they feed reports, billing, and payroll. Approvers check each submitted period and either **Approve** it or **Reject** it with a comment, stage by stage, following the workflow you configure.

<Info>
  Approval workflows are part of Beebole's paid plans. If no workflow is configured, timesheets are approved automatically the moment they are submitted.
</Info>

***

## How approval works

1. A person completes their [timesheet](/help/documentation/timesheets) and clicks **Submit** at the top of the page. The timesheet locks and enters the first approval stage.
2. The stage's approvers are notified. Depending on the stage's quorum, either any one of them or all of them must approve.
3. Once the stage is complete, the timesheet advances to the next stage. When the last stage approves, the timesheet is **Approved**.
4. If any approver rejects — a comment is always required — the timesheet becomes **Rejected** and returns to its owner, who can correct it and click **Resubmit**.

The timesheet's status badge shows where a period stands:

| Status        | Meaning                                                              |
| ------------- | -------------------------------------------------------------------- |
| **Draft**     | Time entries can still be edited. The period has not been submitted. |
| **Submitted** | The timesheet is locked and waiting in the approval workflow.        |
| **Approved**  | Every stage has approved. The timesheet stays locked.                |
| **Rejected**  | An approver rejected the timesheet. The owner can edit and resubmit. |

Click the status badge to open the stage breakdown: each stage shows its approver type, who has already approved and when, and who is still pending on the current stage. A stage with no eligible approver — for example, **People managers** when the person has no manager — shows **No manager found** and is skipped.

***

## Configuring the approval workflow

The workflow is a list of sequential stages. It lives in the **Approval workflow** panel, which exists at three levels: your organization's **Account Settings**, every tag, and every person's profile. Like other cascading settings, the most specific level wins — a workflow set on a person overrides one set on their tags, which overrides the account default. An icon next to the panel shows where the current workflow is inherited from.

<Steps>
  <Step title="Open the Settings menu">
    Click the button with your initials at the bottom of the left sidebar.
  </Step>

  <Step title="Go to Account Settings">
    Click **Account Settings** to open your organization's settings. To define a workflow for one team or one person instead, open the same panel on a tag or on a person's profile.
  </Step>

  <Step title="Open the Approval workflow panel">
    If no workflow exists yet, the panel explains that timesheets are automatically approved when submitted.
  </Step>

  <Step title="Add a stage">
    Click **Add**. A new stage appears with **Project managers** as its type and **Any** as its quorum.
  </Step>

  <Step title="Choose the stage's type and quorum">
    Pick who approves at this stage (see the table below) and whether **All** approvers or **Any** single approver completes it. For **Specific people**, pick each approver with **Select person**; for **Tagged people**, pick one or more tags with **Select tag**.
  </Step>

  <Step title="Add and order more stages (optional)">
    Repeat **Add** for each additional stage. Stages run in the order listed — use **Move up** and **Move down** to reorder them, or **Remove stage** to delete one.
  </Step>
</Steps>

Every change in the panel is saved automatically — there is no save button.

### Approver types

| Type                 | Who approves                                                                                                               |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| **Admins**           | People with admin access.                                                                                                  |
| **Project managers** | The managers of the projects in the timesheet. A manager of a parent project also approves time logged on its subprojects. |
| **People managers**  | The managers of the person who submitted the timesheet.                                                                    |
| **Task managers**    | The managers of the tasks in the timesheet.                                                                                |
| **Tagged people**    | All people tagged with the selected tag.                                                                                   |
| **Specific people**  | The named people you select.                                                                                               |

<Info>
  Beebole resolves approvers when the timesheet is submitted, based on its content. If a period contains entries on three projects, a **Project managers** stage includes the managers of all three.
</Info>

***

## Reviewing and approving your team's timesheets

Approvers can act from three places: the **Timesheet** page, the **Journal**, or directly from email.

### From the Timesheet page

Managers and administrators see an approval button (**Approval**) in the cluster at the top-left corner of the timesheet grid, with a red badge counting submissions waiting for them. It opens the **Pending** pane:

* The pane lists each timesheet waiting for your approval, with **Late** submissions grouped at the top. Turn on **Show all** to include every pending submission you are allowed to see, not just those waiting for you.
* Click a person to open their timesheet for the submitted period. **Approve** and **Reject** buttons appear at the top of the timesheet whenever you are a pending approver — or an administrator.
* Select several submissions with the checkboxes to act in bulk with **Approve** and **Reject**.

The neighboring team button (**Team**) opens the **Team** pane, which lists your team members with their status for the period. People who haven't submitted yet have a **Remind** button (**Send reminder**) that emails them on the spot.

Select people with the checkboxes — or **Select all** — and a bulk bar appears with **Approve**, **Remind**, and **Reject**, each followed by the number of people it applies to. Every button acts only on the people it can act on, so a mixed selection is safe:

* **Approve** and **Reject** act on the selected timesheets submitted for the period on screen and waiting for you — as an administrator, on any submitted one.
* **Remind** goes to the selected people who haven't submitted — their period is a draft, rejected, or empty. People whose timesheet is approved, or submitted and waiting for someone else, are never reminded. Once the reminders are sent, those people are deselected and the submitted ones stay selected for approval.

The bar acts strictly on the period displayed: a person's submission from another period is never approved or rejected from here.

<Tip>
  In the **Team** pane, hold **⌘** while clicking the select-all checkbox to alternate between selecting everyone to remind and everyone to approve.
</Tip>

### From the Journal

Click **Journal** in the left sidebar. Approvers see a banner at the top of the feed — **1 timesheet to approve**, or the total count — or **All caught up** when nothing is waiting. Expand the banner to review without leaving the page:

* Each pending submission shows its total **Hours** and **Billing** amount — plus **Cost**, if your role can see costs.
* Click a person's name to split their total by project, task, and absence type, or click **View records** for the day-by-day entries with their comments.
* Approve or reject one row, or select several and act in bulk.

<Info>
  Totals reflect timesheet entries you can see. Approve and reject act on the whole timesheet.
</Info>

### From your email

Approval notification emails include a summary of the submitted timesheet and **Approve** and **Reject** links that work straight from your inbox, without signing in. **Approve** applies the approval and opens the timesheet it acted on; **Reject** opens the same timesheet with the rejection dialog ready, since a reason is always required. Timesheet reminder emails likewise include a **Submit now** link when the period already holds entries, so your team can submit a completed period directly from the reminder.

You can also decide by replying to the email — the approval email and the approval reminder both end with a note about it:

* Reply with **approve** alone on the first line to approve.
* Reply with **reject** followed by your reason — on the same line or the lines below — to reject. A **reject** with no reason changes nothing.

Beebole reads the first word of your reply and also understands **accept**, **ok**, **yes**, **refuse**, and **decline**, in any of its languages. Before applying the decision, Beebole checks that the reply comes from the approver's own email address and that the sending mail server authenticated it. Whatever the outcome, a receipt lands in the same email thread: **Approved**, **Rejected**, or **Nothing changed** — the latter when the reason was missing, the sender couldn't be verified, or the timesheet is no longer pending your approval. A reply that doesn't start with a decision word is treated as a Journal message instead.

***

## Rejecting a timesheet

Rejecting always requires an explanation. When you click **Reject**, a dialog opens with a comment box (**Enter a reason for rejection…**) — the **Reject** button stays disabled until you write one. The reason is delivered to the person and recorded in their Journal.

A rejected timesheet unlocks for its owner. After correcting the entries, they click **Resubmit** and the workflow starts again from the first stage. Beebole records which entries were added, modified, or deleted since the previous submission, and uses that to spare approvers unnecessary work: a project or task manager who had already approved is only asked again if entries on their own projects or tasks changed.

***

## Time off approval

Time off goes through the same workflow as work time. When someone records an absence on their timesheet and submits the period, the configured approval stages review it along with the rest of the timesheet. The absence counts against the person's allowance as soon as it is recorded — approval reviews and locks the entry but does not gate the balance. See [Time off](/help/documentation/timeoff) for absence types and allowances.

***

## Editing a submitted or approved timesheet

Submitting locks a timesheet for its owner, but it doesn't have to be rejected to be corrected:

| Status        | Owner    | Current-stage approver                                | Administrator |
| ------------- | -------- | ----------------------------------------------------- | ------------- |
| **Draft**     | Can edit | —                                                     | Can edit      |
| **Submitted** | Locked   | Can edit — the workflow restarts from the first stage | Can edit      |
| **Approved**  | Locked   | —                                                     | Can edit      |
| **Rejected**  | Can edit | The rejecting approver can correct entries in place   | Can edit      |

To edit on someone's behalf, open the **Pending** or **Team** pane and click the edit button (**Edit timesheet**) on the person's row. Their grid unlocks for you; the override switches off when you move to another person. Administrator edits never restart the workflow.

While you are editing, the timesheet makes it impossible to forget whose entries you are touching: the grid or calendar and every row picker are washed in the same highlight tint, the edit button on the person's row fills with that color (**Stop editing this timesheet**), and an **Editing** badge appears next to the person's name at the top of the page. Click the badge or the edit button again to stop editing. The override is tied to that one person — opening another person's timesheet drops the tint and the badge along with it.

The edit button is not limited to administrators — managers and approvers see it too, on the rows they are allowed to correct. Beebole decides row by row, following the table above: a timesheet that is already **Approved** stays locked for everyone but an administrator, a **Submitted** one opens only for an approver of the current stage, and the two restrictions below can take the button away entirely.

<Info>
  Two settings in [Timesheet and Planning Settings](/help/documentation/timesheetSettings) narrow this further. **Only the owner or an admin can edit entries** removes the approver column above, so only the owner and administrators can change entries. **Only an admin can edit someone else's timesheet** leaves the owner's own editing untouched but reserves every edit on another person's timesheet for administrators.
</Info>

### Force approve and reject <Badge>Admin only</Badge>

Administrators can unblock the pipeline without reconfiguring it: they can **Approve** or **Reject** any submitted timesheet, even when they are not approvers for the current stage. An already-approved timesheet can also be rejected — by an administrator, or by someone who was an approver on its last stage — which sends it back to its owner.

***

## Reminders and notifications

* **Remind approvers after** a number of **days if not yet approved** — found in the **Reminders** tab of the **Timesheet and Planning Settings** panel — automatically follows up on submissions still waiting for review. Set it account-wide in **Account Settings**, or override it on a tag or a person, just like the approval workflow itself.
* The **Remind** button in the **Team** pane sends a one-off reminder to anyone who hasn't submitted.
* Each person controls how they receive **Approval updates** — instantly or as a digest — in their notification settings. See [Notifications](/help/documentation/notifications).

***

## Approval history

Every approval action is logged in the person's [Journal](/help/documentation/journal) feed: **Submitted for approval**, **Approved by** and **Rejected by** entries with the approver's name and the rejection reason, plus **Auto-submitted** and **Auto-approved** events, each tagged with its stage. For who approved what on the current submission, click the timesheet's status badge to open the stage breakdown.

***

## Related content

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Track time, submit your period, and review your team from the timesheet grid.
  </Card>

  <Card title="Timesheet and Planning Settings" icon="sliders" href="/help/documentation/timesheetSettings">
    Configure the timesheet period, auto-submit, entry restrictions, and reminders.
  </Card>

  <Card title="Time off" icon="umbrella-beach" href="/help/documentation/timeoff">
    Set up absence types and allowances, and record time off on the timesheet.
  </Card>

  <Card title="Journal" icon="comments" href="/help/documentation/journal">
    Follow your team's activity feed, messages, and approval events.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Who approves my timesheet in Beebole?">
    It depends on the approval workflow your administrator configured. Each stage names an approver type — admins, project managers, people managers, task managers, tagged people, or specific people — and Beebole resolves the actual approvers from your timesheet's content when you submit. Click the status badge on your timesheet to see each stage and who is pending.
  </Accordion>

  <Accordion title="What happens when my timesheet is rejected?">
    The approver must enter a reason, which Beebole sends to you and records in your Journal. Your timesheet unlocks so you can correct the entries, then click **Resubmit**. The workflow runs again from the first stage, but approvers unaffected by your changes are not asked to re-approve.
  </Accordion>

  <Accordion title="Can different teams have different approval workflows in Beebole?">
    Yes. The **Approval workflow** panel exists on the organization's **Account Settings**, on every tag, and on every person's profile. A workflow defined on a tag applies to everyone under that tag, and a workflow on a person overrides everything else — so each team can follow its own sign-off process.
  </Accordion>

  <Accordion title="What happens if no approval workflow is configured?">
    Beebole approves timesheets automatically the moment they are submitted. Add at least one approval stage in the **Approval workflow** panel to require a review before timesheets are locked.
  </Accordion>

  <Accordion title="Does time off go through the same approval as work time?">
    Yes. Absences recorded on the timesheet are submitted and approved together with the rest of the period, through the same approval stages. The time off counts against the person's allowance as soon as it is recorded, even before it is approved.
  </Accordion>
</AccordionGroup>


# Assignments: control who has access to what
Source: https://beebole.com/help/documentation/assignments

Control which projects, time off types, and expense types each person can use in Beebole — set account-wide defaults and who has access to each item.

Assignments in Beebole control which items each person can use: the projects they can log time against, the time off types and expense types they can pick, and the custom fields they see. Use them to keep timesheets short and relevant — each person only sees what applies to them.

<Info>
  Assignments control which items are **available** to a person. What a person can **do** — view or edit data — is controlled by their role, covered in [Roles & Permissions](/help/documentation/roles-authorisations).
</Info>

## How access control works

Beebole resolves access from three places:

| Layer                 | Where it lives                                                                 | What it does                                                               |
| --------------------- | ------------------------------------------------------------------------------ | -------------------------------------------------------------------------- |
| Account-wide defaults | **Show or hide by default** in **Account Settings**                            | Decides whether each kind of item is available to everyone by default      |
| Item-side access      | **Who has access?** on a project, time off type, expense type, or custom field | Adds people and tags to a hidden item, or excludes them from a visible one |
| Person-side access    | **Show or hide** on a person, tag, or project                                  | The same relationships, edited from the other direction                    |

The item-side and person-side panels edit the same underlying links — pick whichever direction is more convenient. All of these settings are saved automatically.

## Set the account-wide defaults

<Steps>
  <Step title="Open Account Settings">
    Click the button with your initials at the bottom of the sidebar to open **Settings**, then click **Account Settings**.
  </Step>

  <Step title="Open Show or hide by default">
    Open the **Show or hide by default** panel.
  </Step>

  <Step title="Choose the defaults">
    Check or uncheck each option. Changes are saved automatically.
  </Step>
</Steps>

| Option                          | What it controls                                                |
| ------------------------------- | --------------------------------------------------------------- |
| **Show all projects**           | Whether every project is available to everyone by default       |
| **Show all secondary projects** | Whether secondary projects are available by default             |
| **Show all time off**           | Whether every time off type is available to everyone by default |
| **Show all schedules**          | Whether every work schedule is available to everyone by default |
| **Show all expenses**           | Whether every expense type is available to everyone by default  |
| **Show all tasks**              | Whether every task is available to everyone by default          |
| **Show all custom fields**      | Whether every custom field is available to everyone by default  |

When an option is disabled here, items of that kind are hidden from everyone until you grant access individually — per item under **Who has access?**, or per person or tag under **Show or hide**.

For secondary projects, the account default can also be overridden per entity: on a specific project, person, or tag, choose **All secondary projects available** or **No secondary projects available** instead of following the default, or show and hide individual secondary projects one by one.

<Tip>
  Hold **⌘** and click any checkbox in the **Show or hide by default** panel to apply the same change to all options at once.
</Tip>

## Grant access per item with Who has access?

Each project, time off type, expense type, and custom field has a **Who has access?** panel. Here is where to find it:

| Item          | Where to find it                                                                       |
| ------------- | -------------------------------------------------------------------------------------- |
| Project       | Click **Projects** in the sidebar, select the project, and open **Who has access?**    |
| Time off type | Go to **Settings** > **Time Off**, select the type, and open **Who has access?**       |
| Expense type  | Go to **Settings** > **Expense Types**, select the type, and open **Who has access?**  |
| Custom field  | Go to **Settings** > **Custom Fields**, select the field, and open **Who has access?** |
| Work schedule | Go to **Settings** > **Work Schedules**, select the schedule, and open **Assigned to** |
| Task          | Click **Planning** in the sidebar, select the task, and open **Potential owners**      |

The panel lists who is linked to the item:

* **Individually** — add specific people with the **Select person** selector.
* **By tags** — add whole groups with the **Select tag** selector. Everyone tagged with that tag, or any of its descendants, gets access.

The panel adapts to the account-wide default. When the default already makes the item available to everyone, the sections flip into exclusion lists — **Excluded individually** and **Excluded by tags** — so you list the people who should *not* have it.

On a project, the panel also starts with a toggle that overrides the account default for that one project: **Available to everyone** or **Unavailable to everyone**. Expense types have an extra **Projects** section to limit an expense type to specific projects, and custom fields have **Projects** and **Tasks** sections for the same purpose.

<Info>
  Time off types, expense types, and custom fields don't carry their own default toggle — their default comes from the **Show or hide by default** options above. Projects are the exception, with the per-project toggle.
</Info>

## Edit access from the person or tag side with Show or hide

The same links can be managed from the people side. Click **People** (or **Tags**) in the sidebar, select a person or tag, and open the **Show or hide** panel. For a person or tag it covers time off, expenses, work schedules, tasks, projects, secondary projects, and custom fields. A project's **Show or hide** panel covers secondary projects, expenses, and custom fields.

Each section follows the account default, just like the item-side panel: **Show projects** lists the projects added for this person, while **Hide projects** lists exclusions when all projects are visible by default. The same pattern applies to **Show time off** / **Hide time off**, **Show expenses** / **Hide expenses**, **Show schedules** / **Hide schedules**, **Show tasks** / **Hide tasks**, and custom fields.

Use this direction when onboarding one person onto several projects at once; use **Who has access?** when staffing one project with several people.

## Task assignment

Tasks are independent planning items, separate from projects, and carry their own assignment attributes:

* **Owner** — the single person responsible for the task, with their planned full-time percentage.
* **Potential owners** — the people and tags the task is available to, managed like any **Who has access?** list with **Individually** and **By tags** sections.

To set either one, click **Planning** in the sidebar, select the task, and open the **Owner** or **Potential owners** panel. See [Task Planning](/help/documentation/planning) for how owners and dates drive the Gantt and Kanban views.

## Which plannings a person can book

Alongside the item-by-item assignments above, one setting decides which whole plannings a person may record time on: **Record time on these plannings**, in the **Categories** tab of the **Timesheet and Planning Settings** panel. Add a planning to the list with **Pick a planning**. See [Timesheet and planning settings](/help/documentation/timesheetSettings#plannings) for the setting itself.

The list cascades like every other timesheet setting. The value on **Account Settings** applies to everyone, a value on a tag overrides it for everyone under that tag, and a value on a person overrides both for that one person — so you can let one team book time on a planning that stays out of everyone else's timesheet.

Beebole enforces the list when an entry is saved, not only in the timesheet's pickers. Creating an entry on a task, or moving an existing entry to another task, checks the task's planning against the list of the person the entry belongs to — not the person doing the typing. An entry that breaks the rule is refused with *Your timesheet settings do not allow recording time on this task.*

<Info>
  Because the check follows the timesheet's owner, a manager or admin recording time for someone else is held to that person's own list. Entries saved before you changed the list stay as they are and remain editable in every other way.
</Info>

## Example: a client project for a five-person team

Suppose the **Website Redesign** project for **Acme Corp** should only appear on five people's timesheets:

1. Click **Projects** in the sidebar and select the project.
2. Open **Who has access?** and switch the toggle to **Unavailable to everyone**.
3. Under **Individually**, add the five people — or tag them and add the tag under **By tags**.

Only those five now see the project when they log time. Everyone else's project list stays uncluttered.

## Related content

<CardGroup>
  <Card title="Roles & Permissions" icon="shield" href="/help/documentation/roles-authorisations">
    Define what each role can view and edit across Beebole.
  </Card>

  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Create and organize the projects your team tracks time against.
  </Card>

  <Card title="Tags" icon="tag" href="/help/documentation/tags">
    Group people with tags to grant access to whole teams at once.
  </Card>

  <Card title="Time Off" icon="calendar" href="/help/documentation/timeoff">
    Configure time off types, allowances, and balances.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between assignments and role permissions?">
    Assignments decide which items are available to a person in Beebole — which projects, time off types, and expense types they can pick. Role permissions decide what they can do with data — view it or edit it, and for whom. Both apply at the same time.
  </Accordion>

  <Accordion title="How do I make a project visible to only a few people?">
    Open the project's **Who has access?** panel, set the toggle to **Unavailable to everyone**, then add the right people under **Individually** or a tag under **By tags**. Only the people you add see the project in Beebole.
  </Accordion>

  <Accordion title="Can I grant access to a whole department at once?">
    Yes. Tag the department's people, then add that tag under **By tags** in the item's **Who has access?** panel. Anyone tagged later inherits the access automatically, including through descendant tags.
  </Accordion>

  <Accordion title="Where do I set what everyone sees by default?">
    In Beebole's **Account Settings**, under **Show or hide by default**. Each option — projects, secondary projects, time off, expenses, work schedules, tasks, and custom fields — decides whether that kind of item is available to everyone or hidden until granted.
  </Accordion>

  <Accordion title="Do I need to save after changing access settings?">
    No. Beebole saves changes in **Who has access?**, **Show or hide**, and **Show or hide by default** automatically as you add or remove people, tags, and options.
  </Accordion>
</AccordionGroup>


# Audit trail: track every change in your account
Source: https://beebole.com/help/documentation/audit-trail

Beebole's audit trail records who changed what and when, surfaced in the Journal feed and as a Logs view on individual records.

Beebole's audit trail records every change made to your account's data — who made it and when. It gives administrators an accountable history of edits across people, projects, tasks, time, and configuration, so you can trace any modification back to a person and a moment in time.

<Info>
  The audit trail is part of higher-tier subscriptions and is not available on the entry-level plan. If you don't see it, check your [subscription](/help/documentation/subscription).
</Info>

## What the audit trail records

Each audit trail entry captures the operation that ran, who performed it, when it happened, and the values that were submitted with the change.

| Detail               | Description                                                        |
| -------------------- | ------------------------------------------------------------------ |
| **Operation**        | The action that ran, such as adding, editing, or removing a record |
| **Person**           | Who performed the action                                           |
| **Timestamp**        | When the action occurred                                           |
| **Submitted values** | The argument names and values passed with the operation            |

Beebole records the values submitted with a change — the new state, not a before-and-after comparison. So the audit trail tells you what was set and by whom, rather than displaying the prior value side by side.

## View audit activity in the Journal

The richest view of audit activity is the **Journal** feed. Audit messages appear there alongside other account activity, newest first.

<Steps>
  <Step title="Open the Journal">
    Click **Journal** in the sidebar.
  </Step>

  <Step title="Read the activity feed">
    Browse the messages in chronological order to see recent changes across the account.
  </Step>

  <Step title="Filter out noise">
    Use **Hide similar entries** to collapse repetitive audit messages of the same kind, so a bulk change doesn't flood the feed.
  </Step>
</Steps>

## See the change history on a record

Individual records carry their own change history. When you view a project, person, task, or other record, Beebole shows who last modified it next to a **Modified by** label.

Click the **Logs** link to expand the full history for that record. Each line lists an operation, who performed it, and how long ago — giving you a focused history without opening the whole Journal.

<Tip>
  Use the **Logs** view on a single record to confirm who made a specific edit, then switch to the **Journal** feed when you need the wider picture across the account.
</Tip>

## Related content

<CardGroup>
  <Card title="Roles & permissions" icon="user-shield" href="/help/documentation/roles-authorisations">
    Control who has admin access to view audit activity.
  </Card>

  <Card title="Data Exports" icon="file-export" href="/help/documentation/data-exports">
    Export your organization's data for reporting and record-keeping.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Does Beebole's audit trail show the previous value of a field?">
    No. Beebole records the values submitted with each change — the new state — along with the operation, who ran it, and when. It does not display a before-and-after comparison of the field.
  </Accordion>

  <Accordion title="Where do I see audit activity in Beebole?">
    In two places. The **Journal** feed shows audit messages across the whole account, and the **Logs** view on an individual record shows that record's own change history.
  </Accordion>

  <Accordion title="Does the audit trail record who viewed data, or only changes?">
    Only changes. Beebole's audit trail records actions that modify data, such as adds, edits, and removals. It does not track who viewed or accessed a record.
  </Accordion>

  <Accordion title="Can I see changes made by archived people?">
    Yes. Changes a person made stay in the audit trail after that person is archived, and their name still appears next to their actions.
  </Accordion>

  <Accordion title="Is the audit trail available on every plan?">
    No. The audit trail is part of higher-tier Beebole subscriptions and is excluded from the entry-level plan. Review your [subscription](/help/documentation/subscription) if it isn't available.
  </Accordion>
</AccordionGroup>


# Sign-in, passkeys, SSO, and API keys
Source: https://beebole.com/help/documentation/authentication

How signing in to Beebole works: one-time email codes, passkeys, Google and Microsoft sign-in, single sign-on (SSO), API keys, and admin sign-in as.

Beebole signs everyone in without passwords. Instead, you confirm your identity with a one-time code emailed to you, a passkey, your Google or Microsoft account, or your organization's single sign-on (SSO) provider. Because there is no password to create, forget, or reset, there is nothing for an attacker to steal or reuse.

<Info>
  Every sign-in method matches against the email address on a person's Beebole profile. To sign in, that email must already belong to an active person in your Beebole account — unless your organization enables automatic user creation for SSO.
</Info>

## Sign-in methods

Beebole offers four ways to sign in. A person can use whichever is most convenient on a given device.

Every method also works for the [desktop app](/help/documentation/desktop-app): signing in there hands off to your browser to complete the sign-in — passkeys, Google or Microsoft, and SSO included — and returns you to the app signed in.

| Method              | How it works                                                          | Setup needed                                                                      |
| ------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
| Email code          | Beebole emails a one-time 6-digit code; you enter it to sign in       | None — available by default                                                       |
| Passkey             | Your device unlocks sign-in with a fingerprint, face, or hardware key | Enable once from your user menu                                                   |
| Google or Microsoft | You sign in through your existing Google or Microsoft account         | None for the person; for Google, an admin can link the domain for SSO enforcement |
| SSO                 | You sign in through your organization's identity provider             | An admin configures it on **Account Settings**                                    |

### Email code

The email code is the default method. Enter your email address on the Beebole sign-in page, and Beebole sends a one-time 6-digit code to your inbox. Enter the code to finish signing in. The code is single-use and expires after 5 minutes — request a new one if it does not arrive, and check your spam folder.

### Passkey

A passkey signs you in with your device's built-in security — a fingerprint, face recognition, or a hardware security key — so you skip the email code entirely. Passkeys are phishing-resistant because the credential never leaves your device.

Enable a passkey from your user menu:

<Steps>
  <Step title="Open the user menu">
    Click the button with your initials at the bottom of the sidebar.
  </Step>

  <Step title="Enable the passkey">
    Click **Enable passkey** and follow your browser's prompts to register a fingerprint, face, or hardware key.
  </Step>
</Steps>

<Info>
  **Enable passkey** appears in the user menu only on devices that support passkeys and only when your account does not already have one registered.
</Info>

### Google and Microsoft sign-in

You can sign in with an existing Google or Microsoft account, which is convenient for teams already using Google Workspace or Microsoft 365. Beebole matches the Google or Microsoft account's email address to your Beebole profile, so the two must use the same email address.

## Single sign-on (SSO)

Single sign-on lets your whole team authenticate through your organization's identity provider using OpenID Connect. An administrator configures it on the **Single Sign-On** panel of **Account Settings**. Beebole supports three providers, each on its own tab: **Google**, **Microsoft**, and **Custom OpenID** (for providers such as Okta, Auth0, or Microsoft Entra ID).

<Info>
  Open the **Single Sign-On** panel from **Account Settings** — the page you reach through **Settings** > **Account Settings**. SSO is configured on the organization itself, not as a separate menu item. All SSO settings save automatically as you change them.
</Info>

The **Custom OpenID** tab is available on higher-tier plans. If your plan does not include it, only the **Google** and **Microsoft** tabs appear. See [Subscription & Billing](/help/documentation/subscription) for what each plan includes.

### Google SSO

<Steps>
  <Step title="Open the Google tab">
    On **Account Settings**, open the **Single Sign-On** panel and select the **Google** tab.
  </Step>

  <Step title="Link a domain">
    Type your organization's email domain in the **Linked domains** field and click **Add**. People whose email matches a linked domain are sent to Google sign-in. Click **Remove** next to a domain to unlink it.
  </Step>

  <Step title="Provision new people automatically (optional)">
    Turn on **Automatically create new users on first SSO login** to create a person automatically the first time someone with a matching domain signs in.
  </Step>

  <Step title="Require Google sign-in (optional)">
    Turn on **Disable interactive sign-in. Only Google sign-in allowed.** to block the email-code method for your organization.
  </Step>
</Steps>

### Microsoft SSO

On **Account Settings**, open the **Single Sign-On** panel and select the **Microsoft** tab. To require everyone to authenticate through Microsoft, turn on **Disable interactive sign-in. Only Microsoft sign-in allowed.**

### Custom OpenID

The **Custom OpenID** tab connects any OpenID Connect-compatible provider.

<Steps>
  <Step title="Open the Custom OpenID tab">
    On **Account Settings**, open the **Single Sign-On** panel and select the **Custom OpenID** tab.
  </Step>

  <Step title="Enter your provider details">
    Fill in the **Issuer URL**, **Client ID**, and **Client Secret** from your identity provider. If your provider does not support OpenID Connect discovery, turn on **Other provider** and enter the **Authorization URL** and **Token URL** by hand instead of the issuer.
  </Step>

  <Step title="Configure your provider">
    Copy the **Initiate URI** and **Callback URI** shown in Beebole (each has its own **Copy** button) and paste them into your identity provider's application settings.
  </Step>

  <Step title="Require this provider (optional)">
    Turn on **Disable interactive sign-in. Only this SSO provider allowed.** to block all other sign-in methods.
  </Step>
</Steps>

<Warning>
  Before turning on a **Disable interactive sign-in** toggle, confirm SSO works by signing in as a test user. If your identity provider becomes unavailable while enforcement is on, your team is locked out until you turn the toggle back off.
</Warning>

## API keys

Each person has one API key for Beebole's [GraphQL API](/help/api/introduction). Beebole creates the key automatically the first time you open it — there is no key to add, and no expiration to set.

<Steps>
  <Step title="Open the user menu">
    Click the button with your initials at the bottom of the sidebar.
  </Step>

  <Step title="Open Your API key">
    Click **Your API key**. Your key is shown, partly masked.
  </Step>

  <Step title="Copy or reset the key">
    Click **Copy** to copy the full key to your clipboard. Click **Reset** to revoke the current key and generate a new one.
  </Step>
</Steps>

<Warning>
  Treat your API key like a credential — never share it or commit it to source control. If it is exposed, click **Reset** to revoke it and issue a new one immediately. Any integration using the old key stops working until you update it.
</Warning>

## Sign in as another person

Administrators can sign in as another person to troubleshoot a problem or confirm what that person sees. You start this from your own user menu, not from the other person's profile.

<Steps>
  <Step title="Open the user menu">
    Click the button with your initials at the bottom of the sidebar.
  </Step>

  <Step title="Choose Sign in as…">
    Click **Sign in as…**. A search box opens listing the people in your account — pick the one you want.
  </Step>

  <Step title="Return to your own account">
    Click **Stop** to end the session and return to your own account.
  </Step>
</Steps>

<Info>
  Sign-in-as activity is recorded in the [audit trail](/help/documentation/audit-trail), attributed to the administrator who started it. The option appears only for people with the Admin role.
</Info>

## Related content

<CardGroup>
  <Card title="Account Settings" icon="gear" href="/help/documentation/account-settings">
    Configure your organization, including the Single Sign-On panel.
  </Card>

  <Card title="Roles & permissions" icon="shield" href="/help/documentation/roles-authorisations">
    Control what each person can see and do in Beebole.
  </Card>

  <Card title="Audit Trail" icon="list" href="/help/documentation/audit-trail">
    Review a log of actions taken in your account, including sign-in-as.
  </Card>

  <Card title="API Introduction" icon="code" href="/help/api/introduction">
    Authenticate to the Beebole GraphQL API with your API key.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Why doesn't Beebole ask me for a password?">
    Beebole has no passwords. You sign in with a one-time 6-digit code sent to your email, or more quickly with a passkey, your Google or Microsoft account, or your organization's SSO provider. With no password to steal or reuse, there is nothing to forget or reset.
  </Accordion>

  <Accordion title="Can I use more than one sign-in method?">
    Yes. As long as your organization has not turned on a **Disable interactive sign-in** toggle, you can sign in with the email code, a passkey, or a linked Google or Microsoft account — whichever is handiest on the device you are using.
  </Accordion>

  <Accordion title="How do I make everyone sign in through SSO?">
    On **Account Settings**, open the **Single Sign-On** panel, select your provider's tab, and turn on its **Disable interactive sign-in** toggle. This blocks the email-code method so everyone must authenticate through the configured provider.
  </Accordion>

  <Accordion title="A team member can't sign in — what should I check?">
    Confirm they are using the exact email address on their Beebole profile, and ask them to check their spam folder for the 6-digit code. As an administrator, you can use **Sign in as…** from your user menu to see Beebole as they do.
  </Accordion>

  <Accordion title="How many API keys can I have?">
    One. Beebole creates a single API key per person automatically and offers **Copy** and **Reset** actions for it. Resetting revokes the old key and issues a new one — there are no multiple keys and no expiration dates to manage.
  </Accordion>
</AccordionGroup>


# Billing rates: turn tracked time into revenue
Source: https://beebole.com/help/documentation/billing

Set billing rates in Beebole at the organization, tag, project, or person level and turn tracked hours into billable amounts in reports.

Beebole's billing rates turn tracked time into revenue figures. You define what an hour, a day, or a piece of work is worth, and Beebole calculates billable amounts from the time your team logs — ready to analyze in reports and to measure against budgets.

<Info>
  Billing rates are available on paid Beebole plans. Who can view and edit them is controlled by the **Billing rates** permission — see [Roles & permissions](/help/documentation/roles-authorisations).
</Info>

<div>
  <iframe title="Manage Costs and Billing Rates" />
</div>

***

## Billing methods

Each billing rate uses one of four methods:

| Method           | What it means                                                     |
| ---------------- | ----------------------------------------------------------------- |
| **Hourly rate**  | A fixed amount per hour worked                                    |
| **Daily rate**   | A fixed amount per day worked                                     |
| **Fixed fee**    | A flat amount, regardless of time spent — optionally repeating    |
| **Non-billable** | No billing amount is calculated for the time covered by this rate |

***

## Where to set billing rates

Billing rates live in the **Billing** section of the organization, tag, project, or person settings panel. You can set them at four levels: organization, tag, project, and person.

| Level            | Typical use                                                                          |
| ---------------- | ------------------------------------------------------------------------------------ |
| **Organization** | A company-wide default rate                                                          |
| **Tag**          | A default for everything under the tag — a department or a client group, for example |
| **Project**      | A rate negotiated for one project, including its subprojects                         |
| **Person**       | A rate tied to one person, such as a contractor                                      |

To open the **Billing** section at each level:

* **Organization** — click the button with your initials at the bottom of the sidebar, then go to **Settings** > **Account Settings**.
* **Tag** — click **Tags** in the sidebar, then the tag's name.
* **Project** — click **Projects** in the sidebar, then the project's name.
* **Person** — click **People** in the sidebar, then the person's name.

### Adding a billing rate

<Steps>
  <Step title="Open the Billing section">
    In the settings panel, scroll to **Billing**.
  </Step>

  <Step title="Add a rate">
    Click **Add** to create a new billing rate.
  </Step>

  <Step title="Set the start date">
    Pick the **From** date — the date the rate takes effect.
  </Step>

  <Step title="Choose the method and amount">
    Select a **Billing method** and enter the **Amount** with its currency. Changes are saved automatically.
  </Step>
</Steps>

<Info>
  Rates set on the organization or on a tag cascade down: a project or person without its own rate shows the rate it inherits. Adding a rate directly on the project or person overrides the inherited one.
</Info>

***

## Which rate applies to a time entry

When several billing rates could apply to the same time entry, the most specific rate wins. For each entry, Beebole looks for a rate in this order:

1. **The project the time was logged against** — starting at the deepest subproject and walking up the project hierarchy.
2. **The person who logged the time** — used when no project in the chain has a rate.

Rates inherited from tags or from the organization count as the rate of the project or person they cascade to, so a company-wide default still applies through this same lookup. Billing rates cannot be set directly on a task; time tracked on a task is billed through the project and person rates above.

***

## Rate splits

With an **Hourly rate** or **Daily rate**, you can replace the single amount with a separate amount per person or project. The split options are:

* **No split** — one amount applies to everyone.
* **Split by persons** — a separate amount for each person you add to the list. Available on organizations, tags, and projects.
* **Split by projects** — a separate amount for each project you add to the list. Useful on a person or tag whose work is billed differently per project.

Each row in a split has its own **Amount**, and a **Non-billable** checkbox to exclude that person or project from billing entirely.

***

## Changing rates over time

Each billing rate has a single **From** date. The rate applies to time entries dated on or after that date, until a rate with a later **From** date takes over. To raise a project's rate from January 1, add a new rate starting January 1 — entries before that date keep the old rate, with no recalculation needed.

You can also click **Duplicate** inside a rate card to copy an existing rate as the starting point for the new one.

***

## Recurring fixed fees

A **Fixed fee** applies once. To bill it repeatedly — a monthly retainer, for example — turn on **Repeat** in the rate card and choose how often it recurs: **Every** 1 or more days, weeks, months, or years. Choose **End** to stop the repetition on a given date, or **Do not end** to let it run indefinitely.

***

## Billing in reports

Tracked time is multiplied by the resolved rate and shown in [reports](/help/documentation/reports). In a [custom report](/help/documentation/custom-reports), add the **Billing** column to see billable amounts, and group by project, person, tag, or period to analyze revenue from any angle. When [cost rates](/help/documentation/costs) are configured too, the **Margin** column shows billing minus cost.

***

## Related content

<CardGroup>
  <Card title="Cost Rates" icon="coins" href="/help/documentation/costs">
    Track what the same work costs you internally and measure margins.
  </Card>

  <Card title="Budgets" icon="chart-pie" href="/help/documentation/budgets">
    Set billing, cost, and hours targets on projects and monitor progress.
  </Card>

  <Card title="Custom Reports" icon="table" href="/help/documentation/custom-reports">
    Build reports with billing and cost columns, grouped and filtered your way.
  </Card>

  <Card title="Projects" icon="folder-tree" href="/help/documentation/projects">
    Create and organize the projects and subprojects your team bills time to.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What happens if no billing rate is set?">
    Beebole calculates no billing amount for that time. The hours still appear in reports, but the **Billing** column stays empty for those entries until a rate at some level applies to them.
  </Accordion>

  <Accordion title="Can I bill the same person at different rates on different projects?">
    Yes. Set a billing rate on each project — project rates take priority over the person's own rate in Beebole. On a single project, use **Split by persons** to give each team member their own amount.
  </Accordion>

  <Accordion title="Can I set a billing rate on a specific task?">
    No. In Beebole, billing rates are set on the organization, tags, projects, and people. Time tracked on a task is billed through the rate of the project it was logged against, or the person's rate.
  </Accordion>

  <Accordion title="How do I change a rate without affecting past entries?">
    Add a new rate with a **From** date set to when the change starts. Beebole applies each rate only to time entries dated on or after its From date, so earlier entries keep the previous rate.
  </Accordion>

  <Accordion title="How do I mark work as non-billable?">
    Choose the **Non-billable** billing method on the relevant project, person, or tag, or tick the **Non-billable** checkbox next to a person or project inside a rate split. Beebole then calculates no billing amount for that time.
  </Accordion>
</AccordionGroup>


# Browser extension: turn browsing time into draft entries
Source: https://beebole.com/help/documentation/browser-extension

Install the Beebole browser extension for Chrome, Edge, or Firefox and turn time on the sites you choose into draft timesheet entries.

The Beebole browser extension drafts time entries from the websites you choose. It works in Chrome, Edge, and Firefox, connects directly to your Beebole account with your API key, and sends only the site address, page title, and time spent. The result shows up as [suggested time entries](/help/documentation/ai#suggested-time-entries) — nothing reaches your timesheet until you accept it.

<Info>
  The extension only watches sites you explicitly pick. For sites you additionally allow, it can also read the visible page text to classify the work more precisely — that content is used only to classify and is never stored.
</Info>

***

## Downloading and installing

<Steps>
  <Step title="Open the Assistant page">
    Click **Assistant** in the sidebar and scroll to the **Browser extension** section.
  </Step>

  <Step title="Download the extension">
    Next to **Download**, pick **Chrome / Edge** or **Firefox** — or download the current build directly: [Chrome / Edge](https://app.beebole.com/downloads/beebole-extension-chrome.zip) or [Firefox](https://app.beebole.com/downloads/beebole-extension-firefox.zip). Either way you get a `.zip` file, always the latest version.
  </Step>

  <Step title="Load it in your browser">
    Until the extension reaches the browser stores, install it manually: unzip the download, then load it in your browser — Chrome / Edge: `chrome://extensions` → **Developer mode** → **Load unpacked**; Firefox: `about:debugging` → **This Firefox** → **Load Temporary Add-on**.
  </Step>

  <Step title="Connect it to your account">
    In the extension's options, paste the **Server address** and your **API key** — both shown with copy buttons on the **Assistant** page (click **Show my API key** if the key is hidden).
  </Step>

  <Step title="Pick the sites it may watch">
    Still in the options, choose the sites the extension is allowed to watch. Everything else is ignored.
  </Step>
</Steps>

***

## How it works

While you browse a watched site, the extension measures the time you spend there and sends the site address, page title, and duration to your Beebole server. That activity becomes draft entries in the **Suggested entries** tray above your timesheet, where you **Accept**, **Accept all**, or **Dismiss** each one.

On sites where you additionally allow it, the extension reads the visible page text to match your time to the right project or task more accurately. Page content is used only for that classification and is never stored.

<Warning>
  Your API key gives access to your Beebole account with your permissions. If you shared it by mistake, click **Reset** next to the key on the **Assistant** page — the old key stops working immediately, and you'll need to paste the new one into the extension.
</Warning>

***

## Related content

<CardGroup>
  <Card title="Beebole AI" icon="sparkles" href="/help/documentation/ai">
    All of Beebole's AI features, including how suggestions work.
  </Card>

  <Card title="Desktop app" icon="desktop" href="/help/documentation/desktop-app">
    Capture activity beyond the browser on macOS, Windows, and Linux.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Where suggested entries appear and get accepted.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Which browsers does the Beebole extension support?">
    Chrome and Edge (one download) and Firefox (another). Both are downloaded from the **Assistant** page in Beebole and installed manually until the extension is published to the browser stores.
  </Accordion>

  <Accordion title="Does the extension see everything I browse?">
    No. The Beebole extension only watches the sites you explicitly pick in its options. On those sites it records the address, page title, and time spent — and it reads page content only on sites you separately allow, purely to classify the work, without storing it.
  </Accordion>

  <Accordion title="Do I need the desktop app to use the extension?">
    No. The extension connects directly to your Beebole account with your API key — the desktop app is not required. Install both only if you want activity outside the browser suggested too.
  </Accordion>

  <Accordion title="Why do my suggestions disappear after a while?">
    Suggestions are drafts, not records. If you dismiss them — or never accept them — they simply don't become time entries. Accept a suggestion to turn it into a real entry on your Beebole timesheet.
  </Accordion>
</AccordionGroup>


# Project budgets: billing, cost, and hours targets
Source: https://beebole.com/help/documentation/budgets

Set and track budgets on projects and subprojects in Beebole to monitor hours, costs, and billing against your targets and catch overruns early.

Beebole's budgets let you set targets for billing, costs, or hours on your projects and subprojects, and track progress against those targets in real time. Budgets help you spot overruns before they become problems.

<Info>
  Budgets are not included in every Beebole plan. Review your plan and add-ons on the [Subscription](/help/documentation/subscription) page.
</Info>

<Frame>
  <iframe title="Assign project budgets in Beebole" />
</Frame>

***

## Budget types

Each budget on a project has three target fields:

| Field              | What it tracks                    | Example                                         |
| ------------------ | --------------------------------- | ----------------------------------------------- |
| **Time**           | Time allocation, in hours or days | "This project has a 500-hour cap"               |
| **Billing amount** | Revenue target                    | "This project should generate €50,000"          |
| **Cost amount**    | Internal cost limit               | "Don't spend more than €30,000 on this project" |

You can use any combination of these on the same budget — fields you leave empty simply aren't tracked.

The **Time** target is stated in the unit you pick next to the field — **Hours** or **Days** — and your last choice becomes the default for the next budget. Days are measured against each person's [work schedule](/help/documentation/work-schedule), so a day always means one person's scheduled day.

***

## Setting up a budget

<Steps>
  <Step title="Open the project">
    Navigate to [Projects](/help/documentation/projects) and click the project you want to budget.
  </Step>

  <Step title="Open the Budgets panel">
    In the project's detail panel, open the **Budgets** panel.
  </Step>

  <Step title="Add a budget">
    Click **Add**. Beebole creates the budget and opens it for editing.
  </Step>

  <Step title="Define the targets">
    Enter your targets in **Time**, **Billing amount**, and **Cost amount**. Changes are saved automatically, and Beebole starts tracking progress against the budget immediately.
  </Step>

  <Step title="Set when it starts (optional)">
    A new budget starts counting from the day you create it — its **From** date is set to today. Change **From** to apply the budget from another day. A budget with no From date counts **From the start** — everything ever logged on the project.
  </Step>
</Steps>

Each budget can also hold free-text **Notes** — a purchase order number or the agreement with the customer, for example — shown on the budget's card.

***

## Several budgets over time

A project can hold more than one budget: click **Add** again to create the next one. Each budget applies from its own **From** date onward, so successive budgets model renewals, yearly envelopes, or a re-negotiated scope — the panel lists them in chronological order.

***

## Budget splits

For more detailed tracking, you can split a budget using its **Type** field:

* **Split by person** — Allocate a portion of the budget to each team member, with its own time, billing amount, and cost amount.
* **Split by project** — Distribute the budget across projects from another category — for example, splitting a client's budget across activities.
* **No split** — One set of targets applies to the whole project.

Budget splits let you see not just whether the overall project is on track, but whether individual contributors or work streams are within their allocation.

***

## Monitoring budgets

Click **Reports** in the sidebar, then **Budget Status**, to track every budget in one place. The report shows a progress bar per project comparing the hours, billing, and cost actually logged against your targets, rolls subproject activity up the hierarchy, and flags budgets that are at risk or over budget. See [Reports](/help/documentation/reports) for the report's filters and export options.

The report is also where a budget in trouble surfaces on its own: the status filter narrows the list to projects above the at-risk threshold (**> 80%**) or **Over budget**, and the striped forecast bar shows the planned effort still to come, so an overrun is visible before the actuals get there. Beebole tracks consumption in real time, but never blocks a time entry because a budget is exceeded — watching the report is how you catch an overrun in time to act.

<Info>
  Budget notifications are not available yet: there is no setting in the app to switch them on, so nobody is alerted by email when a budget passes a threshold. Watch the [Budget Status report](/help/documentation/reports#budget-status) instead — it always flags projects that are approaching or over their budget, with nothing to configure.
</Info>

***

## Related content

<CardGroup>
  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Create and configure the projects where budgets are set and tracked.
  </Card>

  <Card title="Cost rates" icon="chart-bar" href="/help/documentation/costs">
    Define cost rates that feed into cost budget calculations.
  </Card>

  <Card title="Reports" icon="chart-simple" href="/help/documentation/reports">
    Read the Budget Status report, and filter, sort, or export budget progress.
  </Card>

  <Card title="Billing rates" icon="tag" href="/help/documentation/billing">
    Configure billing rates used in billing budget tracking.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I set budgets on categories (not just projects)?">
    Budgets are set on individual projects or subprojects. The **Budget Status** report rolls subproject consumption up the project hierarchy for a higher-level view.
  </Accordion>

  <Accordion title="Does Beebole alert me when a budget is exceeded?">
    Not by email today — there is no setting in the app to turn budget alert emails on. The [Budget Status report](/help/documentation/reports#budget-status) is where at-risk and over-budget projects are flagged, and it always shows them with no setting to configure.
  </Accordion>

  <Accordion title="Can I change a budget after it's been set?">
    Yes. You can update a budget's targets at any time — changes are saved automatically, and the **Budget Status** report immediately measures all consumption against the new target.
  </Accordion>

  <Accordion title="Do expenses count toward project budgets?">
    Yes. Expense amounts contribute to a project's budget consumption alongside time-based costs — controlled per expense type by its **Impacts budget** setting. See [Expenses](/help/documentation/expenses).
  </Accordion>

  <Accordion title="Can I set a budget in days instead of hours?">
    Yes. Each budget's **Time** target has a unit picker — choose **Hours** or **Days** per budget, and Beebole remembers your last choice for the next one. Days are measured against each person's work schedule, and the **Budget Status** report shows every budget in the unit it was stated in.
  </Accordion>
</AccordionGroup>


# Key concepts: projects, people, tasks, and tags
Source: https://beebole.com/help/documentation/concepts

Understand how Beebole is structured — projects, people, tasks, and tags — and how rates, schedules, and platform features connect them.

Beebole is built around four building blocks — projects, people, tasks, and tags. This page explains what each one represents, how they connect, and which features — like billing rates, work schedules, and custom fields — apply across all of them.

***

## The four building blocks

Everything in Beebole revolves around four kinds of items:

| Building block | What it represents                                         | Examples                                              |
| -------------- | ---------------------------------------------------------- | ----------------------------------------------------- |
| **Projects**   | The work your team tracks time against                     | Client engagements, internal initiatives, departments |
| **People**     | The users and team members in your account                 | Employees, managers, contractors, administrators      |
| **Tasks**      | The work items you plan, schedule, and assign              | Deliverables, milestones, planned work                |
| **Tags**       | Labels that group and classify people, projects, and tasks | Departments, teams, locations, cost centers           |

These four building blocks form the foundation of your Beebole account. Time entries, reports, budgets, planning, and approval workflows all build on top of them.

Each person also has a role that controls what they can see and do. By default, employees have access to their own data, managers have access to their team's or projects' data, and administrators have access to everything. See [Roles & permissions](/help/documentation/roles-authorisations).

***

## How everything fits together

The four building blocks don't exist in isolation — they connect to create a complete picture of your organization's work:

* **People work on projects — and tasks.** When someone logs time, they select a project (and optionally a subproject), or a task: time can be tracked on tasks as well as projects. This is the core relationship in Beebole.
* **Tasks are independent planning items, not parts of a project.** Where projects model what hours go *into*, tasks model the work *to be done*. A task can optionally be linked to a project — which connects your planning and time tracking — but it exists on its own, with its own dates, owner, and status, managed in the Gantt chart and Kanban board.
* **Projects have hierarchies.** Categories contain projects, which can contain subprojects, nested as deep as you need.
* **Tags group people, projects, and tasks.** A tag like "Engineering" can contain the engineering team members, the engineering projects, and engineering tasks, making it easy to filter and report by department.
* **Tags have hierarchies too.** Tags can be organized into parent/child structures (e.g., "Europe" > "France" > "Paris office").

<Info>
  Think of projects as *what* your team tracks time against, tasks as *what you plan and schedule*, people as *who* does the work, and tags as *how you organize* everything for reporting and management.
</Info>

***

## Shared configuration

Several features in Beebole aren't tied to a single kind of item — they apply across projects, people, and tags. Understanding this pattern is key to configuring Beebole effectively.

### Billing and cost rates

Billing and cost rates can be set at multiple levels:

| Level            | What it controls                                          |
| ---------------- | --------------------------------------------------------- |
| **Organization** | Default rates for the entire account                      |
| **Tag**          | Rates for everyone and everything in a department or team |
| **Project**      | Rates specific to a client or engagement                  |
| **Person**       | Rates for an individual team member                       |

[When rates exist at more than one level, Beebole applies the most specific one. Learn how rates are resolved on the ](/help/documentation/costs)[Billing rates](/help/documentation/billing) and [Cost rates](/help/documentation/costs) pages.

### Work schedules

Work schedules define expected working hours per day across a repeating cycle. Like rates, they can be assigned at the organization, tag, or person level, and the most specific assignment applies.

Learn more[ about work schedules](/help/documentation/work-schedule).

### Custom fields

Custom fields let you add your own data to Beebole's built-in records. You can create fields that appear on:

* **People** (e.g., Employee ID, Office Location)
* **Projects** (e.g., Priority, Contract Type)
* **Tasks** (e.g., Sprint, Story Points)
* **Time entries** (e.g., Activity Type, Deliverable)

Learn more[ about custom fields](/help/documentation/custom-fields).

### Assignments

You control which projects, tasks, absence types, and expense types are available to each person in their timesheet. These assignments can be managed at the organization, tag, or individual level.

Learn more[ about assignments](/help/documentation/assignments).

***

## How it all comes together

Here's a typical setup to illustrate how these concepts connect:

1. **You create projects** organized by category (e.g., **Clients** or **Internal**) and engagement (e.g., **Acme Corp** or **Website Redesign**).
2. **You add people** and assign them roles that control their permissions.
3. **You create tags** for departments and teams, then tag both people and projects.
4. **You set billing rates** on projects (what you charge clients) and **cost rates** on people (what they cost internally). Tags can provide default rates for entire departments.
5. **You assign work schedules** to define expected working hours — at the organization level for most people, with overrides on specific tags or individuals.
6. **People log time** against projects on their timesheets. Each entry captures who, what, when, and how long.
7. **Reports** combine all of this — showing time, costs, billing, and budgets across any combination of projects, people, and tags.

***

## Platform-wide features

A few features in Beebole apply globally, regardless of which section you're working in.

### Search

Each list in Beebole — people, projects, tasks, tags, roles, custom fields, and other lists — has a **Search by name** field at the top of its panel. Beebole uses fuzzy matching, so typing characters that appear in order anywhere in a name returns a hit even when they're not consecutive. Matched characters are highlighted in the results so you can confirm you've found the right record.

Use the search field to:

* **Find anything by partial name.** Typing `alibr` matches "Alice Brooks" and "Aliso Bridges".
* **Filter long lists.** Searching narrows hierarchies like the project tree, expanding only the branches that contain matching entries.
* **Move through results with the keyboard.** Press the up and down arrow keys to step through the filtered list, and **Escape** to clear the search and restore the full list.

Search is local to the panel you're in — there is no single search across the whole application, so use the sidebar to switch between **People**, **Projects**, **Tags**, and **Tasks** when you need to look elsewhere.

### Fast loading

Beebole caches your account data locally in your browser, so lists and timesheets appear near-instantly when you open a page. Beebole shows the cached data right away, then refreshes it from the server in the background. The local cache clears itself automatically when you switch organizations or when a new version of Beebole is deployed — you never need to clean it up manually.

### Real-time sync

Beebole keeps everyone in your account in sync without requiring a refresh. When a teammate creates, edits, archives, or deletes something — a project, a task, a time entry, an approval action, a journal message — the change appears for all other connected users within seconds.

Real-time sync covers:

* **Record changes** — Adds, edits, archives, deletes, renames.
* **Approval actions** — Submitted, approved, and rejected timesheets update for the approver and the submitter at the same time.
* **Planning and Gantt updates** — Task changes propagate to the planning view and the Gantt chart in real time.
* **Journal messages and notifications** — New mentions, replies, and notifications appear without polling.

<Info>
  Real-time sync uses a persistent connection between your browser and Beebole. If your network drops temporarily, Beebole reconnects automatically and catches up on any changes you missed while offline.
</Info>

### When your network blocks real-time updates

Some corporate firewalls, VPNs, and proxies block the secure real-time connection Beebole prefers. When that happens, Beebole keeps working — it switches to a slower compatibility mode and shows an indicator in the sidebar: **Running in slower compatibility mode**. For what the indicator means, the built-in diagnostics page, and what to send support, see [Troubleshooting](/help/documentation/troubleshooting).

### Undo and redo

Beebole lets you undo and redo most changes. Press **⌘+Z** (Ctrl+Z on Windows/Linux) to undo, and **⌘+Shift+Z** (Ctrl+Shift+Z) to redo. Undo and redo buttons also appear in the top bar whenever there is something to undo or redo.

Bulk changes are grouped into a single operation, so one undo reverts the whole change rather than one piece at a time.

### Duplication

Most records in Beebole support a **Duplicate** action that creates a copy with the same configuration as the original. Use it to bootstrap a new project from a template or set up a person record similar to an existing one.

To duplicate something, open the **⋯** action menu next to its name and select **Duplicate**. For example, duplicating a project copies its subprojects, settings, and relations, and places the copy under the same parent as the original. Historical data such as logged time stays with the original.

<Info>
  Duplicating a person opens a small dialog where you enter a new name and email and choose a role before the copy is created. This is because each person needs unique identity fields.
</Info>

### Attribute copy and paste

In addition to duplicating an entire record, Beebole lets you copy a specific configuration block — billing rates, cost rates, budgets, or time-off allowances — from one record and paste it onto another. Use it to keep configurations consistent across similar projects, or to transfer one person's allowance structure to a new hire.

The basic flow:

<Steps>
  <Step title="Open the source">
    Open the record whose configuration you want to copy (for example, a project with the right billing rate setup).
  </Step>

  <Step title="Copy the attribute">
    Click **Copy** on the configuration block. Beebole keeps it on an internal clipboard until you paste it.
  </Step>

  <Step title="Open the target">
    Open the destination — a different project, person, or tag, whichever supports the same kind of configuration.
  </Step>

  <Step title="Paste the attribute">
    Click **Paste** on the matching configuration block. The configuration is applied to the target without affecting any other settings.
  </Step>
</Steps>

<Info>
  You can only copy values set directly on a record. Inherited values can't be copied — copy from the record where the value is actually defined.
</Info>

### Color coding

Beebole assigns each person, project, tag, and task a color used as a visual identifier across the interface. Avatars, list rows, planning blocks, and journal references share the same color, making it easy to scan a list, the planning view, or a Gantt chart and recognize who or what you're looking at.

The default color is generated automatically when a record is created. To change it, open the record and click its picture — or its colored initials — at the top of the detail panel, then pick a color from the palette. The same panel lets you upload a picture instead.

<Info>
  Color is purely a visual aid — it does not affect access, permissions, billing, or reporting. Use it to make at-a-glance scanning easier, especially in shared views like planning, Gantt, or the journal.
</Info>

### Version update notifications

When a new version of Beebole is deployed, a banner labeled **Update available** appears in the interface. Click the banner (**Click to reload**) to reload the app and apply the latest version. This ensures you always have access to new features and fixes without needing to clear your cache manually.

***

## Related content

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/help/documentation/quickstart">
    Set up your first project, team, and report in six steps.
  </Card>

  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Create and organize projects for your team to track time against.
  </Card>

  <Card title="People" icon="users" href="/help/documentation/people">
    Add and manage the team members in your account.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Track time on your projects and submit timesheets.
  </Card>
</CardGroup>

***

<Steps>
  <Step title="Open the source entity">
    Open the entity whose configuration you want to copy (for example, a project with the right billing rate setup).
  </Step>

  <Step title="Copy the attribute">
    Open the source's action menu and select **Copy**. Beebole stores the attribute configuration on the clipboard until you paste it.
  </Step>

  <Step title="Open the target entity">
    Open the destination entity (a different project, person, or tag — whichever supports the same attribute).
  </Step>

  <Step title="Paste the attribute">
    Open the target's action menu and select **Paste**. The attribute configuration is applied to the target without affecting any other settings.
  </Step>
</Steps>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I need to set up all four building blocks before my team can track time?">
    No. In Beebole you need at least one project and one person to start tracking time. Tags and tasks are optional — tags unlock powerful reporting, and tasks add planning on top of time tracking. See the [Quickstart](/help/documentation/quickstart) for the minimum setup.
  </Accordion>

  <Accordion title="What's the difference between a subproject and a task?">
    Subprojects are part of Beebole's project hierarchy — they subdivide a larger project for time tracking. Tasks are independent planning items with their own dates, owner, and status. A task can be linked to a project but exists separately, and is managed visually on the Gantt chart and Kanban board.
  </Accordion>

  <Accordion title="What's the difference between a tag and a project category?">
    A project category is part of Beebole's project hierarchy — it groups projects together. A tag is a cross-cutting label that can be applied to people, projects, and tasks. Use categories for your project structure and tags for organizational dimensions like departments, locations, or cost centers.
  </Accordion>

  <Accordion title="If rates are set at several levels, which one applies?">
    Beebole applies the most specific rate available for each time entry. For example, a rate set directly on a project overrides a default set on the organization. See [Billing rates](/help/documentation/billing) for how rates are resolved.
  </Accordion>

  <Accordion title="Can I change my structure after my team has started tracking time?">
    Yes. In Beebole you can reorganize projects, update tags, and change rates at any time. Historical time entries are preserved. However, structural changes may affect how existing data appears in filtered reports.
  </Accordion>
</AccordionGroup>


# Cost rates: track labor costs and margins
Source: https://beebole.com/help/documentation/costs

Define cost rates in Beebole for your organization, tags, projects, and people to track labor costs and measure project margins in reports.

Beebole's cost rates track what work costs your organization internally. While [billing rates](/help/documentation/billing) represent what you charge, cost rates capture what you spend — and with both in place, Beebole shows you the margin on every project, person, and period in your reports.

<Info>
  Cost rates are not included in every Beebole plan. Review your plan and add-ons on the [Subscription](/help/documentation/subscription) page. Who can view and edit them is controlled by the **Costs** permission — see [Roles & permissions](/help/documentation/roles-authorisations).
</Info>

<div>
  <iframe title="Manage Costs and Billing Rates" />
</div>

***

## Cost methods

Each cost rate uses one of four methods:

| Method          | What it means                                                  |
| --------------- | -------------------------------------------------------------- |
| **Hourly rate** | A fixed cost per hour worked                                   |
| **Daily rate**  | A fixed cost per day worked                                    |
| **Fixed fee**   | A flat cost, regardless of time spent — optionally repeating   |
| **No cost**     | No cost amount is calculated for the time covered by this rate |

***

## Where to set cost rates

Cost rates live in the **Cost** section of the organization, tag, project, or person settings panel — the same panel where [billing rates](/help/documentation/billing) are configured. You can set them at four levels:

| Level            | Typical use                                                                    |
| ---------------- | ------------------------------------------------------------------------------ |
| **Organization** | A company-wide default cost — set it under **Settings** > **Account Settings** |
| **Tag**          | An average cost for a department or team                                       |
| **Project**      | A specific cost allocation for one project and its subprojects                 |
| **Person**       | The person's loaded labor cost — salary plus benefits and overhead             |

<Steps>
  <Step title="Open the Cost section">
    Open the organization (**Settings** > **Account Settings**), or click **Tags**, **Projects**, or **People** in the sidebar and then the tag, project, or person name. Scroll to **Cost**.
  </Step>

  <Step title="Add a rate">
    Click **Add** (**Add a new cost rate**).
  </Step>

  <Step title="Set the start date">
    Pick the **From** date — the date the rate takes effect.
  </Step>

  <Step title="Choose the method and amount">
    Select a **Cost method** and enter the **Amount** with its currency. Changes are saved automatically.
  </Step>
</Steps>

<Info>
  Cost rates cascade exactly like billing rates: rates set on the organization or on a tag are inherited by the projects and people beneath them, and a rate added directly on a project or person overrides the inherited one.
</Info>

***

## Which rate applies to a time entry

Cost rates resolve the same way as billing rates: the most specific rate wins. For each time entry, Beebole looks for a cost rate on the project the time was logged against — starting at the deepest subproject and walking up the hierarchy — and falls back to the person's rate when no project rate applies. Rates inherited from tags or the organization count as the rate of the project or person they cascade to. Cost rates cannot be set directly on a task.

***

## Rate splits

With an **Hourly rate** or **Daily rate**, you can replace the single amount with a separate amount per person or project:

* **No split** — one cost applies to everyone.
* **Split by persons** — a separate cost for each person you add to the list, for projects or tags where team members cost different amounts.
* **Split by projects** — a separate cost for each project you add to the list.

You can see at a glance which rates are split. Where a single-amount rate shows its amount, a split rate's card shows the split it uses — **Split by persons** or **Split by projects** — with badges for the people or projects the cost is shared across. Open the card to read or change each line.

***

## Changing rates over time

Each cost rate has a single **From** date. The rate applies to time entries dated on or after that date, until a rate with a later **From** date takes over — so an annual salary adjustment is just a new rate starting on the right date, and historical entries keep their original cost.

A **Fixed fee** cost can also repeat: turn on **Repeat** in the rate card and choose how often it recurs — **Every** 1 or more days, weeks, months, or years.

***

## Time off in people costs

Time off counts toward your people costs. A leave day is valued with the person's cost rate for that day, exactly as a regular time entry would be, so it shows up in cost totals in reports and budgets even though no project time was tracked. Time off never carries a billing amount. See [Time off](/help/documentation/timeoff#time-off-and-people-costs) for details.

***

## Margins in reports

When both billing and cost rates are configured, [custom reports](/help/documentation/custom-reports) can compare what you charge against what you spend. Add the **Billing**, **Cost**, and **Margin** columns to a report — **Margin %** is also available — and group by project, person, tag, or period to see where you make or lose money.

<Tip>
  Set up cost rates early, even with approximate amounts. Having both billing and cost data from the start makes margin reports immediately useful.
</Tip>

***

## Related content

<CardGroup>
  <Card title="Billing Rates" icon="file-invoice-dollar" href="/help/documentation/billing">
    Define what you charge for tracked time — the other half of margin tracking.
  </Card>

  <Card title="Budgets" icon="chart-pie" href="/help/documentation/budgets">
    Set cost, billing, and hours targets on projects and catch overruns early.
  </Card>

  <Card title="Custom Reports" icon="table" href="/help/documentation/custom-reports">
    Build reports with billing, cost, and margin columns, grouped your way.
  </Card>

  <Card title="Time Off" icon="umbrella-beach" href="/help/documentation/timeoff">
    Configure absence types and see how time off is valued in your people costs.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between billing rates and cost rates?">
    In Beebole, billing rates represent what you charge for work, and cost rates represent what that work costs you internally. With both configured, reports show the margin between them.
  </Accordion>

  <Accordion title="Do I need both billing and cost rates?">
    No. You can use either independently in Beebole: billing rates alone track revenue, and cost rates alone track internal costs. You only need both to measure margins.
  </Accordion>

  <Accordion title="Can I set different cost rates per person on the same project?">
    Yes. On the project's cost rate, choose **Split by persons** and enter an amount for each team member. Beebole then applies each person's cost when they log time to that project.
  </Accordion>

  <Accordion title="Does time off count toward costs?">
    Yes. Beebole values the leave day with the person's cost rate and includes it in cost totals in reports and budgets, the same way a regular time entry is. Time off never carries a billing amount.
  </Accordion>

  <Accordion title="How do I record a salary change without rewriting history?">
    Add a new cost rate on the person with a **From** date set to when the change takes effect. Beebole applies each rate only to time entries dated on or after its From date, so earlier entries keep the old cost.
  </Accordion>
</AccordionGroup>


# Custom fields: capture extra data on your work
Source: https://beebole.com/help/documentation/custom-fields

Create custom fields in Beebole to capture extra data on people, projects, tasks, and time records — six field types with validation and visibility rules.

Custom fields in Beebole add your own data fields to people, projects, tasks, and time records. Use them to capture what Beebole's built-in attributes don't cover — an employee ID on every person, a client reference on each project, or a ticket number on every time entry — and reuse those values as columns in your reports.

<Info>
  Custom fields come with the **Advanced** plan, and can be added to the **Essential** plan as an add-on. If your subscription doesn't include them, the **Custom Fields** entry in Settings shows an upgrade button instead of opening the page.
</Info>

***

## Creating a custom field

<Steps>
  <Step title="Open the Custom Fields settings">
    Click the button with your initials at the bottom of the sidebar, then go to **Settings** > **Custom Fields**.
  </Step>

  <Step title="Add the field">
    Click **Add Custom Field**, type a name — for example "Employee ID" or "Cost center" — and click **Add Custom Field** to confirm.
  </Step>

  <Step title="Choose the field type">
    In the **Custom field details** panel, pick a **Field type**: **Text**, **Date**, **Date & time**, **Number**, **URL**, or **Boolean**.
  </Step>

  <Step title="Configure the type's options">
    The options for the selected type appear below it — defaults, limits, validation. Every change is saved automatically.
  </Step>

  <Step title="Choose where the field appears">
    In the **Custom field visibility** panel, turn on **Visible for People**, **Visible for Absence types**, **Visible for Time Records**, **Visible for Projects**, or **Visible for Tasks**. A single field can apply to several. The field then appears on the matching records — see [Choosing where a field appears](#choosing-where-a-field-appears).
  </Step>
</Steps>

***

## Field types

Beebole supports six field types, each suited to a different kind of data:

| Type            | Holds                                          | Example use                          |
| --------------- | ---------------------------------------------- | ------------------------------------ |
| **Text**        | Free text, or a pick list of predefined values | Employee ID, client reference        |
| **Number**      | Numeric values, with optional prefix or suffix | Mileage, purchase order amount       |
| **Date**        | A calendar date                                | Contract start, certification expiry |
| **Date & time** | A date with a time of day                      | Shift start, incident time           |
| **URL**         | A web link                                     | Link to an external tracker          |
| **Boolean**     | A yes/no value with customizable labels        | Remote worker, billable indicator    |

You can change a field's **Field type** later from the **Custom field details** panel — the type-specific options switch accordingly.

***

## Field options and validation

Each type comes with its own options, all edited in the **Custom field details** panel and saved automatically:

| Type            | Options                                                                                                                                                       |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Text**        | **Minimum length**, **Maximum length**, **Validation pattern (regex)**, **Placeholder text**, and **Use predefined values** with a list of **Allowed values** |
| **Number**      | **Minimum value**, **Maximum value**, **Step size**, **Allow decimal numbers**, **Decimal places**, **Prefix**, **Suffix**                                    |
| **Date**        | **Earliest date**, **Latest date**                                                                                                                            |
| **Date & time** | **Earliest date & time**, **Latest date & time**                                                                                                              |
| **URL**         | **Placeholder text**                                                                                                                                          |
| **Boolean**     | **Label for 'Yes'**, **Label for 'No'**                                                                                                                       |

Custom fields don't carry default values — a field starts empty (or shows its **Placeholder text**) until someone fills it in.

Turn on **Use predefined values** to restrict a text field to a fixed list: add each entry under **Allowed values**, and users pick a value from that list instead of typing freely.

<Info>
  Beebole validates values as people enter them. An entry outside the allowed range or format is flagged with an error and not saved until corrected.
</Info>

***

## Choosing where a field appears

The **Custom field visibility** panel controls which items carry the field. A single field can apply to several, and each toggle is saved automatically:

* **Visible for People** — The field appears on every person's profile.
* **Visible for Projects** — Turn it on, then use **Add a category** to choose the project categories where the field applies. Within each category you can tick the hierarchy levels — for example top-level projects only, or their subprojects too.
* **Visible for Tasks** — Turn it on, then choose the task categories where the field applies.
* **Visible for Time Records** — The field appears when filling in a time entry's details on the timesheet. Narrow it down with **Project categories** and **Plannings**, and turn on **Absences** to also show the field on time-off entries. A field scoped to a planning applies to tasks at every level of that planning.
* **Visible for Absence types** — The field applies to your time off types. It appears in the **Custom fields** panel of each type, and it becomes a column you can review and fill in for time off types in [Master data review](/help/documentation/master-data).

### Who a field is asked of

Visibility decides which *kind* of record can carry the field. The field's **Who has access?** panel then decides *which* records actually get it, with sections for people, tags, projects, tasks, and time off types. When **Show all custom fields** is on in **Show or hide by default**, those sections flip into exclusion lists instead. See [Assignments](/help/documentation/assignments) for how the two directions work together.

On a time record, the field follows the person the timesheet belongs to — not whoever types the entry — and Beebole checks every link the entry offers: the person and their tags, the projects on the entry and their parents, its task, and, on a time-off row, the time off type it is booked against. A match on any one of them brings the field in, which is what makes an assignment to a time off type show the field on absences of that type.

***

## Entering values

Once a field is visible for a given type, it appears automatically on every matching record — there is nothing to add one by one. Open a person, project, or task and fill in the field in its **Custom fields** panel; values are saved automatically as you enter them. For time records, open the entry's details on the timesheet and fill in the field there.

***

## Custom fields in reports

Custom field values flow into reporting. When you build a [custom report](/help/documentation/custom-reports), any custom field visible on people, projects, or tasks is available as a column for that type — so a field like a client reference or region becomes a regular report dimension.

***

## Managing custom fields

To manage an existing field, open it in **Settings** > **Custom Fields** and click the **⋯** action menu next to its name. The menu offers **Duplicate**, **Rename**, **Archive**, **Unarchive**, and **Delete**.

Archived fields disappear from the list. Click **Show Archived** to display them, then use the **⋯** action menu and **Unarchive** to restore one.

<Warning>
  **Delete** only works on a field that holds no values. As long as a value is stored on any person, project, task, or time entry, Beebole refuses the deletion and names what still references the field. Clear those values first, or choose **Archive** to take the field out of use while keeping its data.
</Warning>

***

## Related content

<CardGroup>
  <Card title="People" icon="users" href="/help/documentation/people">
    Manage the profiles where person-level custom fields appear.
  </Card>

  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Organize projects into the categories that drive field visibility.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    See where time-record custom fields show up when entering time.
  </Card>

  <Card title="Custom Reports" icon="table-columns" href="/help/documentation/custom-reports">
    Use custom field values as columns in your report layouts.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Which field types does Beebole support?">
    Beebole offers six custom field types: **Text**, **Number**, **Date**, **Date & time**, **URL**, and **Boolean**. Each type has its own options, such as length limits and patterns for text or earliest and latest dates for date fields.
  </Accordion>

  <Accordion title="Do custom fields appear on the timesheet?">
    Yes. Turn on **Visible for Time Records** and the field appears when filling in a time entry's details on the timesheet. You can limit it to specific **Project categories** and **Plannings**, and the **Absences** toggle also shows it on time-off entries. On a time record the field follows the person the timesheet belongs to, so an assignment made through that person, one of their tags, the entry's projects or task, or its time off type all bring the field in.
  </Accordion>

  <Accordion title="Can I restrict a custom field to a list of allowed values?">
    Yes. On a **Text** field, turn on **Use predefined values** and add the entries under **Allowed values**. In Beebole, users then pick from that list instead of typing free text.
  </Accordion>

  <Accordion title="Can I show a custom field only for some project categories?">
    Yes. Under **Visible for Projects**, add only the project categories where the field belongs, and tick the hierarchy levels it should cover. Projects in other categories won't show the field.
  </Accordion>

  <Accordion title="Can I change a custom field's type after creating it?">
    Yes. Open the field in **Settings** > **Custom Fields** and pick another **Field type** in the **Custom field details** panel. The type-specific options change with it, so review limits and defaults after switching.
  </Accordion>
</AccordionGroup>


# Custom reports: columns, charts, and matrix
Source: https://beebole.com/help/documentation/custom-reports

Build custom reports in Beebole — add columns for time, billing, and costs, group and filter data, and view results as a table, chart, or matrix.

Every report in Beebole is a custom report. You build the output by adding columns — entities like people and projects, and amounts like hours, billing, and costs — and Beebole groups and totals the data to match. The same report can display as a table, a chart, or a matrix.

<Info>
  Reports have no Save button. Every change — columns, filters, period, chart and matrix settings — is saved automatically and applied the next time the report runs.
</Info>

***

## Create a report

<Steps>
  <Step title="Open Reports">
    Click **Reports** in the sidebar.
  </Step>

  <Step title="Choose a folder">
    Select an existing folder in the Reports menu, or click **New folder** to create one.
  </Step>

  <Step title="Add the report">
    Click the **Add a report** button next to the folder name. Beebole creates a report named **New report**, opens it, and puts the name into edit mode — type a descriptive name.
  </Step>

  <Step title="Build the output">
    Add columns to define what the report shows — see the next section. The report re-runs as you change it.
  </Step>
</Steps>

***

## Add output columns

A report's definition is a row of column badges above the results. Click **Add a column…** to open the column menu, which is organized into two groups.

### Time and amounts

These columns carry the numbers. Each column type offers a choice of fields:

| Column              | Fields                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Time**            | **Hours**, **Billing**, **Hourly billing**, **Daily billing**, **Cost**, **Hourly cost**, **Daily cost**, **Margin**, **Margin %**, **Markup %**, **Days**, **Overtime (daily)**, **Overtime (period)**, **Overtime balance**, **Start time**, **End time**, **Business hours**, **Business hours remaining**, **Billable hours**, **Billable %**, **Billing ratio**, **Marked non-billable**, **Billable**, **Work from home**, **Comment**, **Status**, **ID** |
| **Expense**         | **Amount**, **Quantity**, **Expense billing**                                                                                                                                                                                                                                                                                                                                                                                                                    |
| **Task**            | **Planned** — the planned effort of tasks                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **Time & Expenses** | **Billing total**, **Cost total**, **Profit total** — cross-record totals combining time and expenses                                                                                                                                                                                                                                                                                                                                                            |
| **Period**          | **Date**, **Week**, **Month**, **Quarter**, **Year** — splits results into time buckets                                                                                                                                                                                                                                                                                                                                                                          |

<Info>
  Billing, cost, and profit fields show data once [billing rates](/help/documentation/billing) and [cost rates](/help/documentation/costs) are configured, and require a subscription that includes those features.
</Info>

### Entities

These columns define what each row represents:

* **One entry per project category and task category**, named after the category (for example, **Clients**). For these hierarchical columns you also pick a level: **Root**, a named level, or **All levels**.
* **Person** — with fields such as **Name**, **ID**, **Email**, **Description**, **Role**, and **Managed by**.
* **Time entity** — the project, task, or absence type a time entry was logged on, with **Full path**, **Name**, or **ID**.
* **Absence type** and **Expense type**.

Person, project, and task columns also offer your [tag](/help/documentation/tags) categories (with a level picker for multi-level tags) and any [custom fields](/help/documentation/custom-fields) visible on that entity type — so a custom field like a client reference or region becomes a regular report column.

### Arrange and refine columns

* **Reorder** columns by dragging their badges — order determines grouping.
* **Click a badge** to change its field, level, or category, or to **Remove** it.
* **Subtotal** — toggle subtotal rows for a grouping column; groups can collapse and expand in the table.
* **Hide empty values** — hide rows where the column is empty.
* Selecting a currency-based field adds a currency picker that applies to the whole report.

Multi-level grouping is just multiple grouping columns: for example, a tag column, then a project column, then a **Period: Month** column shows each team's projects month by month.

***

## Filter and scope the data

Filters and periods work the same on every report and are covered on the [Reports](/help/documentation/reports) page: set a date range per folder or per report, and filter by people, projects, tasks, tags, project categories or plannings, work location, or owner and status for tasks. Every condition can include (**is**) or exclude (**is not**).

What a filter covers is wider than the entity you name, so a report answers the question you meant:

* **Project**, **Project tag**, and **Project category** filters include the project's whole subtree, and also the time logged on [tasks](/help/documentation/planning) linked to those projects. Time your team booked on a task of the Acme project shows up when you filter on Acme, without adding a task filter.
* **Tag** filters follow the tag hierarchy: a filter on a parent tag also matches the tags below it. And when a tag sits on a parent project, everything under that project is covered too.
* **Task** and **Planning** filters follow the task, even when the time was recorded as project time. If a suggested entry had to be logged on a project because your timesheet does not accept time on that planning, the entry still counts as that task's time here — and an **is not** condition still excludes it.

One scope is specific to time data: a report over time records can cover working time and absences together, or narrow to **Absences only** or **Working time only** — shown as a chip above the results that you can clear at any time.

***

## Chart view

Click **Chart** next to the report name to display results as a chart. **Table** and **Chart** can be open at the same time — the chart appears above the table.

### Switching chart type

Click the chart type picker to choose from 11 chart types:

| Chart type       | Best for                                                       |
| ---------------- | -------------------------------------------------------------- |
| **Bar**          | Comparing values across categories                             |
| **Line**         | Trends over time                                               |
| **Pie**          | Showing proportions of a whole                                 |
| **Area**         | Volume trends over time                                        |
| **Stacked bar**  | Comparing totals and part-to-whole across categories           |
| **Stacked area** | Cumulative volume trends with multiple series                  |
| **Horizontal**   | Bar chart with horizontal orientation — useful for long labels |
| **Scatter**      | Correlations between two numeric columns                       |
| **Radar**        | Multi-axis comparisons across categories                       |
| **Treemap**      | Hierarchical proportions using nested rectangles               |
| **Waterfall**    | Incremental increases and decreases in a running total         |

### Configuring chart axes

Once you select a chart type, use the axis controls to map your data:

* **Label axis** — Choose the column that supplies the category labels (e.g., project name, person, time period).
* **Value axis** — Select one or more numeric columns to plot (e.g., hours, billing amount).
* **Group by** — Add a second label column to split each bar or line into separate series.
* **Swap label axis and group by** — Click the swap button to exchange the label axis and the group-by column.

<Tip>
  Beebole automatically selects the best axes when you run a report. Adjust the axis controls to override the defaults and focus on the dimensions you care about.
</Tip>

### Adjusting chart height

Drag the resize handle at the bottom of the chart area to make the chart taller or shorter. The height is saved with the report so it is restored the next time you open it.

***

## Matrix view

Click **Matrix** next to the report name to pivot the results into a grid: one dimension on each axis and a metric in every cell, with row, column, and grand totals.

The controls above the grid configure it:

* **Rows** — the dimension down the side. Click the picker to choose, and use the second picker to add an optional second row dimension (the arrows button swaps the two, and **×** clears the second one).
* **Columns** — the dimension across the top.
* **Metric** — the number shown in each cell, derived from the report's numeric columns: hours, billing, cost, margin, planned effort, expense amounts, totals, and more.
* **Heat map** — shades each cell by its value, so the largest numbers stand out at a glance.
* The swap button (**Swap rows and columns**) flips the two axes in one click.

Axes come from the report's grouping columns — people, projects, tasks, absence types, expense types, tags — or from calendar periods (day or week), which turn the matrix into a calendar-style grid. The matrix needs at least one numeric column in the report definition, and your **Rows**, **Columns**, **Metric**, and **Heat map** choices are saved with the report automatically.

To download the grid, open the report's **⋯** action menu and choose **Export** > **Matrix (CSV)**, **Matrix (Excel)**, or **Matrix (PDF)**.

***

## Organize reports in folders

Folders group related reports in the Reports menu, and each folder's period and filters apply to every report inside — see [Reports](/help/documentation/reports) for those settings.

* Click **New folder** at the bottom of the Reports menu to add a folder.
* Each folder's **⋯** action menu offers **Duplicate**, **Rename**, **Filter**, **Paste** (when you have copied a report), and **Delete**. Sharing is not in the menu — click **Share** next to the folder's name, as described on the [Reports](/help/documentation/reports#share-a-report-folder) page.
* To copy a report into another folder, open the report's **⋯** action menu, click **Copy**, then click **Paste** in the target folder's menu. **Duplicate** copies a report within its own folder, and the action menu can also move a report straight to another folder.

<Warning>
  Deleting a folder also deletes the reports inside it. Move reports you want to keep into another folder first using **Copy** and **Paste**.
</Warning>

***

## Related content

<CardGroup>
  <Card title="Reports" icon="chart-simple" href="/help/documentation/reports">
    Folders, periods, filters, sharing, exports, and the built-in reports such as Budget Status.
  </Card>

  <Card title="Billing Rates" icon="file-invoice-dollar" href="/help/documentation/billing">
    Configure billing rates so billing and margin columns show data.
  </Card>

  <Card title="Cost Rates" icon="money-bill-trend-up" href="/help/documentation/costs">
    Configure cost rates so cost and profit columns show data.
  </Card>

  <Card title="Custom Fields" icon="list-check" href="/help/documentation/custom-fields">
    Define custom fields and use them as report columns.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I need to save my report?">
    No. Beebole saves every report change automatically — columns, filters, period, chart type, and matrix settings. There is no Save button; when you reopen a report, it runs with your latest configuration on current data.
  </Accordion>

  <Accordion title="Can other people see my reports?">
    Only if you share them. Report folders in Beebole belong to the person who created them, and you share a whole folder — click **Share** next to the folder's name and pick people or tags. Whoever opens a report, the results only include the projects and people that person's [role](/help/documentation/roles-authorisations) allows.
  </Accordion>

  <Accordion title="How many grouping levels can I use?">
    You can add multiple grouping columns — for example a tag, then a project, then a month column — and Beebole nests the rows in that order, with optional subtotals per level. There is no hard limit, but reports with many levels become harder to read.
  </Accordion>

  <Accordion title="Do custom fields appear in reports automatically?">
    Yes. Any [custom field](/help/documentation/custom-fields) visible on people, projects, or tasks is available as a field when you add a column for that entity — no extra setup needed in the report itself.
  </Accordion>

  <Accordion title="Is the chart or matrix saved with the report?">
    Yes. Beebole stores which views are open, the chart type, axis settings, and height, and the matrix rows, columns, metric, and heat-map choice with each report — everything is restored the next time you open it.
  </Accordion>
</AccordionGroup>


# Data exports: CSV, Excel, PDF, and JSON
Source: https://beebole.com/help/documentation/data-exports

Export Beebole report data as Excel, CSV, PDF, JSON, and more for offline analysis, payroll processing, or sharing with clients and stakeholders.

Beebole lets you export report data so you can analyze it offline, share it with stakeholders who do not use Beebole, or integrate it into external tools. Exports capture the exact data shown in your report, including all applied filters and groupings.

***

## Export formats

Beebole exports report data in the following formats, all available from the report's **Export** submenu:

| Format                                                 | Best for                                                                               |
| ------------------------------------------------------ | -------------------------------------------------------------------------------------- |
| **Excel (XLSX)**                                       | Sharing with colleagues, creating formatted spreadsheets, or further analysis in Excel |
| **CSV**                                                | Importing into databases, BI tools, or any software that reads plain text files        |
| **TSV**                                                | Tab-separated data for tools that expect tabs instead of commas                        |
| **JSON**                                               | Feeding scripts or applications that consume structured data                           |
| **PDF**                                                | Sending a fixed, print-ready copy of the report table                                  |
| **Chart (PNG)**                                        | Saving the report's chart as an image for slides or documents                          |
| **Matrix (CSV)**, **Matrix (Excel)**, **Matrix (PDF)** | Exporting the report's matrix view                                                     |

Table exports include the report's columns and respect the filters applied to the report.

### Excel and PDF specifics

* **Excel (XLSX)** files open with every column already sized to its contents. Beebole measures each cell of every row, not just the headers, so long project names, comments, and custom field values are readable straight away — with a cap so one very long value cannot push the rest of the sheet off screen.
* **PDF** files carry their own embedded font, so accented Latin characters, Cyrillic and Greek alphabets, currency symbols, arrows, and mathematical signs all print correctly instead of coming out as empty boxes. A character outside that range prints as a question mark.
* A report with more than six columns is laid out in landscape, and a table still too wide for one page continues on the following pages with the first column repeated — so every row stays identifiable across the split.

If an export cannot be produced, Beebole says so instead of downloading a broken file. A PDF that is too wide to lay out reports **PDF export failed. Try fewer columns or another format.**

***

## Exporting a report

<Steps>
  <Step title="Open Reports">
    Click **Reports** in the sidebar and open the folder that contains your report. You can export any [report](/help/documentation/reports), including your [saved custom reports](/help/documentation/custom-reports).
  </Step>

  <Step title="Open the report's action menu">
    Hover over the report in the list and click the **⋯** action menu next to its name.
  </Step>

  <Step title="Choose Export and a format">
    Click **Export**, then pick a format from the submenu — for example **Excel (XLSX)** or **CSV**.
  </Step>

  <Step title="Download the file">
    Beebole runs the report if it is not already open, then your browser downloads the file. The filename includes the report name, plus its period when one is set.
  </Step>
</Steps>

<Info>
  The exported file contains exactly the data displayed in your report. If you need different data, adjust your filters or columns before exporting.
</Info>

***

## What is included in exports

Exports contain:

* All rows visible in the report, respecting applied filters
* All selected columns, including financial data (billing, cost, profit) and custom field values
* The period appears in the export filename

<Warning>
  Exports respect user permissions. If a user cannot see certain projects or people in reports, that data is excluded from their export as well.
</Warning>

***

## Tips for working with exported data

<Tip>
  When opening a CSV file in Excel, use the **Import** function rather than double-clicking the file. This ensures that special characters, dates, and number formats are handled correctly.
</Tip>

* **Filter before exporting** — Apply all necessary filters in Beebole before exporting to reduce the amount of post-processing needed in your spreadsheet.
* **Use consistent naming** — Save your reports with descriptive names so exported files are easy to identify later.
* **Include metadata columns** — Add project codes, person emails, or custom field values to your report columns before exporting if you plan to merge the data with other systems.

***

## Alternatives for recurring exports

If you need to pull Beebole data into a spreadsheet regularly, consider using a direct connection instead of manual exports:

* [Excel add-in](/help/documentation/excel-addin) — Link Excel worksheets to your saved Beebole reports and refresh the data without manual downloads
* [Google Sheets add-on](/help/documentation/gsheets-addon) — Link Google Sheets to your saved Beebole reports and refresh the data from a sidebar

These tools let you save a report once in Beebole and refresh its data on demand, saving time on repetitive exports.

***

## GDPR and personal data

### Account deletion

If you need to delete the organization and all associated personal data — for example, to honor a right-to-erasure request — go to **Settings** > **Delete Account**.

<Warning>
  Confirming the deletion schedules your account for deletion: all personal data, time records, projects, and configuration are permanently deleted after a 7-day grace period, and all admins are notified by email. Export any data you need to retain before proceeding.
</Warning>

During the grace period, Beebole displays a banner showing who scheduled the deletion and how long remains. An admin can click **Cancel deletion** — in the banner or on the **Delete Account** page — to stop the process and keep the account.

<Info>
  For individual data deletion requests (e.g., removing a specific person's data), remove that person from your Beebole account and delete their time entries and profile. Contact [support@beebole.com](mailto:support@beebole.com) if you need assistance handling a specific GDPR request.
</Info>

***

## Related content

<CardGroup>
  <Card title="Audit Trail" icon="clock-rotate-left" href="/help/documentation/audit-trail">
    Review a complete log of changes before exporting for compliance.
  </Card>

  <Card title="Account Settings" icon="gear" href="/help/documentation/account-settings">
    Configure organization-wide settings, including deleting your organization.
  </Card>

  <Card title="Custom Reports" icon="table" href="/help/documentation/custom-reports">
    Build and save the exact report you need before exporting it.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I export all data from my account at once?">
    Exports are based on the report you have configured. To export all time data, create a report with no filters and a date range covering your entire account history, then export it.
  </Accordion>

  <Accordion title="Are exported files limited in size?">
    Beebole exports all matching data. For very large datasets, the download may take a moment. If performance is an issue, narrow your date range or apply additional filters.
  </Accordion>

  <Accordion title="Can I export expense data?">
    Yes. Create a report, add an **Expense** column (such as **Amount** or **Quantity**), and export it. Expense data supports the same export formats as time data.
  </Accordion>

  <Accordion title="Why do some characters print as question marks in a PDF export?">
    Beebole's PDF exports embed a font covering the Latin, Greek, and Cyrillic alphabets, plus currency, arrow, and mathematical symbols. Anything outside that set — for example Chinese, Japanese, or Arabic text in a project name or comment — prints as a question mark. Export those reports as **Excel (XLSX)** or **CSV** instead, which carry any character.
  </Accordion>

  <Accordion title="Do exports include budget information?">
    Yes. Open the **Budget Status** report and use its **Export** button — budget progress data exports in the same formats as other reports.
  </Accordion>
</AccordionGroup>


# Desktop app: draft time entries from your activity
Source: https://beebole.com/help/documentation/desktop-app

Install the Beebole desktop app on macOS, Windows, or Linux and turn what you work on into draft time entries — private until you accept them.

The Beebole desktop app is a companion application for macOS, Windows, and Linux that drafts time entries from what you work on. Activity tracking is opt-in — nothing is watched or recorded until you explicitly turn it on. When tracking is on, the app reads only application names and window titles — never your screen or audio — and stores them on your machine only. Beebole turns that activity into [suggested time entries](/help/documentation/ai#suggested-time-entries), and only the entries you accept reach your timesheet.

<Info>
  Activity data stays on the device, is never shared with anyone, and is deleted after a week. Suggestions are private to you until you accept them.
</Info>

***

## Downloading and installing

<Steps>
  <Step title="Open the Assistant page">
    Click **Assistant** in the sidebar and scroll to the **Desktop app** section.
  </Step>

  <Step title="Download the installer">
    Pick your platform next to **Download**: **macOS** (`.dmg`), **Windows** (`.exe`), or **Linux** (`.AppImage` or `.deb`). You can also download the current build directly:

    | Platform         | Direct download                                                                                            |
    | ---------------- | ---------------------------------------------------------------------------------------------------------- |
    | macOS            | [beebole-desktop-macos.dmg](https://app.beebole.com/downloads/desktop/beebole-desktop-macos.dmg)           |
    | Windows          | [beebole-desktop-windows.exe](https://app.beebole.com/downloads/desktop/beebole-desktop-windows.exe)       |
    | Linux (AppImage) | [beebole-desktop-linux.AppImage](https://app.beebole.com/downloads/desktop/beebole-desktop-linux.AppImage) |
    | Linux (deb)      | [beebole-desktop-linux.deb](https://app.beebole.com/downloads/desktop/beebole-desktop-linux.deb)           |

    The links always serve the latest version — the same files the **Assistant** page offers.
  </Step>

  <Step title="Install and launch">
    Run the installer and open the app. Signing in from the app hands off to your browser — complete the sign-in there with any method, [passkeys and SSO included](/help/documentation/authentication), and you return to the app signed in. Use **Open the desktop app** on the **Assistant** page in your browser to bring the app up anytime.
  </Step>
</Steps>

<Info>
  Beebole is registering the app with Apple and Microsoft, so installing will soon be seamless. Until then the installers are unsigned and your system warns you: on macOS, after the first blocked launch, allow the app under **System Settings** → **Privacy & Security**; on Windows, choose **More info** → **Run anyway**.
</Info>

***

## Turning tracking on

The app never starts watching on its own. After your first hour with the app, a dialog titled **Automatic timesheet suggestions** opens when you view your timesheet, explaining what would be observed (which applications and windows you use), what stays on your computer, and what is sent to your account — only the resulting suggestions: project, task, and duration.

* Click **Enable tracking** to turn it on. Suggestions start appearing after a few hours of activity.
* Click **No thanks** to keep tracking off — nothing is recorded, and Beebole never asks again.
* Turn tracking on, pause it, or switch it back off anytime from the Beebole icon in the menu bar (macOS) or system tray (Windows/Linux). The [Beebole AI](/help/documentation/ai) page also shows whether tracking is on or off and lets you switch it.

<Info>
  On macOS, Beebole asks for **Screen Recording** access so it can read window titles — it never records your screen or audio. If access was refused, suggestions are less precise; the Beebole AI page warns you and opens the right System Settings pane.
</Info>

***

## How suggestions work

With tracking on, the app watches which applications and windows you actively use and how long. Beebole groups that activity into draft time entries and shows them in the **Suggested entries** tray above your timesheet, badged **Desktop**.

* **Accept**, **Accept all**, or **Dismiss** each suggestion — nothing is logged without your say-so.
* Click **Why?** on a suggestion to see the activity behind it. The details live on the machine that captured them; on another device Beebole shows **These details are only available in the desktop app, on the computer where the activity was tracked.**
* In the timesheet's [calendar view](/help/documentation/timesheets#calendar-view), suggestions appear as ghost entries you can drag into a time slot.

***

## Related content

<CardGroup>
  <Card title="Beebole AI" icon="sparkles" href="/help/documentation/ai">
    All of Beebole's AI features, including where suggestions come from.
  </Card>

  <Card title="Browser extension" icon="puzzle-piece" href="/help/documentation/browser-extension">
    Draft entries from the websites you choose — no desktop app required.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Where suggested entries appear and get accepted.
  </Card>

  <Card title="Mobile app (PWA)" icon="mobile" href="/help/documentation/mobile">
    Install Beebole on your phone or tablet from the browser.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What does the Beebole desktop app track?">
    Nothing until you enable tracking. Once on, it reads only application names and window titles — never your screen or audio. The captured activity is stored on your machine, never shared with anyone, and deleted after a week. It exists solely to draft time entry suggestions for you.
  </Accordion>

  <Accordion title="Can my manager see my desktop activity?">
    No. Activity stays on your device, and the suggestions built from it are private to you. Your manager only ever sees the time entries you explicitly accept onto your timesheet — the same as entries you type by hand.
  </Accordion>

  <Accordion title="Which platforms does the desktop app support?">
    macOS (`.dmg`), Windows (`.exe`), and Linux (both `.AppImage` and `.deb` packages). Download the installer from the **Assistant** page in Beebole.
  </Accordion>

  <Accordion title="Why does my system warn me when installing the app?">
    The installers are not yet signed with Apple and Microsoft while Beebole completes their registration processes. On macOS, allow the app under **System Settings** → **Privacy & Security** after the first blocked launch; on Windows, choose **More info** → **Run anyway**.
  </Accordion>

  <Accordion title="Do I need the desktop app to use the browser extension?">
    No. The Beebole browser extension connects directly to your account with your API key and works on its own. Use the desktop app if you also want activity outside the browser turned into suggestions.
  </Accordion>
</AccordionGroup>


# Excel Add-in: Link Sheets to Saved Reports
Source: https://beebole.com/help/documentation/excel-addin

Link Excel worksheets to your saved Beebole reports and refresh time tracking, billing, and project data with one click — no manual exports.

The Beebole Excel add-in links worksheets in your Excel workbook to your saved Beebole reports. Instead of exporting files and importing them by hand, you save a report once in Beebole, link a sheet to it, and refresh the data whenever you need the latest figures.

<Info>
  The add-in loads saved reports. Build and save the report you need in Beebole first — its columns, filters, and period all come from the report configuration, not from the add-in.
</Info>

***

## How the add-in works

Each worksheet links to one saved Beebole report. When you refresh, the add-in runs the report in your Beebole account, clears the linked sheet, and writes a header row followed by the report data. The links are stored inside the Excel file, so they travel with the workbook when you share it.

The add-in connects with your Beebole API key — you never enter a password. The key is stored privately on your device and is never saved inside the Excel file.

***

## Installing the add-in

<Steps>
  <Step title="Open Excel's add-in store">
    In Excel, open the Office Add-ins store from the ribbon. You can also find the Beebole add-in on Microsoft AppSource.
  </Step>

  <Step title="Add the Beebole add-in">
    Search for **Beebole** and add it to Excel.
  </Step>

  <Step title="Open the task pane">
    Click the **Beebole Reports** button on the **Home** tab of the ribbon to open the Beebole task pane.
  </Step>
</Steps>

***

## Connecting with your API key

The first time you open the task pane, the add-in asks for your Beebole API key.

<Steps>
  <Step title="Copy your API key from Beebole">
    In Beebole, click the button with your initials at the bottom of the sidebar, then **API Key**. Click **Copy**.
  </Step>

  <Step title="Paste the key into the add-in">
    In the task pane, paste the key into the **API Key** field and click **Connect**.
  </Step>
</Steps>

<Info>
  The API key gives the add-in the same access as your Beebole account: you only see the saved reports — and the data — that your [role and authorizations](/help/documentation/roles-authorisations) allow. The **Reset** button next to your API key in Beebole revokes the current key and generates a new one.
</Info>

***

## Linking a sheet to a report

<Steps>
  <Step title="Open the add-link form">
    In the task pane, click **+ Add link** under **Beebole reports linked**.
  </Step>

  <Step title="Pick a report">
    In the **Add Report Link** form, select one of your saved Beebole reports in the **Report** field.
  </Step>

  <Step title="Pick a sheet">
    Choose an existing sheet in the **Worksheet** field, or type a name in **New sheet name** to create one.
  </Step>

  <Step title="Confirm">
    Click **Add Link**. The link appears in the **Beebole reports linked** table.
  </Step>
</Steps>

To remove a link, click the **✕** button (**Remove link**) next to it in the table. This removes the link only — the sheet and its current data stay in place.

***

## Refreshing your data

In the **Refresh** section of the task pane:

* **Refresh This Sheet** — refreshes the sheet you are currently viewing.
* **Refresh All** — refreshes every linked sheet in the workbook.

The add-in also refreshes automatically: every linked sheet refreshes when you open the task pane, and in Excel versions that support workbook-open events, linked sheets refresh in the background each time you open the file.

<Warning>
  Refreshing clears the linked sheet before writing the new data. Anything you typed into that sheet — formulas, notes, formatting — is removed. Keep your own calculations and charts in separate sheets that reference the linked one.
</Warning>

If a linked report no longer exists in Beebole, the add-in writes an error message to the sheet so you know the link needs updating.

***

## Updating or removing your API key

Click **Update API** at the top of the task pane to open the key settings:

* Paste a new key into **New API Key** and click **Update API Key** to switch accounts or replace a reset key.
* Click **Remove API Key** to delete the saved key from your device. You will need to enter a key again to use the add-in.

***

## Related content

<CardGroup>
  <Card title="Reports" icon="chart-line" href="/help/documentation/reports">
    Understand report dimensions, filters, grouping, and columns in Beebole.
  </Card>

  <Card title="Custom Reports" icon="chart-bar" href="/help/documentation/custom-reports">
    Build and save the reports your linked sheets will load.
  </Card>

  <Card title="Google Sheets Add-on" icon="table" href="/help/documentation/gsheets-addon">
    Link Google Sheets to your saved Beebole reports the same way.
  </Card>

  <Card title="Data Exports" icon="download" href="/help/documentation/data-exports">
    Download one-off exports in Excel, CSV, PDF, and other formats.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I configure columns and filters inside the add-in?">
    No. The Beebole Excel add-in loads saved reports exactly as they are configured in Beebole. To change the columns, filters, or period of the data in a sheet, edit the saved report in Beebole and refresh the sheet.
  </Accordion>

  <Accordion title="What happens when I share the workbook with someone else?">
    The sheet-to-report links are stored inside the Excel file and travel with it. Your API key does not — it stays on your device. The other person sees the last refreshed data, and to refresh it themselves they connect with their own Beebole API key, which shows only the reports their account can access.
  </Accordion>

  <Accordion title="Does refreshing overwrite my formulas?">
    Yes. A refresh clears the linked sheet completely before writing the report data. Place your own formulas, pivot tables, and charts in separate sheets that reference the linked sheet, so they survive every refresh.
  </Accordion>

  <Accordion title="What happens if the linked report is deleted in Beebole?">
    The add-in writes an error message to the sheet telling you the linked report no longer exists. Remove the link and create a new one pointing to another saved Beebole report.
  </Accordion>
</AccordionGroup>


# Expense tracking: categories, records, and reports
Source: https://beebole.com/help/documentation/expenses

Track project and employee expenses in Beebole — create expense categories, log amounts or quantities, and report on spending alongside time.

Beebole's expense tracking lets you record spending — travel, meals, mileage, equipment — against the projects and people it belongs to. Expenses are grouped into categories you define, can carry a billing markup, and appear in reports and budgets alongside tracked time.

<Info>
  Expense tracking is not included in every Beebole plan. If you don't see expense features in your account, review your plan and add-ons on the [Subscription](/help/documentation/subscription) page.
</Info>

***

## How expenses work in Beebole

Expense tracking has two building blocks:

* **Expense types** — The categories of spending your organization recognizes (Travel, Meals, Equipment, …). You create them once in Beebole's settings.
* **Expense records** — The individual entries: a date, a category, an amount or quantity, and an optional note. You log them on the **Expenses** panel of a person or a project.

Every expense record must be linked to at least a person or a project — it can be linked to both, so you know who incurred the expense and which project it is charged to.

***

## Creating expense types

<Steps>
  <Step title="Open the Expense Type settings">
    Click the button with your initials at the bottom of the sidebar, then go to **Settings** > **Expense Types**.
  </Step>

  <Step title="Add an expense type">
    Click **Add Expense Type**, enter a **Name** (e.g., "Travel", "Meals", "Mileage"), then click **Add Expense Type** again to confirm.
  </Step>

  <Step title="Configure the Details panel">
    In the expense type's **Details** panel, check **Currency** if entries of this type are monetary amounts; leave it unchecked for quantity-based expenses such as kilometers or meals. Changes are saved automatically.
  </Step>
</Steps>

For currency-based expense types, two more settings appear in the **Details** panel:

| Setting                 | What it does                                                                                                                                                                                    |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Billing markup in %** | The percentage applied to the expense amount when calculating the billed amount in reports. The billed amount is `expense amount × markup / 100`, so a markup of 100 bills the expense at cost. |
| **Impacts budget**      | When enabled, expenses of this type count toward project [budgets](/help/documentation/budgets).                                                                                                |

***

## Controlling who can use an expense type

Each expense type has a **Who has access?** panel where you assign it to specific people, tags, or projects — for example, mileage reimbursement for field staff only.

The organization-wide default is the **Show all expenses** toggle in your organization's **Show or hide by default** panel: when it's on, every expense type is available unless you exclude it; when it's off, an expense type is only available where you assign it. See [Assignments](/help/documentation/assignments) for the full availability model.

***

## Logging expenses

You log expense records on the **Expenses** panel of a person or a project:

<Steps>
  <Step title="Open the person or project">
    Click **People** or **Projects** in the sidebar and select the person who incurred the expense or the project it is charged to.
  </Step>

  <Step title="Open the Expenses panel">
    In the detail panel, open the **Expenses** panel.
  </Step>

  <Step title="Add the expense">
    Click **Add**, then pick a category with **Select expense category**. Beebole creates the record, dated today, and saves it automatically.
  </Step>

  <Step title="Fill in the details">
    Adjust the **Date**, enter the **Amount** (for currency-based categories, with its own currency) or **Quantity** (for unit-based categories), link the **Project** — or the **Person** when you started from a project — and add an optional **Note**. Every change is saved automatically.
  </Step>
</Steps>

To remove an expense record, open it in the **Expenses** panel and click the trash button (**Delete**).

<Info>
  What a person can see and do in the **Expenses** panel depends on the **Expense records** permission of their role. See [Roles and authorizations](/help/documentation/roles-authorisations).
</Info>

***

## Expenses in reports

To analyze spending, click **Reports** in the sidebar and add an **Expense** column to a report. You can group expense records by expense type, person, project, tag, or period, and filter them like any other report. Expense columns include **Amount**, **Quantity**, and **Expense billing** — the billed amount with the category's markup applied (in the report matrix they appear as **Expense amount** and **Expense quantity**). See [Reports](/help/documentation/reports) for folders, charts, sharing, and exports.

For expense types with **Impacts budget** enabled, expense amounts also count toward the project's budget consumption, alongside time-based costs — track them in the **Budget Status** report described in [Budgets](/help/documentation/budgets).

***

## Related content

<CardGroup>
  <Card title="Budgets" icon="chart-bar" href="/help/documentation/budgets">
    Set billing, cost, and hours targets on projects and monitor consumption — including expenses.
  </Card>

  <Card title="Reports" icon="chart-line" href="/help/documentation/reports">
    Build, filter, and share reports on time and expense records.
  </Card>

  <Card title="Assignments" icon="user-check" href="/help/documentation/assignments">
    Control which expense types, projects, and absence types are available to each person.
  </Card>

  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Create the projects that expenses and budgets are tracked against.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do expenses go through the approval workflow?">
    No. Beebole's approval workflow covers timesheets and time-off requests. Expense records are not submitted or approved — anyone with the **Expense records** permission can add and edit them directly.
  </Accordion>

  <Accordion title="Can I track mileage or other unit-based expenses?">
    Yes. Leave the **Currency** setting unchecked on the expense type, and Beebole records a **Quantity** instead of a monetary amount — useful for kilometers, meals, or any per-unit expense.
  </Accordion>

  <Accordion title="How does the billing markup work?">
    Each currency-based expense type has a **Billing markup in %** setting. In reports, the **Expense billing** column shows `expense amount × markup / 100` — so a markup of 100 bills the expense at cost, and a markup of 120 adds 20%.
  </Accordion>

  <Accordion title="Can I restrict who can log certain expense types?">
    Yes. Use the expense type's **Who has access?** panel in Beebole to assign it to specific people, tags, or projects, and the organization's **Show all expenses** toggle to set the default for everyone else.
  </Accordion>

  <Accordion title="What currency is an expense recorded in?">
    The default is your own currency setting; you can change it on the **Amount** field.
  </Accordion>
</AccordionGroup>


# Gantt chart: scheduling tasks on a timeline
Source: https://beebole.com/help/documentation/gantt

Schedule tasks on Beebole's Gantt chart — drag bars to set dates, link dependencies, customize columns, and spot overload with the workload heatmap.

Beebole's Gantt chart displays your [tasks](/help/documentation/planning) as bars on a timeline, so you can see start and end dates, sequence work with dependencies, and spot scheduling overload at a glance. It is one of the four views of the **Planning** page, alongside the [Kanban board](/help/documentation/kanban), the [Staffing view](/help/documentation/staffing), and the [List view](/help/documentation/task-list) — all show the same tasks, so a change in one view appears instantly in the others.

***

## Opening a Gantt view

<Steps>
  <Step title="Open the Planning page">
    Click **Planning** in the sidebar. Pick the planning you want at the top of the page.
  </Step>

  <Step title="Select a Gantt view">
    Click a Gantt view tab above the task list. To create another one, click **Add a view** and select **Gantt chart** — each view keeps its own columns, grouping, and scale.
  </Step>
</Steps>

***

## Reading the timeline

Each task with dates appears as a horizontal bar running from its start date to its end date, in the task's color. Task names show their full project and task path, so tasks with similar names are easy to tell apart. A vertical line marks today, and the timeline extends as you scroll — right into the future, left into the past — with a **Today** button to jump back to the current date.

Hover any bar for a rich tooltip: the full dates, the task name, its project with parents, the owner, the planned hours or days and allocation percentage, plus a hint about what **⌘** does on the chart.

Where one month ends and the next begins, the timeline draws a vertical line across the chart and a pill above it with the month and year, so you keep your bearings while scrolling a long stretch of days or weeks.

### Choosing the period

Open the **⋯** menu on the active view tab and use **Period** to choose how the timeline runs:

* **Infinite by day** or **Infinite by week** — the endless scrolling timeline, at day or week granularity.
* **Day**, **Week**, **2 weeks**, **3 weeks**, **4 weeks**, or **6 weeks** — the chart fits that window to your screen and lists only the tasks that fall inside it (parents and recurring series are kept).

With a fixed window, the view pages one period at a time: swipe or scroll sideways and it snaps cleanly onto the next or previous window, and the period containing today is always reachable.

With a fixed period, tasks that start before or end after the window are drawn cut off, with a dashed edge and a chevron — click it to jump to the hidden start or end date. Cut edges can't be resized, since the date they would move isn't on screen.

<Info>
  Tasks without dates still appear as rows in the task list — they just have no bar yet. See below for how to schedule them directly on the timeline.
</Info>

### Zooming in and out

Click a cell in the timeline header to zoom one level into that period: from the endless timeline down to the multi-week window you last chose (when it is longer than a week), then to a single week, then to a single day. Hovering the cell first previews the stretch of timeline the click will fill.

To go the other way, use the zoom-out button next to the view tabs — it names the level it will take you back to (**Day**, **Week**, **2 weeks** and so on, or ∞ for the endless timeline).

***

## Scheduling tasks on the timeline

* **Give a task dates** — In the row of a task that has no dates yet, click the timeline to create a bar spanning that cell, or click and drag to draw the exact period you want. Dragging on the row of a task that already has dates scrolls to its bar and flashes it instead.
* **Move a task** — Drag its bar left or right. The duration is preserved.
* **Resize a task** — Drag the left or right edge of the bar to change the start or end date.
* **Work on several tasks at once** — Select several bars, then drag them together to reschedule the whole group in one move, hold **⌘** (Alt on Windows/Linux) while dragging to drop dated copies, or grab any selected bar's edge to shift every selected bar's dates by the same amount. Press **Delete** (or **Backspace**) to remove the whole selection at once. Each batch is a single undo step.

While you drag, Beebole shows the new dates live — and tasks linked by [dependencies](#task-dependencies) follow the drag on screen before you drop. Changes are saved automatically when you release the bar.

If the task's planned time no longer fits the new period, the task detail panel flags the overflow and offers one-click fixes — see [scheduling dates and planned time](/help/documentation/planning#scheduling-dates-and-planned-time).

***

## Giving a task hours

A task normally runs over whole days. To pin it to exact times instead, open the task's **Dates** panel and uncheck **All day** — the hint on the checkbox says it plainly: *The task runs over whole days. Uncheck to set the hours it starts and ends.*

**Start time** and **End time** fields appear, pre-filled from the owner's own working hours, and the task now stretches on the clock rather than by whole days:

* Dragging, resizing, splitting, and copying the task keep its hours.
* Typing a figure in **Planned** reflows the task to the exact minute the owner's calendar can hold that work — skipping their scheduled breaks, days off, public holidays, and time off — and rolls to the next working day only when the current one runs out of hours.
* The capacity a timed task consumes is measured on the hours it actually spans, so a two-hour task no longer counts as a whole day against its owner's [workload](#workload-heatmap).
* On the [Staffing](/help/documentation/staffing) timeline, the bar is drawn at its real position inside the day column, with non-working stretches hatched behind it.

Times that fall outside the owner's working hours are highlighted in the **Dates** panel, with a tooltip naming the reason — **Owner's schedule starts at …**, **Owner's schedule ends at …**, **Owner's schedule pauses from … to …**, or **Owner's schedule has no working hours that day**. When a day simply cannot hold the planned work, Beebole says **Not enough working hours on …**.

<Info>
  Moving the anchored edge of a period slides the whole period instead of collapsing it — a task set to run 08:00–12:00 and moved to start at 18:00 becomes 18:00–22:00.
</Info>

<Tip>
  A parent task has no dates panel of its own — its dates are the span of its subtasks. Set hours on the subtasks instead.
</Tip>

***

## Task dependencies

Dependencies sequence tasks: a dependent task is expected to follow the tasks it depends on. Dependency links are drawn between the bars on the timeline, color-matched to the tasks at each end, and they follow the bars live while you drag. The lines route around the bars they pass and around group header rows, so a link stays readable in a crowded chart instead of running straight through a bar.

### Drawing a link on the timeline

Hover a bar and a chain-link handle appears on the half of the bar you are pointing at — the start or the end. Both work the same way, in opposite directions, and the handle's tooltip says which one you have: **Link the end of this task**, then *Drag onto a task, or click the tasks that start after it (hold ⌘ for several)*.

* **Drag** the handle onto another task and release to create the link.
* **Hold ⌘ as you release** to keep the handle armed, so you can chain several tasks one after another without grabbing it again.
* **Release the handle where it is** and it stays armed instead: click tasks in the list to link them, and click again to finish.
* While a handle is armed, tasks already linked to it wear a broken-chain mark — click one to remove that link.

### Adding dependencies from the column

Dependencies are also managed in the **Dependencies** column — add it from the **Columns** menu if your view doesn't show it.

<Steps>
  <Step title="Click the task's Dependencies field">
    Click the **Dependencies** cell of the task that should come after. This activates dependency mode.
  </Step>

  <Step title="Pick its dependencies">
    Click the task it depends on directly in the list — hold **⌘** to select several — or type the row numbers (from the **Row #** column) into the field, separated by commas.
  </Step>

  <Step title="Finish">
    Click elsewhere or press **Esc** to leave dependency mode. Arrows now link the bars on the timeline.
  </Step>
</Steps>

To remove a dependency, edit the row numbers in the **Dependencies** field. A task cannot depend on itself.

### How dependent tasks move

Open the **⋯** menu on the active view tab and hover over **Dependent tasks** to choose what happens to dependent tasks when you move a task they depend on. The submenu is titled **Dependent tasks movement options**, and each option animates on hover so you can see the behavior before picking it:

| Option       | Behavior when the predecessor moves                                      |
| ------------ | ------------------------------------------------------------------------ |
| **Free**     | Dependent tasks stay where they are                                      |
| **Pushing**  | Dependent tasks are pushed later when the predecessor would overlap them |
| **Together** | Dependent tasks move along with the predecessor, keeping their distance  |

The setting belongs to the planning, not to the view, so it applies to every Gantt and Staffing view of that planning. The same submenu is available from a [Staffing view](/help/documentation/staffing) tab.

Whichever option is active, a task that gets rescheduled lands on dates its own owner actually works: its start rolls forward (or back) to the next working day on that person's [work schedule](/help/documentation/work-schedule), and its end shifts by the same amount. Moving a task never changes its planned hours — the period is refitted to hold the same working time at its new position.

***

## Planned time

The **Planned** column shows each task's planned work. The small button in the column header toggles the unit (**Planned in hours or days**). A parent task shows the total planned time of its subtasks.

Planned time is what the [workload heatmap](#workload-heatmap) compares against each person's capacity, derived from their [work schedule](/help/documentation/work-schedule) minus their absences.

***

## Workload heatmap

When the chart is grouped, each group header row carries one cell per period (day or week, following the current **Period** granularity). What the cell draws depends on what you grouped by.

* **Grouped by Owner** — Each owner's row shows a load bar comparing that person's planned time to their capacity for the period. The bar fills red while capacity remains, turns green when the capacity is met exactly, and turns purple as soon as the person is booked beyond it, with the overload share in a darker purple.
* **Grouped by anything else** — For project categories, tag categories, statuses, and the "no owner" bucket of a grouping by owner, the cell shows the group's total planned time as a figure above a bar scaled to the busiest period on that row. A capacity ratio has no meaning for a group of people, so none is drawn. Planned time that has no owner yet appears as a small red badge in the corner of the cell.
* **Without grouping** — A single load bar sits under each day or week number in the timeline header, rolling up everyone. Click it to step the scroll through the rows driving that period's load.
* **Hover for details** — A tooltip names the period, then the planned time against capacity (for example `Planned: 32h / Capacity: 40h (80%)`), and adds a line per overloaded person with their own figures.

Use the heatmap to spot the weeks where an owner is overbooked, then move bars or planned time to rebalance.

***

## Columns

The left panel of the Gantt chart is a configurable table. Open the **⋯** menu on the active view tab and hover over **Columns** to show or hide columns. **Row #** and **Task Name** are always visible — a new Gantt view starts with just those two.

| Column               | What it shows                                                     |
| -------------------- | ----------------------------------------------------------------- |
| **Row #**            | Sequential row number, used to type dependencies                  |
| **Task Name**        | The task name and hierarchy controls                              |
| **Dependencies**     | Row numbers of the tasks this task depends on                     |
| **Dates**            | The task's start and end dates                                    |
| **Owner**            | The task's owner                                                  |
| **Potential owners** | The people or tags the task is assigned to                        |
| **Planned**          | Planned time, in hours or days                                    |
| **Occupation**       | The share of the owner's capacity the task takes, as a percentage |
| **Status**           | The task's current status                                         |
| **Tags**             | Tags applied to the task                                          |

In addition, one column per [project category](/help/documentation/projects) is available, showing the projects from that category linked to each task.

### Reordering, resizing, and sorting columns

* **Reorder** — Drag a column header sideways and drop it where you want it. **Row #** and **Task Name** stay first and can't be moved.
* **Resize** — Drag the right edge of any column header. Widths are saved with the view.
* **Sort** — Click a column header to sort the rows by that column, click again to reverse the direction, and a third time to return to the manual order. An arrow on the header shows which column is sorted and which way. The header's own menu names the same actions: **Sort ascending**, **Sort descending**, and **Hide column**.

Sorting and grouping work together: with a grouping active, the sort applies inside each group, and subtasks always stay under their parent. While a sort is active, the **Row #** column shows plain sequence numbers instead of the handles used to drag rows into a manual order — click the **Row #** header, or **Manual order** in its menu, to get them back.

<Tip>
  For long lists, the [List view](/help/documentation/task-list) shows these same columns as a full-width sortable table, without the timeline taking up half the screen.
</Tip>

### Editing in the columns

The value cells are controls, so most task fields can be set without opening the task:

* **Status** — Step to the previous or next status with the chevrons, or click the status name to pick any of them.
* **Owner** — Remove the current owner from its badge, or use the person button on an empty cell to pick someone (**Select the owner**).
* **Dates** — Click the cell to open the task's period editor.
* **Planned** and **Occupation** — Type the figure straight into the cell.
* **Potential owners**, **Tags**, and each project category column — Click the **+** button for a small editor with the current badges, removable, and a picker to add more.

To change several tasks in one go, **⌘+Click** (Ctrl+Click on Windows) rows to build a selection, or **Shift+Click** for a range, then change a value on any row inside the selection: every selected task gets it, as a single undo step. **Esc** clears the selection and **Delete** removes every selected task.

<Tip>
  When a task's bar sits outside the visible timeline, hovering its **Dates** cell shows an arrow pointing left or right — click it (**Show in the chart**) to scroll straight to the bar.
</Tip>

***

## Row grouping

Open the **⋯** menu on the active view tab and hover over **Group by** to restructure the list without changing any task data:

* **Owner** — One group per task owner
* **Status** — One group per status
* **Project categories** — Group by a level of any project category
* **Tag categories** — Group by a level of any [tag](/help/documentation/tags) category

Select **None** to remove grouping. With a grouping active, **Show all groups** also displays empty groups — useful to see owners or statuses that currently have no tasks.

***

## Saved views

The tabs above the task list are saved views. Each Gantt view stores its own **Period**, **Columns** (which ones, in what order, at what width), sort, and **Group by** settings, plus its filters.

* **Create** — Click **Add a view**, then **Gantt chart**.
* **Rename** — Double-click the tab (or long-press it on a touch screen) and type the new name, or use **Rename** in the tab's **⋯** menu.
* **Duplicate or delete** — Use **Duplicate** and **Delete** in the **⋯** menu. The last remaining view cannot be deleted.

***

## Filtering

Use the **Filters** button to narrow the chart — by task, status, owner, potential owner, project, or [tags](/help/documentation/tags) — with the active filter count shown on the button. Filters can be switched off and back on without losing them: the button toggles them rather than clearing them.

<Tip>
  From an open task's detail panel, the **Show in the chart** button in the top bar jumps straight to the task's position in the Gantt.
</Tip>

***

## Keyboard navigation

With the Gantt chart focused, you can work without the mouse:

| Key                           | Action                                                 |
| ----------------------------- | ------------------------------------------------------ |
| **Arrow Down** / **Arrow Up** | Move the selection to the next or previous row         |
| **Arrow Right**               | Expand the selected task and move into its first child |
| **Arrow Left**                | Collapse the selected task, or move up to its parent   |
| **Enter**                     | Open or close the detail panel of the selected task    |
| **Tab**                       | Make the selected task a subtask of the task above it  |
| **Shift+Tab**                 | Move the selected subtask up one level                 |
| **⌘+A**                       | Add a new task — a subtask if a task is open           |

<Info>
  Keyboard navigation works when the chart has focus. Click anywhere in the task list first if the keys are not responding.
</Info>

***

## Related content

<CardGroup>
  <Card title="Tasks" icon="list-check" href="/help/documentation/planning">
    What tasks are in Beebole — creating, importing, assigning, and tracking time on them.
  </Card>

  <Card title="Kanban board" icon="square-kanban" href="/help/documentation/kanban">
    Move the same tasks through status columns with drag and drop.
  </Card>

  <Card title="List view" icon="table-list" href="/help/documentation/task-list">
    The same columns as a sortable, full-width table, with mass edits across selected rows.
  </Card>

  <Card title="Work schedules" icon="calendar" href="/help/documentation/work-schedule">
    Define the working hours that determine each person's capacity in the heatmap.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Does Beebole's Gantt chart have a month view?">
    No. The Gantt timeline runs **Infinite by day** or **Infinite by week**, selected under **Period** in the view tab's menu — the week granularity is the one to use for a long-range overview. The same menu can also lock the view to a fixed window of **Day**, **Week**, **2 weeks**, **3 weeks**, **4 weeks**, or **6 weeks**, fitted to your screen and paged one period at a time.
  </Accordion>

  <Accordion title="How do I create a dependency between two tasks?">
    Either drag the chain-link handle from the end of one bar onto another task, or click the **Dependencies** cell of the task that should come second and then click the task it depends on (hold **⌘** to pick several) or type its row number. Press **Esc** to finish. Beebole draws an arrow between the bars.
  </Accordion>

  <Accordion title="What happens to dependent tasks when I move their predecessor?">
    It depends on the option chosen under **Dependent tasks** in the view tab's **⋯** menu: **Free** leaves dependents in place, **Pushing** pushes them later when the predecessor would overlap them, and **Together** moves them along with it. The choice belongs to the planning, so it applies to every Gantt and Staffing view of that planning.
  </Accordion>

  <Accordion title="Can I have several Gantt views with different columns?">
    Yes. Click **Add a view** and select **Gantt chart**. Each saved view in Beebole keeps its own columns — which ones, in what order, at what width — plus its sort, grouping, scale, and filters, so you can switch between setups without reconfiguring anything.
  </Accordion>

  <Accordion title="Do changes in the Gantt chart affect the Kanban board?">
    Yes. Both views display the same tasks from the same planning. Dates set on the Gantt timeline, status changes, and renames are immediately visible on the Kanban board, and vice versa.
  </Accordion>
</AccordionGroup>


# Google Sheets Add-on: Link Sheets to Reports
Source: https://beebole.com/help/documentation/gsheets-addon

Link Google Sheets to your saved Beebole reports and refresh time tracking, billing, and project data from a sidebar — no manual exports.

The Beebole Google Sheets add-on links sheets in your spreadsheet to your saved Beebole reports. Instead of exporting files and importing them by hand, you save a report once in Beebole, link a sheet to it, and refresh the data from the **Beebole Reports** sidebar whenever you need the latest figures.

<Info>
  The add-on loads saved reports. Build and save the report you need in Beebole first — its columns, filters, and period all come from the report configuration, not from the add-on.
</Info>

***

## How the add-on works

Each sheet links to one saved Beebole report. When you refresh, the add-on runs the report in your Beebole account, clears the linked sheet, and writes a header row followed by the report data. The links are stored in the spreadsheet, so they travel with the file when you share it.

The add-on connects with your Beebole API key — you never enter a password. The key is stored privately for your Google account and is never saved inside the spreadsheet.

***

## Installing the add-on

<Steps>
  <Step title="Open the Google Workspace Marketplace">
    In Google Sheets, click **Extensions** > **Add-ons** > **Get add-ons**.
  </Step>

  <Step title="Install the Beebole add-on">
    Search for **Beebole**, open the add-on, and click **Install**. Grant the requested permissions when prompted.
  </Step>

  <Step title="Open the sidebar">
    In the **Extensions** menu, open the Beebole add-on and click **Open Beebole Reports**. Once installed, the sidebar also opens automatically when you open the spreadsheet.
  </Step>
</Steps>

***

## Connecting with your API key

The first time you open the sidebar, the add-on asks for your Beebole API key.

<Steps>
  <Step title="Copy your API key from Beebole">
    In Beebole, click the button with your initials at the bottom of the sidebar, then **API Key**. Click **Copy**.
  </Step>

  <Step title="Paste the key into the add-on">
    In the sidebar, paste the key into the **API Key** field and click **Connect**.
  </Step>
</Steps>

<Info>
  The API key gives the add-on the same access as your Beebole account: you only see the saved reports — and the data — that your [role and authorizations](/help/documentation/roles-authorisations) allow. The **Reset** button next to your API key in Beebole revokes the current key and generates a new one.
</Info>

***

## Linking a sheet to a report

<Steps>
  <Step title="Open the add-link form">
    In the sidebar, click **+ Add link** under **Beebole reports linked**.
  </Step>

  <Step title="Pick a report">
    In the **Add Report Link** form, select one of your saved Beebole reports in the **Report** field.
  </Step>

  <Step title="Pick a sheet">
    Choose an existing sheet in the **Sheet** field, or type a name in **New sheet name** to create one.
  </Step>

  <Step title="Confirm">
    Click **Add Link**. The link appears in the **Beebole reports linked** table.
  </Step>
</Steps>

To remove a link, click the **✕** button (**Remove link**) next to it in the table. This removes the link only — the sheet and its current data stay in place.

***

## Refreshing your data

In the **Refresh** section of the sidebar:

* **Refresh This Sheet** — refreshes the sheet you are currently viewing.
* **Refresh All** — refreshes every linked sheet in the spreadsheet.

The add-on also refreshes automatically: when you open the spreadsheet, the sidebar opens and refreshes every linked sheet.

<Warning>
  Refreshing clears the linked sheet before writing the new data. Anything you typed into that sheet — formulas, notes, formatting — is removed. Keep your own calculations and charts in separate sheets that reference the linked one.
</Warning>

If a linked report no longer exists in Beebole, the add-on writes an error message to the sheet so you know the link needs updating.

***

## Updating or removing your API key

Click **Update API** at the top of the sidebar to open the key settings:

* Paste a new key into **New API Key** and click **Update API Key**. Switching to a different key clears the spreadsheet's existing report links, since they belonged to the previous account's reports.
* Click **Remove API Key** to delete your saved key. You will need to enter a key again to use the add-on.

***

## Related content

<CardGroup>
  <Card title="Reports" icon="chart-line" href="/help/documentation/reports">
    Understand report dimensions, filters, grouping, and columns in Beebole.
  </Card>

  <Card title="Custom Reports" icon="chart-bar" href="/help/documentation/custom-reports">
    Build and save the reports your linked sheets will load.
  </Card>

  <Card title="Excel Add-in" icon="file-excel" href="/help/documentation/excel-addin">
    Link Excel worksheets to your saved Beebole reports the same way.
  </Card>

  <Card title="Data Exports" icon="download" href="/help/documentation/data-exports">
    Download one-off exports in Excel, CSV, PDF, and other formats.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I configure columns and filters inside the add-on?">
    No. The Beebole Google Sheets add-on loads saved reports exactly as they are configured in Beebole. To change the columns, filters, or period of the data in a sheet, edit the saved report in Beebole and refresh the sheet.
  </Accordion>

  <Accordion title="Can I share the spreadsheet with people who do not use Beebole?">
    Yes. The refreshed report data is ordinary cell values, so anyone you share the spreadsheet with can read it. The sheet-to-report links travel with the file, but your API key does not — to refresh the data, a person connects with their own Beebole API key, which shows only the reports their account can access.
  </Accordion>

  <Accordion title="Does refreshing overwrite my formulas?">
    Yes. A refresh clears the linked sheet completely before writing the report data. Place your own formulas, pivot tables, and charts in separate sheets that reference the linked sheet, so they survive every refresh.
  </Accordion>

  <Accordion title="Can I refresh the data automatically?">
    The Beebole add-on refreshes every linked sheet automatically when you open the spreadsheet. For anything in between, use **Refresh This Sheet** or **Refresh All** in the sidebar.
  </Accordion>
</AccordionGroup>


# Journal: Team Activity Feed & Messaging
Source: https://beebole.com/help/documentation/journal

Use the Journal in Beebole as your team's activity feed — view updates, exchange messages, and stay informed about what's happening across your account.

The Journal is Beebole's built-in activity feed and communication hub. It shows a chronological log of what's happening in your account — messages, approval actions, mentions, and team updates — all in one place. To open it, click **Journal** in the sidebar.

***

## Activity feed

The Journal displays a timeline of events across your account:

* **Approval actions** — When timesheets are submitted, approved, or rejected.
* **Team updates** — New members added, schedule changes, and other organizational events.
* **Notifications** — Mentions, reminders, and alerts appear inline in the feed.

Beebole marks new items with a "new" separator so you can quickly see what happened since your last visit. Unread counts appear as badge indicators.

The feed is also context-aware: opened from a timesheet, it shows that timesheet's approval events and its own time and expense changes by default — with the option to widen to the person's full history — and changes to a time record appear as a trail, so an approver can see what was edited, when, and by whom.

***

## Messages and threads

The Journal supports threaded conversations:

* **Post messages** — Share updates, ask questions, or communicate with your team.
* **Reply to threads** — Keep conversations organized with threaded replies.
* **Rich text** — Format messages with bold, italic, links, and lists.
* **File attachments** — Upload and share documents directly in messages.
* **@Mentions** — Reference people, projects, and other records to notify them and link to relevant context.
* **Pin messages** — Highlight important messages so they stay visible.

<Info>
  You can reply to journal messages directly from email. Beebole processes incoming replies and adds them to the correct thread automatically.
</Info>

***

## Filtering the feed

The Journal lets you narrow the feed to focus on what matters:

* **Timesheet entries only** — On a person, project, or tag, you can switch to **Showing timesheet entries only** to see just that timesheet activity, then click to show all events again.
* **Hide similar entries** — Choose **Hide similar entries** on a repetitive automatic event to collapse that group of audit entries and keep the feed readable.

***

## Notifications in the Journal

The Journal is also where your [notifications](/help/documentation/notifications) appear. Approval alerts, mention notifications, and reminder messages all show up in the feed alongside regular messages, giving you a single place to stay informed.

***

## Related content

<CardGroup>
  <Card title="Notifications" href="/help/documentation/notifications">
    Configure which events trigger notifications in the Journal feed.
  </Card>

  <Card title="People" href="/help/documentation/people">
    Journal activity is scoped to the people you manage or work with.
  </Card>

  <Card title="Projects" href="/help/documentation/projects">
    Associate Journal messages with specific projects for context.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I use the Journal for project-specific discussions?">
    Yes. Messages can be associated with specific projects or other records, keeping discussions contextual and easy to find.
  </Accordion>

  <Accordion title="Who can see Journal messages?">
    Visibility follows Beebole's [permission system](/help/documentation/roles-authorisations). People see messages relevant to their projects and teams based on their role.
  </Accordion>

  <Accordion title="Can I reply to Journal messages from email?">
    Yes. When you receive an email notification about a Journal message, you can reply directly from your email client. Beebole processes the reply and adds it to the thread.
  </Accordion>

  <Accordion title="Does the Journal show approval activity?">
    Yes. When timesheets are submitted, approved, or rejected, these actions appear in the Journal feed. This gives managers and administrators visibility into approval progress without leaving the Journal. See [Approvals](/help/documentation/approval) for details.
  </Accordion>
</AccordionGroup>


# Kanban board: moving tasks through statuses
Source: https://beebole.com/help/documentation/kanban

Move task cards between status columns on Beebole's Kanban board, set hard WIP limits per status, select multiple cards, and start time records from a card.

Beebole's Kanban board displays your [tasks](/help/documentation/planning) as cards in columns — one column per status of the planning. Drag a card to another column to change its status as work progresses, for example from **Backlog** to **In progress** to **Done**. The Kanban board is one of the four views of the **Planning** page, alongside the [Gantt chart](/help/documentation/gantt), the [Staffing view](/help/documentation/staffing), and the [List view](/help/documentation/task-list) — all show the same tasks, so a change in one view appears instantly in the others.

***

## Opening a Kanban view

<Steps>
  <Step title="Open the Planning page">
    Click **Planning** in the sidebar. Pick the planning you want at the top of the page.
  </Step>

  <Step title="Select a Kanban view">
    Click a Kanban view tab above the task list. To create another one, click **Add a view** and select **Kanban**.
  </Step>
</Steps>

***

## Board layout

Each column is one status of the active planning, in the order defined in the **Task statuses** modal. A column header shows:

* A **+** button (**Add a task**) that opens the add form with this status preselected.
* The number of tasks in the column — displayed as `current/max` when the status has a **Max tasks** limit.
* The status name. Click it to open the **Task statuses** modal.
* A **⋯** menu with **Archive** (archive every task in the column), **Unarchive** (restore the column's archived tasks), **Move entries to left** / **Move entries to right** (move the column's tasks into the neighboring status), and **Delete** (only available when the column holds no tasks — including archived ones — and isn't the planning's only status).

***

## Setting up status columns

Statuses belong to the planning — not to a project — so every planning defines its own columns. Click any column's name (or the **Edit statuses** gear in a task's detail panel) to open the **Task statuses** modal, where you can add a status with the **Add new status** field, rename or recolor one, drag to reorder, set **Max tasks**, and delete empty statuses. The full options are described in [Task statuses](/help/documentation/planning#task-statuses).

<Tip>
  Keep the workflow short. New Beebole accounts start with one planning, **Main plan**, and four statuses — **Backlog**, **Queue**, **In progress**, **Done** — which is enough for most teams.
</Tip>

***

## Working with cards

* **Create a task** — Click the **+** button at the top of a column, or the **+ Add Task** button in the page header. See [creating a task](/help/documentation/planning#creating-a-task).
* **Open a task** — Click its card. The detail panel opens with the task's dates, status, owner, description, and custom fields.
* **Move a card** — Drag it to another column to change its status, or drop it at a different position in the same column to reorder.
* **Act on a card** — Hover over it and click the **⋯** menu for **Duplicate**, **Rename**, **Archive**, **Unarchive**, and **Delete**.

### Choosing what cards display

Open the **⋯** menu on the active view tab and hover over **Show** to toggle the card fields: **Parent**, **Owner**, **Assignee**, **Dates**, **Projects**, and **Tags**. Each Kanban view remembers its own selection.

### Selecting multiple cards

* **⌘+Click** (Ctrl+Click on Windows) a card to add it to or remove it from the selection.
* **Shift+Click** selects the whole range between two cards in a column.
* Drag any selected card to move all selected cards together to the target column.
* Press **Esc** to clear the selection.

For bulk archiving, use the column's **⋯** menu instead. **Archive** and **Unarchive** act on the whole column, or on just the selected cards when a selection reaches into that column.

***

## WIP limits are hard limits

Set **Max tasks** on a status in the **Task statuses** modal to cap how many tasks it can hold. On the board, the column header then shows `current/max`.

The limit is enforced, not just suggested:

* Dragging cards that would push the column over its limit is rejected — the column border turns red while you hover, and dropping shows the error *"\[Status] is at its task limit (N)"*.
* The same rule applies when changing the status from the task's detail panel, and Beebole's server enforces it too.
* You cannot set **Max tasks** below the number of tasks currently in the column.

To allow more work in the status, raise or clear its **Max tasks** value (0 means unlimited), or move tasks out first.

***

## Task descriptions

Every task has a **Description** panel with a rich-text editor. The toolbar offers **Bold**, **Italic**, **Code**, **Link**, **Bulleted list**, **Numbered list**, text alignment (**Align left**, **Align center**, **Align right**), **Text color**, text size, **Mention** (type **@** to reference a teammate), **Undo**, **Print / Save as PDF**, and **Attach a file** — images, videos, and PDFs, which you can also paste or drop directly into the text.

Edits are saved automatically. The description is part of the task, so the same content appears whether you open the task from the Kanban board or the Gantt chart.

<Tip>
  Use the description for stable task-level information — acceptance criteria, reference links, background. Custom fields are better for structured data you want to filter and report on; see [Custom fields](/help/documentation/custom-fields).
</Tip>

***

## Tracking time from a card

Hover over a card and click the clock button (**Add time**) to log time on that task for today, without leaving the board. Once time has been logged, the card shows a pill with the logged total next to the planned time (for example `4h / 8h`) — click it to add more.

The button only appears on tasks whose planning is selected under **Record time on these plannings** in [Timesheet and Planning Settings](/help/documentation/timesheetSettings).

### Auto Timesheet: statuses that drive time records

With **Auto Timesheet from Planning**, the board itself can start and end time records. In the [Auto Timesheet from Planning tab](/help/documentation/timesheetSettings#auto-timesheet-from-planning) of **Timesheet and Planning Settings**, check **Enable Auto Timesheet from planning**, pick a planning, then choose the **Start** and **End** statuses — the statuses that trigger a time record to start and to end. Moving a card into those columns then drives the time record for the task: cards created directly in a start status begin tracking immediately, moving a card back before its start column stops its clock, and finishing several tasks the same day splits the day between them — manual entries always win. Cards show a gray pill with the suggested, not-yet-accepted time alongside logged time.

***

## Related content

<CardGroup>
  <Card title="Tasks" icon="list-check" href="/help/documentation/planning">
    What tasks are in Beebole — creating, importing, assigning, and archiving them.
  </Card>

  <Card title="Gantt chart" icon="chart-gantt" href="/help/documentation/gantt">
    Schedule the same tasks on a timeline with dependencies and a workload heatmap.
  </Card>

  <Card title="List view" icon="table-list" href="/help/documentation/task-list">
    The same tasks as a sortable table, with in-place editing and mass edits.
  </Card>

  <Card title="Timesheet and Planning Settings" icon="sliders" href="/help/documentation/timesheetSettings">
    Choose which plannings accept time entries and configure Auto Timesheet from Planning.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I use the Kanban board without setting up statuses first?">
    Yes. New Beebole accounts come with the default **Main plan** and the statuses **Backlog**, **Queue**, **In progress**, and **Done**, so the board works immediately. You can rename, recolor, reorder, add, or remove statuses later in the **Task statuses** modal.
  </Accordion>

  <Accordion title="What happens when a column reaches its WIP limit?">
    Beebole blocks the move. The column border turns red while you drag over it, and dropping shows an error saying the status is at its task limit. Raise the status's **Max tasks** value, set it to 0 for unlimited, or move other tasks out first.
  </Accordion>

  <Accordion title="How do I move several cards at once?">
    **⌘+Click** cards to build a selection (or **Shift+Click** for a range within a column), then drag any selected card — all selected cards move to the target column together, as long as the move stays within the column's WIP limit.
  </Accordion>

  <Accordion title="Do changes on the Kanban board affect the Gantt chart?">
    Yes. The Kanban board and the Gantt chart display the same tasks from the same planning. A status change, rename, or archive done on the board is immediately reflected in the Gantt view, and vice versa.
  </Accordion>

  <Accordion title="How do I archive every task in a column?">
    Open the column header's **⋯** menu and click **Archive**. The same menu offers **Unarchive** to restore the column's archived tasks — use **Show Archived** in the page header to see them.
  </Accordion>
</AccordionGroup>


# Migrating a legacy Beebole account
Source: https://beebole.com/help/documentation/legacy-migration

How Beebole support imports your legacy account — people, projects, tags, rates, budgets, and time records — into the new platform, and what to expect afterwards.

Beebole can import a legacy Beebole account — people, projects, tags, rates, budgets, settings, and historical time records — into a new Beebole account. The import is run by Beebole's support team on request, so there is nothing to install or configure yourself. It is a one-time operation per account: once an account has been migrated, it cannot be migrated again.

<Info>
  To request a migration, email [support@beebole.com](mailto:support@beebole.com). Tell us which legacy account to import, which account it should land in, and how far back you want time records. There is no self-service migration screen in the app.
</Info>

***

## What gets migrated

| Data                                 | How it lands in the new account                                                                                                              |
| ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **People**                           | Active and archived people, with their roles, email addresses, and external IDs                                                              |
| **Companies, projects, subprojects** | One project category — **Companies** by default — with the legacy company > project > subproject hierarchy kept as is                        |
| **Activities**                       | Legacy activities (jobs) become projects in a second category, **Tasks (Legacy)** by default, offered as a secondary column in the timesheet |
| **Groups and branches**              | Two tag categories, **Groups** and **Branches** by default, with each person's assignments over time                                         |
| **Time off types**                   | Absence types and their allowances                                                                                                           |
| **Work schedules**                   | Schedule definitions and the assignments of people to them                                                                                   |
| **Billing and cost rates**           | The full dated rate history, including rates split per person or per project                                                                 |
| **Budgets**                          | Project budgets, with subproject budgets inheriting the parent's type and currency                                                           |
| **Custom fields**                    | Field definitions and the values on your records                                                                                             |
| **Managers**                         | Who manages whom, and who manages which project                                                                                              |
| **Project membership**               | Who has access to which project, including exclusive-membership settings                                                                     |
| **Time records**                     | Historical entries with their hours, comments, and clock-in and clock-out times when legacy stored them                                      |
| **"Specific tasks" lists**           | Legacy per-project activity restrictions, applied as an "only these" restriction on that project's secondary projects                        |

A few details worth knowing about the conversion:

* **Rate currency.** A legacy rate that carries no currency of its own — split rates and unbillable rates never do — falls back to the migrated account's own currency, taken from the main company, rather than to a default like US dollars.
* **Clock times.** An entry with a complete, same-day start and end time keeps both. Anything else — no times, only one of the two, an end at or before the start — becomes a whole-day entry. Either way the entry's duration stays exactly what legacy reported, so report totals never move because times were imported.
* **Custom field history.** A legacy field that held a history of values collapses to a single value in the new account, and the most recent one wins.
* **"No task" projects.** A legacy project set to offer no activity at all keeps that behavior: its task picker offers nothing.

<Info>
  Data can only be migrated **as is**. You can choose which data sets to bring over — for example people and projects but no time records — and how far back time records go, but not to restructure the account on the way in. If you want a different structure, see [Review your structure before you switch](/help/guides/migration#review-your-structure-before-you-switch).
</Info>

<Tip>
  You can ask for only active records, which skips archived people and projects. Archived records that historical time entries point at are still created, so no entry loses its project or person.
</Tip>

***

## What to expect after the migration

The imported history is treated as closed business, so nobody has to re-submit years of timesheets:

* **Everything up to the cut-over is approved.** Each person gets a single approval covering their whole imported history, so no migrated period shows up as a draft, nothing reaches an approver's queue, and no approval email is ever sent for it.
* **The timesheet lock date is set to the last imported day.** Migrated records are frozen from the start — admins included — and a period the lock date covers cannot be submitted, so imported history can't be pushed back into the approval flow by hand.
* **Timesheet scores ignore pre-import periods.** A person's [timesheet score](/help/documentation/approval) is computed only from periods after the cut-over, so periods they never worked in the new app don't read as missed submissions.
* **Imported entries keep the amounts legacy reported.** Billing and cost figures on migrated entries come from the legacy account, so report totals reconcile with what you saw before the move.
* **Nobody is notified.** Migrating people creates their records without sending invitations. Invite them from the **People** page in the sidebar when you are ready.

<Warning>
  A migration is additive and can only run once per account. Because it never wipes the target account, anything you already configured there — your approval workflow in particular — survives the run untouched, and the imported data lands alongside it. Ask support for an empty account if you want a clean result.
</Warning>

After the migration, it is worth checking a sample of time records in [Reports](/help/documentation/reports), reviewing the project categories and their level names, and confirming that rates and budgets landed where you expect. [Master data review](/help/documentation/master-data) is the fastest way to check a whole entity at once.

***

## Related content

<CardGroup>
  <Card title="Migration guide" icon="arrow-right" href="/help/guides/migration">
    How the legacy and new systems coexist, and what has changed between them.
  </Card>

  <Card title="Master data review" icon="table" href="/help/documentation/master-data">
    Check the imported configuration entity by entity, and fix it in bulk.
  </Card>

  <Card title="Account settings" icon="gear" href="/help/documentation/account-settings">
    Review the organization profile and account-level settings after the import.
  </Card>

  <Card title="Data exports" icon="download" href="/help/documentation/data-exports">
    Export your Beebole data for backup or external analysis.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How do I migrate my legacy Beebole account?">
    Email [support@beebole.com](mailto:support@beebole.com) and we run the import for you. Beebole has no self-service migration screen: tell us which legacy account to import, which new account it should land in, which data sets you want, and how far back time records should go.
  </Accordion>

  <Accordion title="Can a Beebole account be migrated more than once?">
    No. The migration is additive and runs once per account — a second run would duplicate everything, so Beebole refuses it. If something needs to be corrected afterwards, contact support and we will look at it with you.
  </Accordion>

  <Accordion title="Can I migrate only part of my legacy data?">
    Yes. You can leave out whole data sets — for example bring over people and projects but no time records — and set a start date so only recent entries are imported. What you cannot do is change the structure on the way in: the hierarchy, rates, and settings arrive as they were.
  </Accordion>

  <Accordion title="Will migrated timesheets need to be submitted and approved again?">
    No. Beebole marks every imported period as approved and sets the timesheet lock date to the last imported day, so migrated history is frozen and closed. Approvers see nothing new in their queue, and per-person timesheet scores start from the periods after the migration.
  </Accordion>

  <Accordion title="Will migrated people receive an invitation email?">
    No. Migrating people creates their records in Beebole without sending anything. Invite them from the **People** page in the sidebar whenever you are ready for them to sign in.
  </Accordion>
</AccordionGroup>


# Master data review: check, export, and bulk-edit your setup
Source: https://beebole.com/help/documentation/master-data

Review, export, and bulk-edit your Beebole configuration data — people, projects, tags, rates, schedules, and custom field values — from one admin table.

Master data review in Beebole is an admin table over your organization's configuration data: the definitions your account is built on, not the time your team logs. Pick an entity, build the columns you want from its own fields and relations, and you get a live table you can filter, download, or edit in bulk. Use it to audit a setup before a cutover, hand a colleague a spreadsheet of your rates, or fix the same field on two hundred people in one pass.

<Info>
  Master data review is restricted to administrators. Open it from the button with your initials at the bottom of the sidebar, then **Master data review**.
</Info>

***

## What you can review

A review always starts from one entity. Beebole offers nine:

| Entity             | What it holds                                                             |
| ------------------ | ------------------------------------------------------------------------- |
| **People**         | Everyone in the account, with their roles, rates, schedules, and settings |
| **Projects**       | The project hierarchy, with rates, budgets, and access                    |
| **Tasks**          | Planning items, with owners, dates, and planned time                      |
| **Tags**           | Your tag trees and the configuration they carry                           |
| **Time off types** | Absence types and their allowances                                        |
| **Expense types**  | Expense types and their units and markups                                 |
| **Custom fields**  | The field definitions themselves, with their types and visibility         |
| **Roles**          | Roles and their permissions                                               |
| **Work schedules** | Schedule definitions and their days                                       |

For **Projects**, **Tasks**, and **Tags** you can also narrow the review to one category, and inside it to one hierarchy level — pick **All categories**, a category, then **All levels**, **Lowest level**, or a named level.

<Info>
  Master data review covers definitions only. Time entries, expense records, and absences are records, not master data — report on those with [custom reports](/help/documentation/custom-reports) and [data exports](/help/documentation/data-exports).
</Info>

***

## Building a review

<Steps>
  <Step title="Open Master data review">
    Click the button with your initials at the bottom of the sidebar, then **Master data review**.
  </Step>

  <Step title="Add an export">
    Click **Add an export**. Beebole creates one named **New export** and puts the name in edit mode — type a name and press Enter.
  </Step>

  <Step title="Pick the entity">
    In the table's first column header, click the entity button — it shows the entity currently reviewed — and choose another from the menu. The first column always holds that entity's name.
  </Step>

  <Step title="Add the columns you need">
    Click **Add a column…** and walk into the entity's fields. Each pick appends a column; the table re-runs on its own.
  </Step>
</Steps>

Every review you save is personal to you, and the list of your saved exports is the page itself — click one to open it, click it again to close it.

### Adding columns

The column picker walks the entity's own fields and its relations, with no depth limit. A field becomes a column; an attribute or a relation opens as a branch you step into, so a person's tags lead to the tag's own fields, and a tag's rates lead to the rate's amount.

* Type in **Search a field…** to search several levels down at once. Each match shows the path it sits on, so a hit reading *Tags: Name* is clearly the name of a tag, not the name of the person.
* Press Backspace on an empty search box to step back up one level, or click a step of the path to jump back to it.
* One column can hold several values — a person with three tags shows all three, stacked in the cell.

A column header carries its own menu:

| Menu entry                | What it does                                                                                            |
| ------------------------- | ------------------------------------------------------------------------------------------------------- |
| **Filter on this column** | Adds a filter chip for that column                                                                      |
| **Other *Tags* column**   | Names the path the column sits on, and opens the picker there so you can add a sibling field next to it |
| **Add a column…**         | Inserts a new column right after this one                                                               |
| **Remove column**         | Drops the column from the review                                                                        |

You can also drag a header sideways to reorder the columns.

### Custom field values as columns

When a [custom field](/help/documentation/custom-fields) applies to the entity you are reviewing, a **Custom field values** branch appears in the picker with those definitions in it. Pick one and its values become a plain column, one value per row, blank where a record holds none. Only the definitions that actually apply to the entity are offered.

***

## Narrowing what the table shows

**Filters** are chips under the command row. Each chip names a column, an operator, and a value:

| Operator                            | Matches                            |
| ----------------------------------- | ---------------------------------- |
| **contains** / **doesn't contain**  | Part of the cell's text            |
| **is** / **is not**                 | The whole value                    |
| **is empty** / **is not empty**     | Rows with or without a value       |
| **is more than** / **is less than** | Numbers above or below a threshold |

**Show Archived** next to the review's name brings archived records into the table; click **Hide Archived** to leave them out again. Archived rows are shown dimmed.

**A period selector** appears whenever the review holds a dated column — rates, costs, budgets, allowances, work schedule assignments, tag assignments. It decides which of those records the table lists: a record counts for the period when its validity overlaps it, so a rate that started in 2025 still shows for 2025 as long as its replacement starts after the period begins. The default period runs from today onwards, which lists the records in force now.

***

## Reading the table

* **Inherited values name their origin.** When a value comes from the organization, a tag, or a parent record rather than the row itself, the cell shows the source next to the value, with the same clickable link the attribute panels use. A value set on the row itself shows nothing.
* **Stored codes read as words.** Durations, work-schedule day times, colors, absence units, duration formats, weekdays, and permission names render the way the interface shows them, not as raw codes. A rate renders like its panel: the amount on the first line, then its method and start date beneath it — **120,00 EUR**, then **Hourly rate · 1 Jan 2026** — with its split lines below that.
* **Records are badges.** A cell holding another record shows it as a clickable badge — click it to open that record's panel and edit it in place.
* **A subtracted value is struck through.** When a rule removes an inherited item instead of adding one, the cell shows it struck through in red, the same way the rest of Beebole marks an exclusion.
* **The table re-runs live.** When anything on screen changes — your own edit in a panel, or a colleague's — the review re-runs and rows that no longer match fade out.

***

## Downloading a review

Hover the review in the list, click the **⋯** action menu, choose **Export**, then a format: **JSON**, **CSV**, **TSV**, **Excel (XLSX)**, or **PDF**. The file carries the columns and rows on screen, plus a header noting the entity, whether archived records were included, and the period when the review has one.

***

## Building a review in plain language

When AI features are enabled for your account, a text box sits above the table. Describe the table you want — for example *people with their hourly rate and their tags* — and click **Build**. Beebole picks the entity, the columns, and the filters, and runs it.

With a review open, the same box refines it: **Update** adds a column, changes a filter, or swaps the entity. Asking about a different entity creates a new review instead of overwriting the one you built. If a request is ambiguous, Beebole asks a question rather than guessing.

***

## Changing data in bulk

Click **Modify this data…** to switch the review into update mode. Then describe the change and click **Preview**.

The change applies to every row the table currently lists, so filter the table first — a command that names a narrower subset comes back with a request to filter instead. What you can ask for:

* Set or clear a value, including a custom field value.
* Put text around the value each row holds today, such as *prefix their external ID with ext-*.
* Add or clear a billing rate, a cost rate, a time off allowance, or a public holiday — including a percentage change on the rate each row holds.
* Link or unlink a related record, such as a work schedule, a tag, or a role.
* Archive, unarchive, or delete the listed records, or create one new record.

<Steps>
  <Step title="Preview the change">
    Beebole replaces the table with a before/after view: the changed column shows **old → new**, records to be created appear as new rows, and records to be deleted are struck through. A one-line summary and the number of changes sit next to the buttons.
  </Step>

  <Step title="Check what was left out">
    Rows Beebole will not touch are listed after **Left out:** with a reason — *inherited from* a tag or the organization, *nothing to remove*, *no current value to change*, or *the field does not apply*.
  </Step>

  <Step title="Refine or apply">
    Type another sentence and click **Update preview** to adjust, **Cancel** to drop the whole thing, or **Apply** to run it. Rows tick off one by one as they go through, and a row that fails shows its error without stopping the rest.
  </Step>
</Steps>

<Warning>
  **Undo the last change** reverses the bulk action you just applied, and only that one. It is held in memory, so reloading the page loses it, and deleted records cannot be brought back at all — recreating one gives it a new identity and no reference to the old one survives.
</Warning>

<Info>
  A row whose value is inherited from a tag or from the organization is deliberately skipped: writing on the row would break the inheritance for its whole history. To raise rates on people who inherit them, run the change on the tag instead.
</Info>

***

## What reaches the AI model

The plain-language builder and update mode follow the same privacy stance as the rest of [Beebole AI](/help/documentation/ai#what-reaches-the-model): only definitions reach the model. It receives your sentence, the entity being reviewed, and the vocabulary of that entity — the labels and paths of its fields, plus the allowed values of a field that has a closed set. It never sees a value from your table and never names one of your records: Beebole turns the sentence into an abstract instruction, and your browser computes the actual before and after values.

***

## Related content

<CardGroup>
  <Card title="Custom fields" icon="tag" href="/help/documentation/custom-fields">
    Define the fields whose values become columns in a review.
  </Card>

  <Card title="Data exports" icon="download" href="/help/documentation/data-exports">
    Export the time and expense records a review deliberately leaves out.
  </Card>

  <Card title="Beebole AI" icon="sparkles" href="/help/documentation/ai">
    How Beebole's AI features work and what data they see.
  </Card>

  <Card title="Account settings" icon="gear" href="/help/documentation/account-settings">
    The organization-wide settings a review lets you check across records.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Who can use Master data review in Beebole?">
    Administrators only. The **Master data review** entry sits in the Settings menu, opened from the button with your initials at the bottom of the sidebar, and the page itself is closed to anyone whose role does not have **Admin role (full access)** checked. See [Roles & permissions](/help/documentation/roles-authorisations).
  </Accordion>

  <Accordion title="Which entities can I review?">
    Nine: **People**, **Projects**, **Tasks**, **Tags**, **Time off types**, **Expense types**, **Custom fields**, **Roles**, and **Work schedules**. For projects, tasks, and tags you can narrow the review to one category and one hierarchy level.
  </Accordion>

  <Accordion title="Can I export my time entries from here?">
    No. Master data review covers your configuration data — the definitions — not the records your team logs. For time entries, expenses, and absences, build a [custom report](/help/documentation/custom-reports) and download it as described in [Data exports](/help/documentation/data-exports).
  </Accordion>

  <Accordion title="Can I undo a bulk change?">
    Yes, but only the last one, and only while the page stays open — **Undo the last change** is held in memory and a reload drops it. Records deleted by a bulk change cannot be restored at all, so check the before/after preview before clicking **Apply**.
  </Accordion>

  <Accordion title="Why did some rows get left out of my bulk change?">
    Beebole lists them after **Left out:** with the reason. The common ones are a value inherited from a tag or the organization (change it on the tag instead), a row that already holds the value you asked for, a row with nothing to remove, and a custom field that does not apply to that record.
  </Accordion>
</AccordionGroup>


# Mobile: install Beebole on your phone or tablet
Source: https://beebole.com/help/documentation/mobile

Install Beebole as a progressive web app on your phone, tablet, or desktop and use the responsive layout, dark mode, and on-the-go time tracking.

Beebole works on any device with a web browser — phone, tablet, or desktop. You can also install it as an app on your device for a native-like experience, complete with an app icon and full-screen mode.

<Info>
  This page covers installing the Beebole web app on your device (PWA). The separate [Beebole desktop app](/help/documentation/desktop-app) is a companion that drafts time entries from your computer activity — you can use both.
</Info>

***

## Installing Beebole as an app

Beebole is a Progressive Web App (PWA), which means you can install it directly from your browser without going through an app store. Once installed, Beebole appears as a standalone app on your home screen or taskbar.

### On iPhone or iPad

<Steps>
  <Step title="Open Beebole in Safari">
    Navigate to your Beebole account URL in Safari.
  </Step>

  <Step title="Tap the Share button">
    Tap the **Share** icon at the bottom of the screen.
  </Step>

  <Step title="Add to Home Screen">
    Scroll down and tap **Add to Home Screen**. Give the app a name and tap **Add**.
  </Step>
</Steps>

### On Android

<Steps>
  <Step title="Open Beebole in Chrome">
    Navigate to your Beebole account URL in Chrome.
  </Step>

  <Step title="Tap the install prompt">
    Chrome displays an **Install** banner or you can tap the menu (three dots) and select **Install app** or **Add to Home screen**.
  </Step>

  <Step title="Confirm installation">
    Tap **Install**. Beebole appears as an app on your home screen.
  </Step>
</Steps>

### On desktop (Windows, macOS, Linux)

<Steps>
  <Step title="Open Beebole in your browser">
    Navigate to your Beebole account URL in Chrome, Edge, or another compatible browser.
  </Step>

  <Step title="Install the app">
    Click the install icon in the address bar, or go to the browser menu and select **Install Beebole**.
  </Step>

  <Step title="Launch from your desktop">
    Beebole now appears in your applications list and can be pinned to your taskbar or dock.
  </Step>
</Steps>

<Tip>
  The installed app runs in its own window without browser navigation bars, giving you more screen space for your timesheets and reports.
</Tip>

***

## Responsive layout

Beebole's interface adapts automatically to your screen size. Whether you are on a large monitor or a small phone screen, all features remain accessible:

* **Desktop** — Full layout with sidebar navigation, detailed tables, and expanded views.
* **Tablet** — Optimized layout that adjusts columns and spacing for medium-sized screens.
* **Phone** — Compact layout with simplified navigation and touch-friendly controls.

You do not need to switch between different apps or URLs. The same Beebole account works seamlessly across all devices.

***

## Theme settings

Beebole supports three theme options to match your visual preference:

| Theme     | Behavior                                                          |
| --------- | ----------------------------------------------------------------- |
| **Light** | Standard light background                                         |
| **Dark**  | Dark background that reduces eye strain in low-light environments |
| **Auto**  | Automatically matches your device's system theme setting          |

To change your theme, click the button with your initials at the bottom of the sidebar to open the user menu, then pick **Light**, **Dark**, or **Auto**.

<Info>
  The theme setting is personal and applies only to your account. It does not affect other people in your organization.
</Info>

***

## Logging time on mobile

The mobile timesheet is optimized for touch interaction. It presents your time entries as a scrollable list of days rather than a weekly grid, making it easier to navigate on a small screen.

### How to log hours

<Steps>
  <Step title="Open your timesheet">
    Tap the hamburger menu icon in the top-left corner to open the sidebar, then tap **Timesheet**.
  </Step>

  <Step title="Add a time entry">
    Tap the **+** button at the bottom of the screen (floating action button) or the **+** icon next to a specific day. The activity selector opens as a bottom sheet.
  </Step>

  <Step title="Select a project, task, or absence">
    Choose what you worked on from the list. Tap a project, task, or absence type to open the time entry editor.
  </Step>

  <Step title="Enter your time">
    In the editor bottom sheet, enter the duration or set start and end times (depending on your account configuration). Your entry saves automatically — tap the back arrow to return to the list.
  </Step>
</Steps>

### Editing and deleting entries

* **Tap** a time entry card to open the editor bottom sheet and update the duration, project, or comment.
* **Swipe left** on a time entry to reveal the delete action. Confirm deletion in the dialog that appears.

<Info>
  Editing and deleting are disabled when the timesheet period is locked (submitted or approved). The swipe-to-delete gesture and tap-to-edit are both blocked until the period is unlocked.
</Info>

### Using the timer on mobile

<Steps>
  <Step title="Start the timer">
    On a time entry card, tap the play button on the right side of the card. The timer starts and the entry shows a running red counter.
  </Step>

  <Step title="Monitor the timer">
    While the timer is running, a timer bar appears at the top of the header showing the active project and elapsed time.
  </Step>

  <Step title="Stop the timer">
    Tap the red stop button in the timer bar or on the entry card. Beebole saves the elapsed time as the entry's duration.
  </Step>
</Steps>

<Tip>
  The timer only appears on today's entries and is disabled when the timesheet is locked.
</Tip>

### Submitting timesheets on mobile

When your timesheet is ready for approval, tap the **Submit** button in the header. The button is visible when the period is in draft or rejected state and you are viewing your own timesheet.

After submission, the period is locked and the header shows the **Submitted** status badge. If your approver rejects the timesheet, the period unlocks and a **Resubmit** button appears in its place.

### Navigating periods with infinite scroll

The mobile timesheet uses infinite scroll rather than week-by-week navigation:

* **Scroll down** to load future periods automatically.
* **Pull down** from the top of the list to load previous periods. A pull-to-refresh indicator shows when you have pulled far enough to trigger the load.
* Month banners appear in the scroll list whenever the date crosses into a new month.
* A **Today** button appears in the footer when today is out of view. Tap it to scroll back to the current day.

### Approving team timesheets on mobile

Managers and administrators see a team button in the header (person group icon) with a badge showing the number of pending approvals.

<Steps>
  <Step title="Open the approval sheet">
    Tap the team icon in the header. The approval bottom sheet slides up with two tabs: **Pending** and **Team**.
  </Step>

  <Step title="Select a timesheet">
    Tap a person's entry in the **Pending** tab to view their submitted timesheet.
  </Step>

  <Step title="Approve or reject">
    With the submitter's timesheet open, tap **Approve** or **Reject** in the header. Rejection requires a comment.
  </Step>
</Steps>

You can also select multiple timesheets using checkboxes and bulk-approve or bulk-reject them from the action bar that appears at the bottom of the sheet.

***

## Related content

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Learn all the ways to log and manage time entries on desktop and mobile.
  </Card>

  <Card title="Approvals" icon="check" href="/help/documentation/approval">
    Submit and approve timesheets from any device, including directly from email.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I need to download Beebole from an app store?">
    No. Beebole is a Progressive Web App (PWA) that you install directly from your browser. There is no app store download required.
  </Accordion>

  <Accordion title="What can I do in Beebole on mobile?">
    The mobile layout is focused on day-to-day time tracking: logging and editing time entries, running the timer, submitting your timesheet for approval, and (for managers) approving or rejecting team timesheets. More detailed configuration and reporting are best handled on a larger screen.
  </Accordion>

  <Accordion title="Can I use Beebole offline?">
    Beebole requires an internet connection to sync your data. However, the installed PWA may cache some interface elements for faster loading when you reconnect.
  </Accordion>

  <Accordion title="How do I switch between dark and light mode?">
    Click the button with your initials at the bottom of the sidebar to open the user menu, then pick **Light**, **Dark**, or **Auto**. The **Auto** option automatically follows your device settings.
  </Accordion>

  <Accordion title="Can an administrator set the theme for the entire organization?">
    No. Theme selection is a personal preference. Each person chooses their own theme independently.
  </Accordion>
</AccordionGroup>


# Notifications: email alerts and reminders
Source: https://beebole.com/help/documentation/notifications

Set up Beebole email notifications for mentions and approval updates, choose instant, daily, or weekly delivery, and configure account-wide timesheet reminders.

Beebole's notifications keep you informed about mentions and approval updates by email. Each person chooses which events to receive and how often — **Instant**, **Daily**, **Weekly**, or **None**. Administrators configure account-wide timesheet reminders and the email content people receive.

<Info>
  Notification preferences are personal. You set yours from your own profile, and they cascade down through tags the same way other settings do — so a default can be set once on the organization or a tag and inherited by everyone beneath it.
</Info>

## What you get notified about

Beebole sends notifications for a fixed set of events. You control each one independently in your **Notifications** preferences.

| Event                                   | What it covers                                                                            |
| --------------------------------------- | ----------------------------------------------------------------------------------------- |
| **When you're @mentioned**              | Someone @mentions you in a Journal message.                                               |
| **Items you manage are mentioned**      | A project, person, or other item you manage is mentioned.                                 |
| **Items assigned to you are mentioned** | An item assigned to you is mentioned.                                                     |
| **Approval updates**                    | A timesheet you submitted is approved or rejected, or one is submitted for your approval. |

## How notifications reach you

Beebole delivers notifications by **Email**: they arrive in your inbox, approval emails include action buttons so you can approve or reject without opening Beebole, and you can reply to a Journal message straight from the email.

<Info>
  **Email** must be on to receive notifications. Turn it off and the per-event preferences are hidden, because there is nowhere to deliver them.
</Info>

## Choosing how often you're notified

For each event, you pick how often Beebole emails you:

| Frequency   | What it does                                                                    |
| ----------- | ------------------------------------------------------------------------------- |
| **Instant** | Sends a notification as soon as the event happens.                              |
| **Daily**   | Batches the day's events into a single digest, sent at the hour you choose.     |
| **Weekly**  | Batches the week's events into one digest, sent on the day and hour you choose. |
| **None**    | Turns the event off entirely.                                                   |

Daily and weekly digests reduce inbox volume by grouping events into one message instead of sending one email per event.

<Steps>
  <Step title="Open your Notifications preferences">
    Open your own profile, then open the **Notifications** panel.
  </Step>

  <Step title="Enable email">
    Tick **Email**. It must be on to configure events.
  </Step>

  <Step title="Set a frequency per event">
    For each event, choose **Instant**, **Daily**, **Weekly**, or **None**. For **Daily** and **Weekly** you also pick the delivery hour, and for **Weekly** the day of the week.
  </Step>
</Steps>

<Info>
  Your preferences save automatically as you select them — there is no separate save step. To apply the same frequency to every event at once, hold the meta key (⌘ or Ctrl) while clicking a frequency.
</Info>

### When many alerts fire at once

**Instant** never floods your inbox. When more than three notifications of the same kind are waiting for you at the same moment — a whole team submitting their timesheets, for example — Beebole collapses them into one summary instead of one email each. The summary uses the same layout as a digest: it lists the first eight items of each kind, then a count of the rest, with a link to open Beebole.

If another burst of the same kind follows within the next 15 minutes, it is held and delivered as one further summary once that window closes, so a long-running import or a busy afternoon never turns into a stream of near-identical emails.

<Info>
  Summaries are built from the **Digest** email template, so any wording you customize there also applies to these bursts.
</Info>

## Timesheet reminders

Reminders are configured by administrators in **Timesheet and Planning Settings**, not in personal preferences. They prompt people to submit their timesheets and nudge approvers about pending work.

<Steps>
  <Step title="Open Timesheet and Planning Settings">
    Open the organization, a tag, or a person, then open the **Timesheet and Planning Settings** panel and select the **Reminders** tab.
  </Step>

  <Step title="Remind people to submit">
    Next to **Remind to submit**, choose **Start of next period** or **End of current period**, then set the hour the reminder is sent. Click the selected option again to turn it off.
  </Step>

  <Step title="Remind approvers">
    Set **Remind approvers after** a number of **days if not yet approved** to chase pending approvals automatically.
  </Step>
</Steps>

<Info>
  Reminder settings save automatically and cascade like other timesheet settings — set them once on the organization and they apply everywhere, or override them on a tag or person.
</Info>

## Email templates

Administrators can customize the wording of the emails Beebole sends. Email templates live in the **Email templates** panel, where each email type has its own tab, including **Sign Up**, **Sign In**, **Invite**, **Mention**, **Timesheet Submitted**, **Reminder**, **Approval Reminder**, and **Digest**.

<Steps>
  <Step title="Open Email templates">
    Open the organization, a tag, or a person, then open the **Email templates** panel.
  </Step>

  <Step title="Pick the email type">
    Select the tab for the email you want to change.
  </Step>

  <Step title="Edit the content">
    Edit the text in the editor. Insert the listed placeholders (for example, the recipient's name or an action link) where you want Beebole to fill in real values.
  </Step>
</Steps>

<Info>
  Template edits save automatically as you type. To revert a customized email to Beebole's built-in wording, choose **Reset to default template**. Templates inherit down through tags, so a custom template set higher up applies to everyone beneath it unless overridden.
</Info>

## Reliable delivery

Beebole delivers notifications through a background queue so a temporary network or service hiccup does not lose them. If a notification fails to send, Beebole retries it automatically up to three times before marking it as failed. No action is needed on your side — delayed notifications are redelivered once the issue clears.

Emails only go to people who actually belong to the organization — an active account or a still-valid invitation. Archived people are excluded, so departed team members never receive notifications about an account they left.

## Related content

<CardGroup>
  <Card title="Journal" icon="rss" href="/help/documentation/journal">
    @Mentions, approval events, and reminders all appear in the Journal feed.
  </Card>

  <Card title="Approval" icon="circle-check" href="/help/documentation/approval">
    Approval updates and approver reminders are tied to the timesheet approval workflow.
  </Card>

  <Card title="Budget Status report" icon="chart-simple" href="/help/documentation/reports#budget-status">
    Where projects approaching or over their budget are flagged, with no setting to switch on.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I turn off all notifications?">
    Yes. In your **Notifications** preferences in Beebole, turn **Email** off, or set every event to **None**. Either way you stop receiving notifications for those events.
  </Accordion>

  <Accordion title="What is the difference between instant and digest notifications?">
    In Beebole, **Instant** sends a notification the moment an event happens. **Daily** and **Weekly** instead batch events into a single digest sent at the hour — and, for weekly, the day — you choose. Digests cut down on inbox volume while still keeping you informed. Even with **Instant**, a burst of more than three alerts of the same kind arrives as one summary rather than one message each.
  </Accordion>

  <Accordion title="Who sets up timesheet reminders?">
    Administrators set timesheet reminders in Beebole's **Timesheet and Planning Settings** panel, on the **Reminders** tab. Reminders prompt people to submit timesheets and chase approvers about pending work, and they cascade from the organization down through tags and people.
  </Accordion>

  <Accordion title="Can I respond to a notification by email?">
    Yes. Beebole's approval emails include buttons to approve or reject a timesheet without opening Beebole. You can also reply to a Journal message email directly, and Beebole adds your reply to the right thread.
  </Accordion>
</AccordionGroup>


# People: add, invite, and manage your team
Source: https://beebole.com/help/documentation/people

Add, invite, and manage your team members in Beebole. Configure profiles, assign roles, and set up schedules and rates for each person.

In Beebole, **People** represents every user or team member in your account — anyone who tracks time, manages projects, or views reports. Each person has a profile that combines their user account with configuration data like rates, schedules, and permissions.

<Info>
  Every person is assigned a role that determines what they can see and do. Beebole includes default roles (Admin, Employee, Manager), and you can create custom roles to match your organization's structure. See [Roles & permissions](/help/documentation/roles-authorisations).
</Info>

***

## Adding your team

<div>
  <iframe title="Add a Person to Beebole" />
</div>

<Steps>
  <Step title="Open the People page">
    Click **People** in the left sidebar.
  </Step>

  <Step title="Add a person">
    Click the **+** button (**Add person**). Enter the person's **Name**, **Email**, and **Role**.
  </Step>

  <Step title="Add multiple people (optional)">
    To add a large team at once, use the **Or add multiple entries** area of the same panel. Copy rows from a spreadsheet — one person per line: name, then **Tab**, then email — click **Paste**, review the entries, and click **Add them all**.
  </Step>

  <Step title="Add">
    Click **Add person**. The person's profile is now created in your account.
  </Step>
</Steps>

<Info>
  Adding a person and inviting them are two separate actions. A person's profile exists as soon as you save it, but they cannot log in until you send an invitation.
</Info>

<Warning>
  If your subscription has no available seats, Beebole creates the new person as archived automatically. You see a warning message confirming this. Unarchive them once you have a free seat, or upgrade your plan first.
</Warning>

***

## Sending invitations

<Steps>
  <Step title="Open the person's profile">
    Click the person's name in the People list.
  </Step>

  <Step title="Send the invitation">
    Click **Invite by email**. Beebole emails a secure invitation link so they can access their account — no password to set, as sign-in works with one-time email codes or a passkey.
  </Step>

  <Step title="Track status">
    The profile shows an **Invitation pending** status until the person completes their sign-up.
  </Step>
</Steps>

<Tip>
  You can resend invitations at any time from the person's profile if they missed the initial email.
</Tip>

### Bulk invitation

To invite several people at once, select multiple people from the list using the checkboxes, then choose **Invite** from the bulk actions menu. Beebole sends invitation emails to all selected people in a single operation. This is useful when onboarding a new team or following an import.

***

## Configuring person profiles

Click a person's name to access their profile settings:

* **Manages** — See who this person is **Managed by**, plus the team members, projects, tasks, and tags they manage.
* **Tags** — Organize people into departments, teams, or locations. See [Tags](/help/documentation/tags).
* **Custom fields** — Add metadata like "Employee ID", "Office Location", or "Department". See [Custom fields](/help/documentation/custom-fields).
* **Localization** — Set individual timezone and date format preferences.

### Role assignment

Each person is assigned a role that controls what they can see and do in Beebole. You set the role when creating a person, but you can change it at any time. Open the person's profile, go to the **Email & role** panel, and pick a new role from the **Choose a role** selector. The change takes effect immediately — the person's next page load reflects their updated permissions. See [Roles & permissions](/help/documentation/roles-authorisations) for details on what each role can access.

### Schedule assignment

Work schedules define a person's standard working hours and days. To assign a schedule, open the person's profile and click **Work schedule**, then select an existing schedule type from the menu. Optionally set a start date so historic data is not affected. Schedules on a person override any schedule inherited from their tags or the organization default. See [Work schedules](/help/documentation/work-schedule).

### Valid period for time entry

A person's profile can carry a **Valid period for time entry** — a **From** and/or **To** date bounding when time can be recorded for them. Set it to a contractor's engagement dates or an employee's start and end dates: entries outside the window are refused, with a message naming the person whose validity period blocks them. Leave either date empty for an open-ended window.

Projects can carry the same setting — see [Projects](/help/documentation/projects#project-settings).

### Localization per person

You can override the organization's locale settings for any individual. Open the person's profile, then edit the **Localization** attribute to set their **Time zone**, **Date format**, **Time format**, **Decimal format**, and **First day of the week**. These settings affect how the app displays dates and times for that person only — useful for team members in different countries or who prefer a specific format.

***

## Rates and quotas on people

<Info>
  Rates and schedules follow a priority system: settings on a person override those inherited from tags or the organization. See [Billing rates](/help/documentation/billing) for the full priority order.
</Info>

### Billing and cost rates per person

To set a person's rates, open their profile and go to the **Billing** or **Cost** attribute section. Click **Add** to create a new rate entry. Choose the rate type (hourly, daily, or fixed), enter the amount and currency, and set the effective date. You can add multiple rate entries over time to reflect salary changes or contract updates — Beebole uses the rate that was active on the date of each time record. See [Billing rates](/help/documentation/billing) and [Cost rates](/help/documentation/costs).

### Absence quotas per person

Absence quotas define how much time off a person is entitled to for each absence type (for example, 20 days of annual leave). To configure a person's allowances, open their profile and go to the **Absence allowances** attribute section. Click **Add new allowance**, select the absence type, enter the amount, and set the validity period. You can also enable carry-forward and allow negative balances depending on your policy. Quotas set on a person take priority over any default defined on a tag. See [Time off](/help/documentation/timeoff).

### Custom fields on persons

Custom fields let you extend a person's profile with structured metadata beyond the built-in fields. Common uses include storing an employee ID, cost center, office location, or contract type. To add a value, open the person's profile and fill in any custom fields that appear in the **Attributes** section. The available fields are defined globally in **Settings** > **Custom Fields** and apply to all people. See [Custom fields](/help/documentation/custom-fields).

***

## Archiving and offboarding

<Warning>
  Do not delete a person if you want to keep their historical time data. Use **Archive** instead — this frees up a seat while preserving all their records for reports.
</Warning>

To archive a person, open their profile, click the **⋯** action menu next to their name, and select **Archive**. You can unarchive them at any time from the same menu.

<Info>
  Unarchiving requires a free seat on your subscription. If no seats are available, the **Unarchive** option is disabled. Upgrade your plan or archive another person first.
</Info>

### Bulk operations <Badge>Admin only</Badge>

Select multiple people from the list using the checkboxes to perform actions in bulk. The following bulk actions are available from the actions menu:

* **Invite** — Send invitation emails to all selected people at once.
* **Archive** — Archive multiple active people in a single step.
* **Unarchive** — Restore multiple archived people (requires available seats).
* **Delete** — Permanently delete multiple people. Use with caution — deletion cannot be undone, and deleted people can no longer sign in to Beebole.

***

## Related content

<CardGroup>
  <Card title="Roles & permissions" icon="shield" href="/help/documentation/roles-authorisations">
    Configure what each person can see and do in Beebole with granular role-based permissions.
  </Card>

  <Card title="Tags" icon="tag" href="/help/documentation/tags">
    Organize people into departments, teams, and locations for better reporting and inherited configuration.
  </Card>

  <Card title="Work schedules" icon="clock" href="/help/documentation/work-schedule">
    Define standard working hours and days for individuals or groups.
  </Card>

  <Card title="Cost rates" icon="chart-bar" href="/help/documentation/costs">
    Track the internal cost of each team member's time for profitability reporting.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What happens when someone leaves the company?">
    Archive their profile instead of deleting it. This preserves all their historical time data for your reports while freeing up the user seat on your subscription.
  </Accordion>

  <Accordion title="Can I create custom roles beyond Admin, Manager, and Employee?">
    Yes. Go to **Settings** > **Person Roles** to create custom roles with granular permissions. See [Roles & permissions](/help/documentation/roles-authorisations).
  </Accordion>

  <Accordion title="Can I add multiple people at once?">
    Yes. Click **People** in the sidebar, then **Add person**. In the **Or add multiple entries** area, copy rows from a spreadsheet — one person per line: name, then **Tab**, then email — click **Paste**, and confirm with **Add them all**.
  </Accordion>

  <Accordion title="What happens if I add a person when all seats are taken?">
    Beebole creates the person as archived automatically and displays a warning. The person cannot log in until you unarchive them. Unarchiving requires a free seat — either archive another person first or upgrade your subscription.
  </Accordion>

  <Accordion title="Can I sign in as another user for troubleshooting?">
    Yes. Administrators can use the **Sign in as…** <Badge>Admin only</Badge> action to sign in as another person. This is useful for diagnosing issues or verifying what a team member sees.
  </Accordion>
</AccordionGroup>


# Task planning: create, organize, and track tasks
Source: https://beebole.com/help/documentation/planning

Tasks in Beebole are independent planning entities. Create them one by one or from a spreadsheet, organize statuses and subtasks, assign owners, and track time.

Tasks in Beebole are independent planning entities — units of work that you schedule, assign, and track time on. A task is not a sub-element of a project: tasks live on their own **Planning** page, and linking a task to a project is optional. Use tasks to plan the work to be done, and let your team track time directly on them.

<Info>
  To work with tasks, click **Planning** in the sidebar. The same tasks can be displayed in four views: the [Gantt chart](/help/documentation/gantt) for timelines, the [Kanban board](/help/documentation/kanban) for status columns, the [Staffing view](/help/documentation/staffing) for planning by person, and the [List view](/help/documentation/task-list) for working the list as a sortable table.
</Info>

<div>
  <iframe title="Create and Plan Tasks" />
</div>

***

## How tasks relate to projects

[Projects](/help/documentation/projects) describe what hours are logged *into*; tasks describe the work *to be done*. The two are connected but independent:

* A task can exist without any project. You can plan, assign, and complete it entirely on the **Planning** page.
* A task can be linked to projects through its **Projects** attribute in the task detail panel.
* Time can be tracked on tasks directly, in the **Tasks** section of the [timesheet](/help/documentation/timesheets).

For general work that isn't planned as a task, track time on projects and subprojects instead.

***

## Plannings

Every task belongs to a planning — a separate board with its own statuses and its own level names for the hierarchy. New Beebole accounts start with one planning named **Main plan**, with the statuses **Backlog**, **Queue**, **In progress**, and **Done**.

* **Switch plannings** — Click the planning name at the top of the **Planning** page and pick another one from the menu.
* **Create a planning** — In the same menu, type a name in the **Name of a new planning** field and click **Add**.

Statuses always belong to a planning, not to a project: each planning defines its own workflow. See [Statuses](#task-statuses) below.

***

## Creating a task

<Steps>
  <Step title="Open the Planning page">
    Click **Planning** in the sidebar, and check that the right planning is selected at the top of the page.
  </Step>

  <Step title="Click Add Task">
    Click the **Add Task** button. A form opens in the side panel.
  </Step>

  <Step title="Name the task and pick a status">
    Type the task name, and pick a status with the status selector below the name.
  </Step>

  <Step title="Submit">
    Click **Add new task** (or press **Enter**). The task appears in the active view, and you can fill in dates, owner, and other details from its panel.
  </Step>
</Steps>

<Tip>
  Press **⌘+A** (Ctrl+A on Windows) anywhere on the **Planning** page to open the add form. If a task is currently open, the new task is created as its subtask.
</Tip>

A new task doesn't get a color of its own. It takes the color of its project, its owner, or its parent task, and shows that same color everywhere it appears — badges, dots, timesheet section headers, timers, and mentions. Pick a color on the task itself only when you want it to stand apart from the work it belongs to.

### Adding many tasks at once

You can import a whole task list by pasting it from a spreadsheet — there is no file upload involved.

<Steps>
  <Step title="Open the add panel">
    Click **Add Task**. Below the form, find the **Or add multiple entries** section.
  </Step>

  <Step title="Copy and paste your list">
    Copy rows from a spreadsheet — one entry per line, using **Tab** or spaces to indent sub-levels — then click **Paste**. Indented lines become subtasks of the line above.
  </Step>

  <Step title="Review and confirm">
    Beebole shows the entries **Ready to import** as a tree. Remove any line you don't want, then click **Add them all**.
  </Step>
</Steps>

Imported tasks get the status selected in the add form. After the import you can click **Undo** to remove everything you just added, or **New import** to paste another batch.

***

## Task statuses

Statuses are the steps of a planning's workflow — the same statuses that form the columns of the [Kanban board](/help/documentation/kanban). To edit them, open the **Task statuses** modal:

* On the Kanban board, click a column's name.
* In the task detail panel, click the gear button next to the status (tooltip: **Edit statuses**).

In the modal you can:

* **Add a status** — Type its name in the **Add new status** field and confirm.
* **Rename or recolor a status** — Click a status to edit its name or pick a new color.
* **Reorder statuses** — Drag a status up or down. The order defines the column order on the Kanban board.
* **Limit a status** — Set **Max tasks** to cap how many tasks the status can hold. See [WIP limits](/help/documentation/kanban#wip-limits-are-hard-limits).
* **Delete a status** — Only possible when the status holds no tasks (including archived ones). Every planning must keep at least one status.

***

## Assigning tasks

Beebole distinguishes the person responsible for a task from the people it is available to:

* **Owner** — The single person doing the task. Pick them in the task detail panel (**Select the owner**); a task can only have one owner. Next to the owner you can set **% FTE**, the share of their working time dedicated to the task — Beebole uses the owner's [work schedule](/help/documentation/work-schedule) and this percentage when fitting planned time between the task's dates.
* **Potential owners** — People or [tags](/help/documentation/tags) the task is assigned to. In filters, these appear as **Potential owner** and **Potential owner tag**.

<Info>
  Beebole can warn everyone involved before a task with no owner starts: the task manager and the assigned people are notified — the admins when the task has no manager. Configure the number of days in [Timesheet and Planning Settings](/help/documentation/timesheetSettings#reminders).
</Info>

***

## Subtasks and hierarchy

Tasks nest into subtasks, as deep as your plan requires. The hierarchy is shared by all views.

* **Create a subtask** — Hover over a task name in the Gantt task list and click the **+** button that appears, or select the task and press **⌘+A**.
* **Indent or outdent with the keyboard** — In the Gantt view, select a task and press **Tab** to make it a subtask of the task above it, or **Shift+Tab** to move it up one level.
* **Move a task under a different parent** — Hover over the breadcrumb above the task's name (in the detail panel or on a Kanban card), click the edit button (**Change parent**), and pick the new parent with **Choose a task**. The list only offers tasks from the same planning.
* **Expand and collapse** — Click the chevron next to a parent task. **⌘+Click** the chevron to expand or collapse all.

A parent task rolls up its children: it shows the period spanned by its subtasks and their total **Planned in hours**, read-only.

***

## Scheduling dates and planned time

Open a task's detail panel to set its schedule:

* **Dates** — Pick the start and end dates with the date-range picker. A task runs over whole days by default; uncheck **All day** to give it exact start and end times instead — see [giving a task hours](/help/documentation/gantt#giving-a-task-hours).
* **Planned in hours** / **Planned in days** — Enter the planned amount of work. Next to the value, a pill shows the capacity the owner's schedule leaves between the task's dates; hover it to read the planned time against that capacity.
* **Date locks** — Lock buttons flank the date picker (**Lock start date** and **Lock end date**). One edge is locked at a time — the start by default. When planned time no longer fits between the dates, Beebole moves the *unlocked* edge: with the end date locked, the start moves earlier; with the start locked, the end extends. When planned time overflows the period, the pill turns red and grows two arrows: the down arrow cuts the planned time to what the period holds (its tooltip names both figures, as in **Reduce 12h to 8h**), and the up arrow moves the unlocked edge out to fit the planned time (its tooltip names the new date, as in **Change end date to 12 Mar 2026**).

If the owner already has another task with planned time in the same period, the panel shows an **Overlapping tasks causing overload** warning so you can rebalance.

To sequence tasks — making one start after another ends — use [dependencies in the Gantt chart](/help/documentation/gantt#task-dependencies).

***

## Tracking time on tasks

Time entries can be recorded directly against tasks:

* **From the timesheet** — People add rows in the **Tasks** section of their [timesheet](/help/documentation/timesheets) and log hours on a task, just like on a project. Tasks someone owns are listed first in the add-task picker, so their own work is quickest to reach.
* **From a suggestion** — A dated task assigned to someone reaches them as a [suggested entry](/help/documentation/ai#suggested-time-entries) rather than being added to their timesheet as a row automatically. Accepting the suggestion creates the entry and pins the row.
* **From a Kanban card** — Hover over a card and click the clock button (**Add time**) to log time on that task for today. Once time is logged, the card shows a pill with the logged total next to the planned time (for example `4h / 8h`). See [Kanban board](/help/documentation/kanban#tracking-time-from-a-card).

Which plannings accept time entries is controlled by the **Record time on these plannings** setting, in the **Categories** tab of [Timesheet and Planning Settings](/help/documentation/timesheetSettings). Tasks in other plannings don't show the time button.

You can also let task statuses drive time records automatically with **Auto Timesheet from Planning** — choose a **Start** and an **End** status per planning, and moving a task into those statuses starts and ends its time records, as suggestions the person accepts or written directly into the timesheet. Set it up in the [Auto Timesheet from Planning tab](/help/documentation/timesheetSettings#auto-timesheet-from-planning).

<Info>
  From a person's or a project's action menu, **Go to tasks** jumps to the **Planning** page filtered on that person or project.
</Info>

***

## Descriptions, custom fields, and tags

Beyond scheduling, each task carries:

* **Description** — A rich-text panel for context, acceptance criteria, links, and file attachments, with @mentions to reference teammates. See [task descriptions](/help/documentation/kanban#task-descriptions) for the editor's features.
* **Custom fields** — Organization-defined fields (text, numbers, dates, URLs, booleans) that appear in the task detail panel. Define them in **Settings** > **Custom Fields** and make them visible for tasks — visibility can even be limited to specific plannings. See [Custom fields](/help/documentation/custom-fields).
* **Tags** — Label tasks with [tags](/help/documentation/tags) to group and filter them across categories, and to report on them by team, client, or any dimension you define.

***

## Archiving and deleting tasks

Each task has a **⋯** action menu — hover over its row in the Gantt view or its Kanban card — with **Duplicate**, **Rename**, **Archive**, **Unarchive**, and **Delete**.

* **Archive** hides the task from active views without losing its data or its time records. Use **Show Archived** in the page header to display archived tasks again, then **Unarchive** to restore one. On the Kanban board, a column's own menu can archive or unarchive every task in that status at once.
* **Delete** removes the task permanently. A toast appears with an **Undo** button right after deletion.

<Warning>
  A task that has time records logged against it cannot be deleted — Beebole blocks the deletion and tells you whose time records are affected. Archive the task instead to keep historical data intact.
</Warning>

***

## Viewing tasks your way

The **Planning** page shows your tasks through saved views — tabs above the task list. Click **Add a view** and pick **Gantt chart**, **Kanban**, **Staffing**, or **List**; each view remembers its own settings (columns, grouping, period, sort, or card fields). Use the **Filters** button to narrow any view by task, status, owner, potential owner, project, or tags — the button shows the active filter count, and toggling it off keeps the filters for later.

<CardGroup>
  <Card title="Gantt chart" icon="chart-gantt" href="/help/documentation/gantt">
    Schedule tasks on a timeline, link dependencies, and spot overloaded owners with the workload heatmap.
  </Card>

  <Card title="Kanban board" icon="square-kanban" href="/help/documentation/kanban">
    Move task cards through status columns, set WIP limits, and start time records from a card.
  </Card>

  <Card title="Staffing" icon="users" href="/help/documentation/staffing">
    Book people onto projects on a per-person timeline and balance workload against capacity.
  </Card>

  <Card title="List view" icon="table-list" href="/help/documentation/task-list">
    Sort the same tasks as a table, edit their fields in place, and change many at once.
  </Card>
</CardGroup>

***

## Related content

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    How people log hours — including time tracked on tasks.
  </Card>

  <Card title="Timesheet and Planning Settings" icon="sliders" href="/help/documentation/timesheetSettings">
    Control which plannings accept time entries and configure Auto Timesheet from Planning.
  </Card>

  <Card title="Custom fields" icon="list-check" href="/help/documentation/custom-fields">
    Add structured data to tasks and use it in reports.
  </Card>

  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Set up the project structure your time entries are logged against.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Are tasks part of projects in Beebole?">
    No. Tasks in Beebole are independent planning entities with their own page, statuses, and hierarchy. You can link a task to projects through its **Projects** attribute, but a task doesn't need a project to exist, be assigned, or have time tracked on it.
  </Accordion>

  <Accordion title="How do I import many tasks at once?">
    Copy rows from a spreadsheet and paste them into Beebole. Click **Add Task**, find **Or add multiple entries**, click **Paste**, review the list, and click **Add them all**. Indent lines with Tab to create subtasks. There is no CSV file upload — the import works by pasting.
  </Accordion>

  <Accordion title="Can people track time on any task?">
    Only on tasks in the plannings selected under **Record time on these plannings** in Beebole's **Timesheet and Planning Settings**. Tasks in those plannings appear in the **Tasks** section of the timesheet and show the **Add time** button on their Kanban cards.
  </Accordion>

  <Accordion title="What is the difference between the Owner and the Potential owners of a task?">
    The **Owner** is the single person doing the task — Beebole uses the owner's work schedule and **% FTE** to fit planned time between the task's dates, and a task can only have one owner. **Potential owners** are the people or tags the task is assigned to; in filters they appear as **Potential owner** and **Potential owner tag**.
  </Accordion>

  <Accordion title="Should I archive or delete a finished task?">
    Archive it. Archiving hides the task from active views while keeping its time records for reporting, and you can unarchive it anytime. Deleting is permanent, and Beebole blocks the deletion entirely if time records exist against the task.
  </Accordion>
</AccordionGroup>


# Managing projects and project categories
Source: https://beebole.com/help/documentation/projects

Create projects and subprojects in Beebole, organize them into categories, add many at once from a spreadsheet, and control rates, budgets, and access.

Projects in Beebole are what your team logs time against. Every report, budget, and billing calculation builds on your project structure, so organizing it well pays off across the whole account. Projects live in categories you define and can be nested into subprojects as deep as you need.

***

## How projects are organized

Beebole uses a flexible hierarchy with three building blocks:

* **Categories** — The broadest grouping. A new account starts with **Client**, **Internal**, and **Activity**. Each project belongs to exactly one category.
* **Projects** — The engagements or work streams inside a category, such as a client account or an internal initiative.
* **Subprojects** — Smaller pieces of work nested under a project. There is no fixed depth limit, and each category names its own levels (for example, the **Client** category starts with the levels **Project** and **Subproject**).

Projects describe *what* your team works on. To group projects and people across other dimensions — departments, locations, service lines — use [tags](/help/documentation/tags) instead of deepening the project hierarchy.

### Only the lowest level accepts time

Time is always recorded at the bottom of a branch. A project that has active subprojects aggregates their time in reports and cannot be recorded against: the project pickers only offer the lowest level, and an entry that still reaches a parent is refused with *You cannot record time on a project that has sub-projects.* Archived subprojects don't count, so archiving the last subproject of a project hands the parent back as a bookable one.

[Tasks](/help/documentation/planning) follow the same rule — a task with subtasks aggregates its children and cannot carry time either.

<Info>
  Which project categories your team can record time on is controlled by the **Record time on these project categories** setting, in the **Categories** tab of the **Timesheet and Planning Settings** panel. Open it from **Settings** > **Account Settings**.
</Info>

***

## Creating a project

<Frame>
  <iframe title="Create a Project in Beebole" />
</Frame>

<Steps>
  <Step title="Open the Projects page">
    Click **Projects** in the sidebar.
  </Step>

  <Step title="Pick a category">
    Click the category name next to the **Projects:** heading and select the category the project belongs in. To create a new category, type its name in the field at the bottom of that menu and click **Add**.
  </Step>

  <Step title="Add the project">
    Click the **Add \[category]** button at the top right — its label shows the active category, for example **Add Client**. Enter the project name and click the **Save new…** button (its label ends with the level you are creating, for example **Save new project**).
  </Step>

  <Step title="Add subprojects (optional)">
    In the project list, expand the parent project, then click the **+** button next to the level name below it (its tooltip reads **Add** followed by the level name, for example **Add Subproject**).
  </Step>
</Steps>

### Adding several projects at once

When the add panel is open, use the **Or add multiple entries** area below the name field:

1. Copy rows from a spreadsheet — one entry per line, using **Tab** or spaces to indent sub-levels.
2. Click **Paste**.
3. Review the entries to be imported, then click **Add them all**. If something looks wrong, click **Undo**.

***

## Managing categories and level names

Click the category name next to the **Projects:** heading to open the category menu. From there you can:

* Switch to another category by clicking its name.
* Add a category — type a name in the field and click **Add**.
* Rename a category — hover over it, click the pencil icon, edit the name, and click **Ok**.
* Delete a category — hover over it and click the trash icon.

To rename a hierarchy level, expand a project in the list and click the level name shown above its children — the tooltip reads **Click to edit the level name for the whole category**. The new name applies to that level across the whole category.

***

## Moving a project in the hierarchy

You move a project by changing its parent from the project's detail panel:

<Steps>
  <Step title="Open the project">
    Click **Projects** in the sidebar, then click the project to open its details.
  </Step>

  <Step title="Open the parent selector">
    Hover over the breadcrumb above the project name and click the **Change parent** button that appears.
  </Step>

  <Step title="Pick the new parent">
    Select the new parent project or the category root. The change is saved immediately, and the project's subprojects move with it.
  </Step>
</Steps>

<Info>
  A project can only be moved within its own category — the parent selector lists destinations from the same category and excludes the project's own subprojects.
</Info>

***

## Project settings

Clicking a project opens its detail panel, which is organized into settings panels. Open panels appear first; the remaining ones are listed below — click a panel's name to open it. Changes are saved automatically.

| Panel                           | What it controls                                                                                                 |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| **Managed by**                  | The people who manage this project.                                                                              |
| **Tags**                        | The [tags](/help/documentation/tags) applied to the project. Subprojects inherit tags from their parent project. |
| **Billing**                     | Project-level [billing rates](/help/documentation/billing).                                                      |
| **Cost**                        | Project-level [cost rates](/help/documentation/costs) for profitability tracking.                                |
| **Budgets**                     | Spending or effort ceilings for the project. See [Budgets](/help/documentation/budgets).                         |
| **Expenses**                    | The expenses recorded against the project. See [Expenses](/help/documentation/expenses).                         |
| **Custom fields**               | Values for the custom fields defined for projects. See [Custom fields](/help/documentation/custom-fields).       |
| **Who has access?**             | Who can use the project — see below.                                                                             |
| **Secondary projects allowed**  | Whether people can log time to a secondary project alongside this one.                                           |
| **Show or hide**                | Which secondary projects, expense types, and custom fields are available on this project.                        |
| **Valid period for time entry** | **From** and **To** dates limiting when time can be recorded on the project.                                     |
| **Description**                 | Free-form notes about the project.                                                                               |

### Billing and cost rates per project

Open the project's **Billing** or **Cost** panel and click **Add** to create a rate. Choose a method — **Hourly rate**, **Daily rate**, or **Fixed fee** — and optionally split it with **Split by persons**, **Split by projects**, or **Split by tags**. A rate set directly on a project overrides rates inherited from tags or the organization. See [Billing rates](/help/documentation/billing) for the full priority order and repeat options.

### Valid period for time entry

The **Valid period for time entry** panel bounds when time can be recorded on the project: set a **From** and/or **To** date, and entries outside that window are refused with a message naming the project that blocks them. Use it to close a finished project without archiving it, or to open a project for booking only from its actual start date. The window set on a project also applies to its subprojects; when several projects in the chain define one, the most specific project's window wins. People can carry the same setting — see [People](/help/documentation/people#valid-period-for-time-entry).

### Custom fields on a project

The fields shown in the **Custom fields** panel come from the field definitions in your account — you fill in values there, but you create and scope the fields themselves in **Settings** > **Custom Fields**. Custom field values appear as dimensions and filters in [reports](/help/documentation/reports).

***

## Controlling who can track time on a project

The **Who has access?** panel decides who can use the project:

* A toggle switches the project between **Available to everyone** and **Unavailable to everyone**. The default comes from your organization's **Show or hide by default** settings.
* **Individually** — add specific people with the **Select person** field.
* **By tags** — make the project available to everyone in a tag with the **Select tag** field.

See [Assignments](/help/documentation/assignments) for how availability defaults and exceptions work together, and [Roles & permissions](/help/documentation/roles-authorisations) for what each person can see and do.

You can also restrict an expense type to specific projects from the expense type's own **Who has access?** panel — see [Expenses](/help/documentation/expenses).

***

## Duplicating, archiving, and deleting projects

Each project has a **⋯** action menu — it appears when you hover over the project's row in the list, and next to the project name in its detail panel. It offers:

* **Duplicate** — create a copy of the project.
* **Rename** — edit the project name in place.
* **Go to tasks** — open the Tasks view filtered to this project's tasks.
* **Archive** / **Unarchive** — retire the project or bring it back.
* **Delete** — remove the project.

Archived projects are hidden from the list — click **Show Archived** at the top of the page to display them (the label includes the count), and **Hide Archived** to hide them again. Their recorded time stays available in reports.

<Warning>
  **Delete** permanently removes the project. To retire a completed project while keeping its history in reports, use **Archive** instead. If you delete by mistake, click **Undo** in the notification that appears right after.
</Warning>

***

## Related content

<CardGroup>
  <Card title="Tags" icon="tag" href="/help/documentation/tags">
    Group projects and people by department, location, or any other dimension, and cascade configuration through tags.
  </Card>

  <Card title="Budgets" icon="chart-bar" href="/help/documentation/budgets">
    Set billing, cost, or hours budgets on your projects and track progress.
  </Card>

  <Card title="Billing rates" icon="money-bill" href="/help/documentation/billing">
    Configure billing rates at the organization, tag, project, or person level.
  </Card>

  <Card title="Assignments" icon="user-check" href="/help/documentation/assignments">
    Control which projects, expense types, and custom fields are available to each person or group.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How deep can the project hierarchy go in Beebole?">
    Beebole doesn't impose a fixed nesting limit — you can keep adding subprojects under subprojects. In practice, structures stay easiest to navigate and report on at four levels or fewer. Keep in mind that only the lowest level of each branch accepts time entries; the projects above it aggregate their subprojects' time in reports.
  </Accordion>

  <Accordion title="Can I move a project to a different category?">
    The **Change parent** control in Beebole moves a project anywhere within its own category — under another project or back to the top level. It does not move projects between categories.
  </Accordion>

  <Accordion title="Can I restrict which people track time on a project?">
    Yes. Open the project's **Who has access?** panel in Beebole to make it unavailable to everyone and then grant access individually or by tags. See [Assignments](/help/documentation/assignments) for the full availability model.
  </Accordion>

  <Accordion title="Can different people have different billing rates on the same project?">
    Yes. When adding a rate in the project's **Billing** panel, choose **Split by persons** to set a different rate for each team member. See [Billing rates](/help/documentation/billing) for details.
  </Accordion>

  <Accordion title="What happens when I archive a project?">
    The project disappears from the active list in Beebole, and its recorded time remains available in reports. Click **Show Archived** to display archived projects, and use **Unarchive** in the **⋯** action menu to make one active again.
  </Accordion>
</AccordionGroup>


# Public holidays: country calendars and custom days
Source: https://beebole.com/help/documentation/public-holidays

Set up country-specific public holiday calendars and add custom or regional holidays for your team in Beebole to streamline absence and capacity planning.

Beebole's public holidays feature lets you define which days are non-working days for your team. You can load country-specific public holiday calendars and add custom holidays to match your organization's schedule. Public holidays appear on timesheets and are factored into work schedule calculations, reports, and time-off balances.

<Info>
  Public holidays work alongside [work schedules](/help/documentation/work-schedule). When a public holiday falls on a scheduled work day, Beebole automatically accounts for it in capacity and reporting calculations.
</Info>

***

## Loading a country-specific calendar

Beebole includes built-in public holiday calendars for many countries. Loading a calendar pre-fills the standard national holidays for the selected year.

<Steps>
  <Step title="Open the Public holidays panel">
    Go to **Settings** > **Account Settings** and open the **Public holidays** panel. The same panel is also available on a tag or a person — see [Assigning holidays to specific groups](#assigning-holidays-to-specific-groups).
  </Step>

  <Step title="Select a country">
    Choose the **Country** — and optionally a **Region** and **Language** — then click **Load holidays**. Beebole populates the calendar with that country's official public holidays.
  </Step>

  <Step title="Review the holidays">
    Check the list of imported holidays for the selected **Year**. You can remove any that do not apply to your organization or edit their dates and names. Every change is saved automatically.
  </Step>
</Steps>

<Tip>
  If your team spans multiple countries, you can assign different public holiday calendars to different groups using tags. This ensures each person sees only the holidays relevant to their location.
</Tip>

***

## Adding custom holidays

You can add holidays that are specific to your organization — company-wide days off, regional observances, or any other non-working day not covered by the built-in calendars.

<Steps>
  <Step title="Open the Public holidays panel">
    Go to **Settings** > **Account Settings** and open the **Public holidays** panel (or open the panel on the relevant tag or person).
  </Step>

  <Step title="Add a holiday">
    In the empty row at the bottom of the holiday list, pick the date and type the holiday's name, then click **Add**. The custom holiday is saved and appears in the calendar alongside any country-specific holidays.
  </Step>
</Steps>

***

## Editing and removing holidays

To modify an existing holiday, click its date or name in the list and update it — changes are saved automatically. To remove a holiday, click the remove icon at the end of its row.

<Warning>
  Removing a public holiday may affect timesheet calculations and reports for periods that include that date. Review any submitted or approved timesheets that overlap with the removed holiday.
</Warning>

***

## Assigning holidays to specific groups

By default, the calendar configured on **Account Settings** applies to everyone in your account. If your organization has teams in different countries or regions, the same **Public holidays** panel is available on tags and people:

* **By tag** — Click **Tags** in the sidebar, open the tag (e.g., "US Office", "UK Office"), and configure its **Public holidays** panel so only people with that tag get those holidays.
* **By person** — Click **People** in the sidebar, open the person, and configure their **Public holidays** panel to override the calendar for that individual.

This ensures each person's timesheet reflects the correct public holidays for their location.

<Info>
  When a person has both a tag-level and a person-level holiday calendar, the person-level setting takes priority.
</Info>

***

## How public holidays affect timesheets and reports

Public holidays interact with several parts of Beebole:

| Area                  | Effect                                                                                                                                        |
| --------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| **Timesheets**        | Public holidays are highlighted on the timesheet. Depending on your settings, people may or may not be required to log time on these days.    |
| **Work schedules**    | Public holidays reduce the expected working hours for the period. A person's capacity calculation accounts for public holidays automatically. |
| **Reports**           | Reports that include capacity or availability metrics factor in public holidays when calculating expected versus actual hours.                |
| **Time off balances** | Public holidays do not count against a person's time-off allowance — they are separate from absence types like vacation or sick leave.        |

***

## Year-to-year management

Public holiday calendars are managed per year through the **Year** selector in the **Public holidays** panel. The selector covers a rolling window of two years back and three years ahead, so you can review recent past years as well as prepare upcoming ones.

At the start of each new year:

<Steps>
  <Step title="Select the new year">
    In the **Public holidays** panel, pick the new year in the **Year** selector. Beebole loads the country's official holidays for new years automatically as they become available.
  </Step>

  <Step title="Review and adjust">
    Some public holidays shift dates year to year (e.g., Easter). Verify that all dates are correct for the new year, and add any custom holidays again — they are defined per year. Every change is saved automatically.
  </Step>
</Steps>

<Info>
  Need to switch countries? Pick a new **Country** (and **Region**, if any) and click **Load holidays** — the country can be changed at any time. Every year's holidays, past years included, re-derive from the new country; your own custom edits are kept when you reload the same country.
</Info>

<Info>
  Previous years' holiday calendars remain in the system for historical reporting. Updating the current year does not affect past data.
</Info>

***

## Related content

<CardGroup>
  <Card title="Time Off" icon="calendar" href="/help/documentation/timeoff">
    Configure absence types and allowances that work alongside public holidays.
  </Card>

  <Card title="Accruals" icon="clock" href="/help/documentation/accruals">
    Set up automatic leave accrual policies linked to absence types.
  </Card>

  <Card title="Work Schedule" icon="users" href="/help/documentation/work-schedule">
    Define working hours so public holidays reduce capacity correctly.
  </Card>

  <Card title="Tags" icon="folder" href="/help/documentation/tags">
    Use tags to assign country-specific holiday calendars to different groups.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do public holidays count against a person's time-off balance?">
    No. Public holidays are separate from absence types like vacation or sick leave. They reduce the expected working hours for a period but do not consume any time-off allowance.
  </Accordion>

  <Accordion title="Can I have different holiday calendars for different offices?">
    Yes. Configure the **Public holidays** panel on a tag to give that group its own calendar. For example, load the US calendar on the "US Office" tag and the UK calendar on the "UK Office" tag.
  </Accordion>

  <Accordion title="What happens if a public holiday falls on a weekend?">
    Beebole applies the holiday to the date as configured. If the holiday falls on a non-working day according to the person's work schedule, it has no effect on their expected hours. If your country observes a substitute day (e.g., the following Monday), add that substitute date as a custom holiday.
  </Accordion>

  <Accordion title="Do I need to reload the calendar every year?">
    No. Once a country calendar is configured, Beebole loads the country's official holidays for new years automatically as they become available. Use the **Year** selector to review them, and add your custom holidays for each new year — those are defined per year.
  </Accordion>

  <Accordion title="Can I bulk-import public holidays?">
    The fastest approach is to load a built-in country calendar, which imports all national holidays at once. You can then add or remove individual entries as needed.
  </Accordion>
</AccordionGroup>


# Quickstart: set up your time tracking account
Source: https://beebole.com/help/documentation/quickstart

Set up Beebole in six steps — create your account, add your first project and team, track time, run a report, and adjust key settings.

Beebole gives teams a clear picture of where time goes: people log hours against projects, and reports do the rest. This quickstart takes you from a brand-new account to your first report in six steps. You'll be up and running in under 20 minutes.

## Step 1: Create your account

Go to [app.beebole.com/signup](http://app.beebole.com/signup), and fill in your name, work email, and company name — or sign up with Google or Microsoft. Beebole is passwordless: instead of setting a password, you'll confirm your email with a one-time code each time you sign in. A short welcome questionnaire follows, then you're in.

<Info>
  Your 30-day free trial includes every Beebole feature, with no seat limit and no credit card required.
</Info>

***

## Step 2: Create your first project

Projects are what your team logs time against. Projects live inside categories — your new Beebole account already includes three: **Clients**, **Internal**, and **Activities** — and each category comes with some sample projects so you can see the structure in action.

<div>
  <iframe title="Create a Project in Beebole" />
</div>

<Steps>
  <Step title="Go to Projects">
    Click **Projects** in the sidebar.
  </Step>

  <Step title="Pick a category">
    Use the category selector next to the **Projects** title to choose where the project belongs. For example, **Clients** for client work or **Internal** for everything else. The existing categories can be modified or deleted. A new category can be added by entering the name in the field at the bottom of the selector menu and clicking **Add**.
  </Step>

  <Step title="Add the project">
    Once you have chosen a category, click the **+ Add** button at the top of the page. Its label names the open category, for example, **Add Clients**.
  </Step>

  <Step title="Name the project and confirm">
    Type the project name in the field that appears and click the **Save new** button. The project is immediately available for time tracking.
  </Step>
</Steps>

<Tip>
  Start small — one or two real projects are enough to see how your team tracks time. Projects can hold subprojects at any depth, so you can refine the structure later. Learn more on the [Projects](/help/documentation/projects) page.
</Tip>

<Info>
  Need to add several projects at once? Beebole supports bulk entry across projects, people, tasks, and more: open the add panel, look for the **Or add multiple entries** area, copy rows from a spreadsheet, and click **Paste**. Beebole reads each row and lets you confirm before saving.
</Info>

***

## Step 3: Invite your team

Each team member gets their own profile and logs their own hours. Your account comes with three ready-made roles — **Admin**, **Employee**, and **Manager** — that control what each person can see and do in Beebole.

<div>
  <iframe title="Add a Person to Beebole" />
</div>

<Steps>
  <Step title="Go to People">
    Click **People** in the sidebar.
  </Step>

  <Step title="Add a team member">
    Click the **+ Add Person** button at the top of the screen, then enter the person's **Name**, **Email**, and **Role**. **Employee** is the right starting point for most team members.
  </Step>

  <Step title="Confirm">
    Click **Add Person**. The profile now exists in your account. You may want to configure a person's settings before inviting them to the platform.
  </Step>

  <Step title="Invite them">
    Open the person's profile and click the **Invite by email** button. Beebole emails them a secure link, and the profile shows **Invitation pending** until they join.
  </Step>
</Steps>

<Tip>
  Adding a large team? In the same add panel, use the **Or add multiple entries** area: copy rows from a spreadsheet — one person per line, with the name, then a tab, then the email — click **Paste**, review the list, and click **Add them all**.
</Tip>

<Info>
  Adding a person and inviting them are two separate actions in Beebole. A profile exists as soon as you add it, but the person can't sign in until you send the invitation.
</Info>

***

## Step 4: Track your first hours

This is where Beebole delivers its core value. Logging a first entry confirms your setup works and gives you data to report on.

<Steps>
  <Step title="Open your timesheet">
    Click **Timesheet** in the sidebar. Your account already has some example hours logged, so you can see what a filled timesheet looks like. These time entries can be modified or deleted.
  </Step>

  <Step title="Add a row">
    Click the **+** button (**Add a row**) in the top row of the project category section you want to add time for. Then, choose a project from the **Select a project** menu. By default, new accounts are configured to track time first on a Client, then an Activity. 
  </Step>

  <Step title="Log your time">
    Type the time you worked in the cell for the relevant day — or click the timer button on the row (**Start timer**) to record time as you work. Beebole saves each entry automatically.
  </Step>

  <Step title="Add details to a time entry">
    Hover over a time entry and click ⓘ to add more information, such as start and end times, comments, custom fields, work from home, or mark hours as non-billable.
  </Step>
</Steps>

***

## Step 5: Run your first report

With a project and at least one time entry in place, you can turn raw hours into insights. The first time you open the Reports section, Beebole shows sample folders with a few ready-made reports inside.

<Steps>
  <Step title="Open Reports">
    Click **Reports** in the sidebar. Your report folders appear on the left.
  </Step>

  <Step title="Run a sample report">
    Click through to discover default reports like **Hours by person** or **Margin by Client per Month.** Beebole runs the report and displays the results.
  </Step>

  <Step title="Refine and share">
    Click to view the report as a **Table**, **Chart**, or **Matrix**. Each format can be modified to fit your needs. Open the report's **⋯** action menu to change the date range with **Period**, download the results with **Export**, or **Filter**.
  </Step>
</Steps>

***

## Step 6: Adjust the basics

Beebole's account-wide configuration lives in the Settings area, opened from the button with your initials at the bottom of the sidebar. The defaults work out of the box, but these menu items are worth a first look:

| Menu item          | What you configure                                                                                                                                   |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Admin Settings** | Company details and account-wide defaults, including **Show or hide by default** — checkboxes that turn individual features on or off for all users. |
| **Person Roles**   | What each role can see and manage. Adjust the built-in roles or add your own.                                                                        |
| **Work Schedules** | Expected working hours per day, used to flag incomplete timesheets.                                                                                  |
| **Time Off**       | The leave types your team can book — new accounts include **PTO**, **Sick**, and **Seminar**.                                                        |
| **Subscription**   | Your plan, seats, and billing details once the trial ends.                                                                                           |
| **Integrations**   | Connections between Beebole and your other tools.                                                                                                    |

***

## Before you continue: a note on tags

Before you start assigning settings across your projects, people, and tasks, it's worth taking a moment to plan your tags.

Tags are Beebole's cross-cutting labels. Unlike projects or people, which live in their own sections, tags let you group and compare *across* entities in any way that matters to your business. Once applied, they become filters and dimensions in every report.

Your account starts with two default tag types — **Department** and **Location** — but you can create your own under **Settings** > **Tags**.

A few minutes spent deciding which tag types reflect how your business actually measures work will pay off every time you open a report or apply new settings.

See [Tags](/help/documentation/tags) for the full reference.

***

## What's next?

You've completed the essential setup. Here's where to go depending on what matters most for your team:

| Goal                                | Where to go                                     |
| ----------------------------------- | ----------------------------------------------- |
| Track project budgets and spending  | [Budgets](/help/documentation/budgets)          |
| Set up timesheet approval workflows | [Approval](/help/documentation/approval)        |
| Plan and assign future tasks        | [Planning](/help/documentation/planning)        |
| Manage time off and leave           | [Time Off](/help/documentation/timeoff)         |
| Track labor costs and billing rates | [Costs](/help/documentation/costs)              |
| Connect Beebole to your other tools | [Integrations](/help/integrations/introduction) |
| Explore the mobile app              | [Mobile](/help/documentation/mobile)            |

***

## Related content

<CardGroup>
  <Card title="Key Concepts" icon="lightbulb" href="/help/documentation/concepts">
    Understand Beebole's core building blocks and how they relate to each other.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Entering time, duration modes, the timer, and timesheet options in depth.
  </Card>

  <Card title="People" icon="users" href="/help/documentation/people">
    Adding team members, sending invitations, and configuring profiles.
  </Card>

  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    The project hierarchy, project settings, and rates per project.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I add multiple people at once instead of one by one?">
    Yes. Click **People** in the sidebar, click the **+** button (**Add person**), and use the **Or add multiple entries** area of the panel. Copy rows from a spreadsheet — one person per line, with the name, then a tab, then the email — click **Paste**, and confirm with **Add them all**. Beebole creates all the profiles in one pass.
  </Accordion>

  <Accordion title="What's the difference between a project and a category?">
    A category is the top-level grouping on Beebole's Projects page — new accounts start with **Clients**, **Internal**, and **Activities**. Projects sit inside a category and represent the work being tracked, and each project can hold subprojects at any depth. Use whichever depth makes sense for your team.
  </Accordion>

  <Accordion title="Will my team members see each other's time entries?">
    Not with the default roles. In a new Beebole account, the **Employee** role sees only the person's own time entries, the **Manager** role also sees entries for their people and projects, and the **Admin** role sees the whole account. You can adjust or extend these roles under **Settings** > **Person Roles**.
  </Accordion>

  <Accordion title="Do I need to set up tags before my team can start tracking time?">
    No. Tags are optional in Beebole — your team can log time against projects right away. Tags group people, projects, and tasks across dimensions like department or location, and you can add them whenever your reports need that extra breakdown.
  </Accordion>

  <Accordion title="Is there a limit to how many projects or people I can add during the trial?">
    No. Beebole's 30-day free trial includes every feature with no seat limit, so you can add as many projects and people as you need to evaluate it properly. Contact [support@beebole.com](mailto:support@beebole.com) if you have any questions about the trial.
  </Accordion>
</AccordionGroup>


# Reports: analyze time, billing, and costs
Source: https://beebole.com/help/documentation/reports

Run reports in Beebole to analyze tracked time, billing, costs, and budgets — filter and group data, share folders with your team, and export results.

Beebole's reports turn tracked time, expenses, and planned work into answers about productivity, billing, costs, and budgets. Reports live in the **Reports** section of the sidebar, organized into folders, and they run on live data — every time you open a report, Beebole fetches the latest numbers.

<Info>
  Reports respect each person's permissions. A report only ever shows the projects and people the viewer is authorized to see, based on their [role](/help/documentation/roles-authorisations).
</Info>

***

## Open the Reports section

Click **Reports** in the sidebar. The Reports menu on the left lists your report folders — click a folder to see the reports inside, or click **New folder** to add one.

Folders are personal: only you see the folders you create and the reports inside them, plus any folders other people have [shared with you](#share-a-report-folder).

Each folder carries three settings that apply to every report inside it:

* **A period** — the date range the reports cover, chosen with the period selector next to the folder name.
* **Filters** — conditions added with the **Filters** button that narrow the data for the whole folder.
* **A record scope** — the **Absence/working time** setting, which switches every report in the folder to working time only, absences only, or both. Left unset, each report keeps whichever scope it was saved with.

The folder's filter button is highlighted whenever a filter or a record scope is in force, so it's clear when the numbers you're reading are narrowed.

***

## Share a report folder

Reports are shared by sharing their folder. Open the folder and click **Share** next to its name, then pick who gets access:

* **People** — select individual team members.
* **Tags** — select a [tag](/help/documentation/tags) to include everyone tagged by it or its sub-tags.

Only you and the people you share a folder with can see it and its reports. Shared folders are view-only for the recipients — they can open and run the reports, but the owner keeps full control over the folder and the reports inside. Click **Share** again to review or change who has access.

<Info>
  Sharing a folder never overrides permissions: each viewer still only sees the projects, people, and amounts their own [role](/help/documentation/roles-authorisations) allows.
</Info>

***

## Sample reports in a new account

A new Beebole account starts with two sample folders with ready-made reports inside:

| Folder            | Reports                                                       |
| ----------------- | ------------------------------------------------------------- |
| **Current Month** | **Hours by Person**, **Team Calendar**, **Profit by Project** |
| **Current Year**  | **Margin by Client per Month**, **Absences by person**        |

Sample reports are regular reports — open them to see how columns and grouping work, then edit, duplicate, or delete them like any report you create yourself.

***

## What reports can analyze

A report in Beebole is built on one or more record types:

| Record type     | What it contains                                                                                                                                          |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Time records    | Time entries logged in timesheets — both working time and [time off](/help/documentation/timeoff). Absences are time records, not a separate report type. |
| Expense records | [Expense](/help/documentation/expenses) entries, with amounts, quantities, and expense billing                                                            |
| Task records    | The planned effort of [tasks](/help/documentation/planning)                                                                                               |

The columns you add to a report determine which record types it fetches — see [Custom reports](/help/documentation/custom-reports) for how columns work. For time records, a report can also narrow its scope to **Absences only** or **Working time only**.

***

## Run a report

Click a report's name in the folder to open it — Beebole runs it immediately and shows the results. Next to each report name, three buttons toggle how the results display:

* **Table** — rows and columns, with sorting, subtotals, and a frozen header.
* **Chart** — one of 11 chart types with configurable axes.
* **Matrix** — a two-axis grid with a metric per cell and an optional heat map.

You can keep several views open at once. Beebole remembers which views each report uses — like every report setting, the choice is saved automatically. The [Custom reports](/help/documentation/custom-reports) page covers building the output and using the chart and matrix views in detail.

***

## Periods and filters

### Set the period

The period selector next to the folder name controls the date range for every report in the folder. Choose a target — **Current**, **Previous**, **Next**, **Year to date**, **Last 12 months**, or **Custom** with explicit start and end dates — and, for the first three, a granularity: **Day**, **Week**, **Bi-week**, **Semi-month**, **Month**, **Quarter**, or **Year**.

A single report can override its folder's period: open the report's **⋯** action menu and click **Period**. To drop the override and follow the folder again, click **Reset period** in the same menu.

### Filter the data

Add filters with the folder's **Filters** button, or per report via the **⋯** action menu's **Filter** entry. Available filter types:

| Filter                                        | What it narrows                                                                           |
| --------------------------------------------- | ----------------------------------------------------------------------------------------- |
| **Person**, **Project**, **Task**             | Specific people, projects, or tasks                                                       |
| **Owner**, **Status**                         | Tasks by their owner or status                                                            |
| **Person tag**, **Project tag**, **Task tag** | Entities carrying a given [tag](/help/documentation/tags)                                 |
| **Project category**, **Planning**            | Everything in a whole project category, or in a whole planning (task category)            |
| **Billability**, **Marked non-billable**      | Time entries by whether they are **Billable** or **Non-billable**, or marked non-billable |
| **Work location**                             | **Work from home** or **On-site** time entries                                            |
| **Absence/working time**                      | **Absence time only**, **Working time only**, or **Both**                                 |

Filters combine, and each condition can include (**is**) or exclude (**is not**). Filter and period changes are saved automatically and the open report re-runs.

To filter on a whole category, ⌘-click (Ctrl-click on Windows and Linux) the category itself in the **Project** or **Task** list instead of picking one entity — Beebole turns it into a **Project category** or **Planning** condition. What each filter actually covers is described in [Custom reports](/help/documentation/custom-reports#filter-and-scope-the-data).

***

## The report action menu

Every report has a **⋯** action menu with its management actions:

| Action           | What it does                                                                                                                                               |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Duplicate**    | Creates a copy of the report in the same folder                                                                                                            |
| **Filter**       | Adds a filter condition to this report                                                                                                                     |
| **Period**       | Sets a period override for this report                                                                                                                     |
| **Export**       | Downloads the results as **JSON**, **CSV**, **TSV**, **Excel (XLSX)**, **PDF**, **Chart (PNG)**, **Matrix (CSV)**, **Matrix (Excel)**, or **Matrix (PDF)** |
| **Copy**         | Copies the report so you can **Paste** it into another folder's menu                                                                                       |
| **Reset period** | Removes the report's period override (shown only when one is set)                                                                                          |
| **Delete**       | Deletes the report                                                                                                                                         |

The action menu can also move the report straight into another folder — pick the destination from the **Move to** entry's submenu (shown when you own another folder) instead of copying and pasting.

For recurring spreadsheet workflows, see [Data exports](/help/documentation/data-exports) and the [Excel add-in](/help/documentation/excel-addin) and [Google Sheets add-on](/help/documentation/gsheets-addon), which refresh saved report data from inside your spreadsheet.

***

## Budget Status

When your subscription includes budgets and your role can view budgets, a **Budget Status** entry appears at the top of the Reports menu. It shows every project that has a [budget](/help/documentation/budgets) as a progress bar: the solid bar is actual consumption, and a striped forecast bar extends it based on the planned effort of tasks linked to the project. Budgets set on subprojects roll up into their parent project's bar.

Controls at the top of the page:

| Control           | Options                                                   |
| ----------------- | --------------------------------------------------------- |
| View              | **Time**, **Billing**, **Costs** — toggle any combination |
| Status filter     | **All**, **> 80%** (at risk), **Over budget**             |
| **Sort:**         | **% consumed**, **Name**, **Remaining**                   |
| **Filters**       | Narrow by project or project tag                          |
| **Show archived** | Include archived projects                                 |
| **Export**        | **JSON**, **CSV**, **TSV**, **Excel (XLSX)**, **PDF**     |

These controls all work on data the page already has, so the list re-orders and re-filters as you click — nothing is reloaded. The **Filters** cover the whole project hierarchy: filter on a client or a parent project and every project underneath it is included, and a project-tag filter also matches tags below the one you picked, plus every project under a tagged parent. Each condition can include (**is**) or exclude (**is not**).

The chosen **Sort** applies at every level of the list — top-level rows, nested subprojects, and the per-person or per-project lines inside a split — and the project name breaks ties, so rows that read the same (all the untouched budgets at 0%, for example) keep a stable order.

A budget consumed to exactly 100% counts as **on budget**: only a project projected above 100% is reported as over budget, and the bar colors use the same boundary.

Click a project's bar to open its detail sheet with the numbers behind the bar — consumption, forecast, and remaining amounts. On a budget [split by person or by project](/help/documentation/budgets#budget-splits), each line compares its own allocation with the time and money really logged against it — a split-by-project line also counts everything logged on that project's own subprojects. A project carrying several budgets appears as a single row: the targets add up, and its actual consumption is counted once.

This report is where budget trouble surfaces: it always flags projects approaching or over their budget, and there is no setting to switch on. The striped forecast bar carries the planned effort still to come, so a budget heading for an overrun shows it before the actuals get there. See the [Budgets](/help/documentation/budgets) page for how budgets are set.

***

## Planned vs. Real

Next to **Budget Status**, the Reports menu offers **Planned vs. Real** — a chart comparing the work you planned with the time actually logged, period by period.

<Steps>
  <Step title="Pick the plan">
    Pick the plan to chart with the **Plan** dropdown — shown when your account has more than one planning. The plan's tasks form the planned side.
  </Step>

  <Step title="Choose the unit and view">
    Pick the **Unit** the chart reads in: **Hours**, **Days**, **Billing**, **Cost**, or **Margin** — money is shown in your organization's currency. Under **View**, switch between **Cumulative** (the running total) and **Remaining** (a burndown toward zero).
  </Step>

  <Step title="Read the chart">
    **Planned** is the tasks' planned effort, distributed across the scheduled days between their dates. **Real** is the timesheet time recorded on the projects those tasks belong to — the same scope the Budget Status report uses. A **Forecast** carries the remaining planned effort forward from today's actuals, an **Ideal** line shows the steady pace that would land exactly on plan, and a **Budget** line appears where a budget is set. A headline states the pace at a glance: **Behind**, **On track**, or **Ahead**.
  </Step>

  <Step title="Check who is over or under">
    The **Over/under plan per person** chart breaks the variance down by person, showing who is running over or under their planned time in the selected period.
  </Step>

  <Step title="Narrow and export">
    Use **Filters** to focus on specific people, projects, or tags, and **Export** to download the results.
  </Step>
</Steps>

Your chosen plan, unit, and view are remembered per user, so the report reopens the way you left it. Use it to catch plans drifting from reality early — a **Real** line running above **Planned** means the work costs more time than scheduled. Plan the work itself in the [Gantt](/help/documentation/gantt) and [Staffing](/help/documentation/staffing) views.

***

## Revenue at Risk

The **Revenue at Risk** entry in the Reports menu answers one commercial question: which hourly or daily-billed projects will not consume their contracted hours before their end date? Unused budgeted hours on a time-and-materials contract are revenue that is lost when the contract ends — this report surfaces them while there is still time to act.

For every project with a budget, a billing method of **Hourly** or **Daily**, and an end date, the report projects consumption to the end date and lists what will be left over:

| Column                       | What it shows                                                             |
| ---------------------------- | ------------------------------------------------------------------------- |
| **Project**, **Manager**     | The project and its manager                                               |
| **Billing**, **End date**    | The billing method (**Hourly** or **Daily**) and the project's end date   |
| **Budget**, **Budget hours** | The budgeted amount and its equivalent in hours                           |
| **Logged**, **Remaining**    | Hours consumed so far and hours still available                           |
| **Planned to end**           | Hours planned on the project's tasks between today and the end date       |
| **Projected at end**         | Hours expected to remain unconsumed at the end date — the hours at risk   |
| **Implied rate**             | The budget divided by its hours, used to convert hours at risk into money |

Totals at the top summarize the portfolio: **Total at risk**, **Projects at risk**, and **Share of portfolio**. Rows where nothing has been logged yet are flagged **Not started**. Projects the report cannot assess are counted separately below the table — those with no end date set, and those whose budgets mix currencies.

The report appears when your subscription includes budgets and your role can view budgets and billing rates, and it supports the standard **Filters** and **Export** controls.

***

## Utilization

The **Utilization** entry in the Reports menu shows billable hours as a share of scheduled capacity, per person and month. Use it to see how much of each person's available time turns into billable work.

* Each row is a person; each column is a month, showing their utilization percentage. **Billable hours** are the hours logged on billable work; **Capacity hours** are the person's scheduled working time, net of time off — so a 30-hour week or a vacation doesn't unfairly lower the score.
* A **Projected** column estimates next month from the person's planned bookings on billable projects.
* An **Average** summarizes each person across the period.
* **Filters** and **Export** work as in other reports.

The report appears when your subscription includes budgets and your role has the **Billable utilization** permission.

***

## Timesheet Compliance

The **Compliance** entry in the Reports menu shows whether each person submitted their timesheet on time, late, or not at all — per person and period, in a calendar-style grid. It is the detailed view behind the [timesheet score](/help/documentation/timesheets) shown on person records.

* Each row is a person with their compliance **Score**; each column is a timesheet period, marked **On time**, **Late**, or **Not submitted**.
* Hover a cell for the details: the period's **Deadline**, when it was **Submitted**, **Days late**, and **Rejections**.
* Rows sort worst-first by default, so the people needing attention surface at the top.
* Filter by person or person tag, and change the date range — the report defaults to the last six full months. **Export** downloads the grid.
* People who have never recorded time are counted separately in a footnote — the timesheet process has not started for them, so they aren't shown as non-submitters. Click the people count in the footnote to expand the list of exactly who hasn't started tracking time.

Access is a dedicated permission: your role needs **Timesheet compliance**, and managers see the people they manage — admins see everyone. See [Roles & authorizations](/help/documentation/roles-authorisations).

***

## Absence quotas

The **Absence quotas** entry in the Reports menu gives managers one consolidated view of everyone's time-off allowances — no more opening profiles one by one. Each row is a person's allowance for a time off type, with columns for **Allowance**, **Accrued**, **Carry forward limit**, **Valid until**, **Taken**, **Planned**, **Pending**, **Remaining**, and **Allow negative balance**.

* **Timeline** — Switch to the timeline to see consumption over the allowance's period instead of totals.
* **Drill down** — Open a row for the detailed breakdown behind its numbers.
* **Columns**, **Filters**, **Show archived**, **Export** — Choose the visible columns, narrow by person or tag, include archived people, and download the results.

The report appears when your subscription includes absence quotas and your role can view absence quotas. Balances follow the same rules as the allowances themselves — see [Time off](/help/documentation/timeoff).

***

## Reports on your phone

On a phone, the **Reports** section switches to a layout built for consulting: pick a folder, adjust the period, and read each report as a scrollable sheet. Filters and the period selector work as chips at the top of the screen.

Building and reconfiguring report output remains a desktop task — for example, an unconfigured matrix view asks you to open the report on desktop to pick its rows, columns, and metric.

***

## Related content

<CardGroup>
  <Card title="Custom Reports" icon="table-columns" href="/help/documentation/custom-reports">
    Build report output with columns, grouping, charts, and the matrix view.
  </Card>

  <Card title="Budgets" icon="coins" href="/help/documentation/budgets">
    Set billing, cost, or hours budgets on projects and track them against targets.
  </Card>

  <Card title="Data Exports" icon="file-export" href="/help/documentation/data-exports">
    Download report results for offline analysis and sharing.
  </Card>

  <Card title="Cost Rates" icon="money-bill-trend-up" href="/help/documentation/costs">
    Configure cost rates so cost and profit columns show data in reports.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Does Beebole include ready-made reports?">
    Yes. A new Beebole account starts with two sample folders — **Current Month** and **Current Year** — containing five ready-made reports, including **Hours by Person** and **Profit by Project**. They are regular reports you can run, edit, or delete, and they double as examples for building your own.
  </Accordion>

  <Accordion title="Can I report on time off?">
    Yes. In Beebole, absences are time records, so any time-based report can include them. Add an **Absence type** column to break results down by leave type, or narrow a report to **Absences only** — the sample report **Absences by person** shows this setup.
  </Accordion>

  <Accordion title="What formats can I export a report to?">
    Beebole exports report results as JSON, CSV, TSV, Excel (XLSX), or PDF, plus the chart as a PNG image and the matrix view in CSV, Excel, or PDF. For spreadsheets that refresh themselves, connect a saved report to the [Excel add-in](/help/documentation/excel-addin) or [Google Sheets add-on](/help/documentation/gsheets-addon).
  </Accordion>

  <Accordion title="How does Beebole calculate revenue at risk?">
    For each hourly or daily-billed project with a budget and an end date, Beebole projects how many budgeted hours will still be unconsumed at that date, then converts them to money using the budget's implied rate. The **Revenue at Risk** report totals this across your portfolio so you can rebalance staffing before contracted hours expire unused.
  </Accordion>
</AccordionGroup>


# Roles and permissions: control who sees what
Source: https://beebole.com/help/documentation/roles-authorisations

Create roles in Beebole and set Edit and View permissions for timesheets, billing, time off, reports, and more, each scoped to the right people.

A role in Beebole is a named set of permissions that controls what its holders can see and do. Every person has exactly one role, and each permission in a role sets two levels — **View** and **Edit** — scoped to targets such as **Me**, **Managed people**, or **Managed projects**. This page explains how roles work and what every permission controls.

<Info>
  Roles control what a person's role lets them **do** — view or edit data. Which projects, time off types, and expense types are **available** to each person is a separate system, covered in [Assignments](/help/documentation/assignments).
</Info>

## How roles work

Roles live in **Settings** > **Person Roles** — click the button with your initials at the bottom of the sidebar to open **Settings**. Each role is a grid of permissions with three pieces:

* **Permission** — the area of Beebole it controls, such as **Timesheet entries** or **Billing rates**.
* **Edit** — the targets whose data the role can create, change, or delete.
* **View** — the targets whose data the role can see.

A permission with nothing selected shows **Not allowed**: people with that role don't see that area at all. Two permissions — **Timesheet entries** and **Reports** — are simple on/off checkboxes instead of target selectors.

Edit access always includes view access. When you add a target under **Edit**, Beebole adds it to **View** automatically; when you remove a target from **View**, it is removed from **Edit** too.

At the top of the grid, the **Admin role (full access)** checkbox grants everything at once. Checking it replaces all individual permissions with full access; unchecking it clears the role so you can build it permission by permission.

<Info>
  A few permissions — such as **Billing rates**, **Costs**, **Project budgets**, and **Time off balance** — correspond to features included in higher-tier plans. If your subscription doesn't include the feature, the permission has no effect, even for admins.
</Info>

## Creating and managing roles

<Steps>
  <Step title="Open the roles page">
    Click the button with your initials at the bottom of the sidebar to open **Settings**, then click **Person Roles**.
  </Step>

  <Step title="Add a role">
    Click **Add a role** and type a name — for example Editor, Staff, or Project Lead.
  </Step>

  <Step title="Set the permissions">
    For each permission, pick targets under **Edit** and **View**, or check the **Admin role (full access)** box for full access. Use the **Search…** field to find a permission by name.
  </Step>
</Steps>

There is no Save button — every change to a role is saved automatically and applies to everyone holding that role.

To manage an existing role, open its **⋯** action menu in the roles list: **Duplicate** copies the role with all its permissions, **Archive** hides it, and **Delete** removes it.

<Tip>
  Start from a role that is close to what you need and use **Duplicate**, then adjust the copy. It is faster than building a role from scratch and you are less likely to miss a permission.
</Tip>

Every new Beebole account starts with four roles: **Admin** (full access), **Employee**, **People manager**, and **Project manager**. You can edit them, duplicate them, or add your own.

## Permission scopes

For permissions with target selectors, the targets you pick under **Edit** and **View** define whose data the permission covers. Each permission only offers the targets that make sense for it.

The targets separate what the person *manages* from their *colleagues* — and, for tasks, what they *own* from what they *manage*:

| Target                      | Who or what it covers                                      |
| --------------------------- | ---------------------------------------------------------- |
| **All**                     | No restriction — every target at once                      |
| **Me**                      | The person's own data                                      |
| **Managed people**          | People they manage, directly or through tags they manage   |
| **Team colleagues**         | People who share the same managers                         |
| **Project colleagues**      | People assigned to the same projects                       |
| **Task colleagues**         | People assigned to the same tasks                          |
| **Managed project members** | People assigned to the projects they manage                |
| **Managed projects**        | Projects they manage, directly or through tags they manage |
| **Assigned projects**       | Projects assigned to them                                  |
| **Owned tasks**             | Tasks they own                                             |
| **Managed tasks**           | Tasks they manage                                          |
| **Assigned tasks**          | Tasks assigned to them                                     |
| **Managed tags**            | Tags they manage, including descendant tags                |
| **Global settings**         | The organization-wide value of the setting                 |

For example, a team leader role could have **People details** set to **Edit: Managed people** and **View: Managed people, Project colleagues** — they can maintain their own team's profiles and see, but not change, the profiles of project colleagues.

## Timesheet, time off, and schedule permissions

These permissions control day-to-day time tracking data.

| Permission                          | What it controls                                                            |
| ----------------------------------- | --------------------------------------------------------------------------- |
| **Timesheet entries**               | Time entries on timesheets (on/off)                                         |
| **Timesheet and planning settings** | The timesheet and planning configuration panel on people and on the account |
| **Valid period for time entry**     | The setting that limits how far back or forward time can be entered         |
| **Time off balance**                | People's time off allowances and balances                                   |
| **Public Holidays**                 | Public holiday calendars assigned to people                                 |
| **Schedule assignment**             | Which work schedule is assigned to a person, tag, or the account            |

**Timesheet and planning settings** governs who may change that panel, not what it contains. Which plannings a person may record time on is one of its settings — **Record time on these plannings** — and it applies per person rather than per role. See [Which plannings a person can book](/help/documentation/assignments#which-plannings-a-person-can-book).

## Approval permissions

| Permission            | What it controls                                            |
| --------------------- | ----------------------------------------------------------- |
| **Approval workflow** | The approval stages configured on the account and on people |

Only the people who design the sign-off process need **Approval workflow**. Approving and rejecting timesheets isn't a separate permission — it follows the stages of the [approval workflow](/help/documentation/approval) itself, so whoever a stage resolves as an approver can act, and administrators can always step in.

## Billing, cost, and budget permissions

| Permission          | What it controls                     |
| ------------------- | ------------------------------------ |
| **Billing rates**   | Billing rates on people and projects |
| **Costs**           | Cost rates on people and projects    |
| **Project budgets** | Budgets defined on projects          |

Financial data is hidden from anyone whose role has these set to **Not allowed** — they don't see billing or cost amounts anywhere in Beebole, including reports.

## Expense permissions

| Permission          | What it controls                               |
| ------------------- | ---------------------------------------------- |
| **Expense records** | Expense entries, scoped by people and projects |

## People permissions

| Permission         | What it controls                                                    |
| ------------------ | ------------------------------------------------------------------- |
| **People details** | People's profiles — names, pictures, and profile data               |
| **User account**   | The **Email & role** panel — a person's email, invitation, and role |

Be deliberate with **User account** edit access: whoever holds it can change other people's roles. Who manages whom is a separate permission, **Assign people managers**, in the assignment permissions below.

## Project and task permissions

| Permission             | What it controls                                                                         |
| ---------------------- | ---------------------------------------------------------------------------------------- |
| **Project details**    | Projects — creating, editing, and archiving them                                         |
| **Secondary projects** | The secondary projects allowed on a project                                              |
| **Tasks**              | Tasks in Planning — scoped to **Owned tasks**, **Managed tasks**, and **Assigned tasks** |

## Assignment permissions

Assignment permissions separate *changing data* from *deciding who works on what*. A role can be allowed to edit projects without being allowed to assign people to them — or the reverse. When a role lacks an assignment permission, the matching controls simply don't appear for its holders.

| Permission                  | What it controls                                   |
| --------------------------- | -------------------------------------------------- |
| **Assign people managers**  | Who is set as a person's manager                   |
| **Assign project managers** | Who manages a project                              |
| **Assign task managers**    | Who manages a task                                 |
| **Assign tag managers**     | Who manages a tag                                  |
| **Assign task owner**       | Setting the owner of a task                        |
| **Potential owners**        | Assigning tasks to people                          |
| **Who has access**          | Assigning people to projects                       |
| **Assign schedules**        | Which work schedule is assigned to a person or tag |
| **Assign time off**         | Which time off types are available to a person     |
| **Assign expenses**         | Which expense types are available to a person      |
| **Assign custom fields**    | Which custom fields are available to a person      |
| **Apply tags**              | Applying tags to people, projects, and tasks       |

<Tip>
  The permission list is long. Use the search box at the top of the role's permission panel to jump straight to the permission you're looking for.
</Tip>

## Custom field permissions

| Permission               | What it controls                            |
| ------------------------ | ------------------------------------------- |
| **Custom fields values** | The values filled in on people and projects |

## Journal and report permissions

| Permission               | What it controls                                                                                                                               |
| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| **Journal**              | Journal messages on people, projects, and tasks — this permission also gates the **Journal** page in the sidebar                               |
| **Reports**              | The **Reports** page (on/off)                                                                                                                  |
| **Timesheet compliance** | The [Timesheet Compliance report](/help/documentation/reports#timesheet-compliance) — managers see the people they manage; admins see everyone |
| **Billable utilization** | The [Utilization report](/help/documentation/reports#utilization)                                                                              |

## Account and visibility permissions

These permissions cover account configuration and the access-control settings themselves.

| Permission                  | What it controls                                                   |
| --------------------------- | ------------------------------------------------------------------ |
| **Localization**            | Language, time zone, and format settings on people and the account |
| **Templates for emails**    | The email templates Beebole sends                                  |
| **Notification settings**   | Notification preferences on people and the account                 |
| **Show or hide by default** | The account-wide **Show or hide by default** settings              |
| **Description**             | The description panel on people, projects, tasks, and the account  |

**Show or hide by default** sets the account-wide defaults described in [Assignments](/help/documentation/assignments). The per-item **Who has access?** panels and the per-person **Show or hide** panels follow the assignment permissions above instead — a role needs the matching **Assign …** permission to change who has access to what.

<Info>
  Some account-wide definitions are not role-configurable and so have no row in the grid — creating time off types, expense types, custom fields, and work schedules, for example, along with the tag and single sign-on configuration, which are reserved for administrators.
</Info>

## Assigning a role to a person

<Steps>
  <Step title="Open the person">
    Click **People** in the sidebar and click the person's name.
  </Step>

  <Step title="Open the Email & role panel">
    In the person's details, open the **Email & role** panel.
  </Step>

  <Step title="Pick the role">
    Next to **Role**, click the current role and choose another one from the **Choose a role** selector. The change is saved automatically.
  </Step>
</Steps>

## Best practices

* **Grant the least access that works.** Start from **Not allowed** and add **View** before **Edit**, only for the targets each role really needs.
* **Name roles after responsibilities.** Names like Project Lead or Finance make it obvious who should hold them.
* **Prefer few roles over many.** Targets like **Managed people** and **Managed projects** adapt to each holder, so one Manager role can serve every manager.
* **Review roles when your structure changes.** Targets follow manager and tag relationships — check that permissions still reach the right people after a reorganization.

## Related content

<CardGroup>
  <Card title="Assignments" icon="user-check" href="/help/documentation/assignments">
    Control which projects, time off types, and expense types are available to each person.
  </Card>

  <Card title="People" icon="users" href="/help/documentation/people">
    Add and invite team members, and manage their profiles and roles.
  </Card>

  <Card title="Tags" icon="tag" href="/help/documentation/tags">
    Group people and projects with tags — several permission targets follow tag managers.
  </Card>

  <Card title="Account Settings" icon="gear" href="/help/documentation/account-settings">
    Configure the organization-wide settings that several permissions gate.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between roles and assignments in Beebole?">
    Roles control what a person can do: view or edit timesheets, billing rates, reports, and so on. Assignments control which items are available to them: which projects they can log time against, or which time off types they can pick. Beebole applies both — a person needs the permission and the item.
  </Accordion>

  <Accordion title="Can a person have more than one role?">
    No. Each person in Beebole holds exactly one role. If someone needs a mix of permissions from two roles, duplicate one of them and adjust the copy.
  </Accordion>

  <Accordion title="What do Edit, View, and Not allowed mean?">
    For each permission, **View** lets the role see the data and **Edit** lets it create, change, or delete it, each scoped to the targets you select. A permission with no targets selected shows **Not allowed**, and that area of Beebole is hidden from the role entirely.
  </Accordion>

  <Accordion title="Which roles does a new Beebole account include?">
    Every new account starts with **Admin**, **Employee**, **People manager**, and **Project manager**. The Admin role has the **Admin role (full access)** box checked, which grants every permission. You can edit these roles or add your own.
  </Accordion>

  <Accordion title="Do I need to save after changing a role?">
    No. Beebole saves every change to a role automatically — adding a target, unchecking a permission, or renaming the role. There is no Save button on the roles page.
  </Accordion>
</AccordionGroup>


# Staffing: plan who works on what, and when
Source: https://beebole.com/help/documentation/staffing

Plan your team's workload on Beebole's Staffing timeline — drag to create bookings, set allocation percentages, and see each person's remaining capacity.

Beebole's Staffing view is a long-horizon timeline of who works on what, and when. It is one of the four views of the **Planning** page, alongside the [Gantt chart](/help/documentation/gantt), the [Kanban board](/help/documentation/kanban), and the [List view](/help/documentation/task-list) — the bars you see are the same tasks, displayed per person instead of per task. Use it to book people onto projects, set how much of their time each booking takes, and see at a glance who still has capacity.

<Info>
  Staffing, Gantt, Kanban, and List display the same underlying tasks. A booking created in the Staffing view is a task like any other — it appears in the other views and in reports immediately.
</Info>

***

## Opening a Staffing view

<Steps>
  <Step title="Open the Planning page">
    Click **Planning** in the sidebar, and pick the planning you want at the top of the page.
  </Step>

  <Step title="Select or create a Staffing view">
    Click a Staffing view tab above the task list. To create one, click **Add a view** and select **Staffing**. Like every saved view, it remembers its own settings and filters.
  </Step>
</Steps>

***

## Reading the timeline

Each row is a person (or a project, depending on the grouping). Each bar is a booking: a task scheduled between two dates, shown in the task's color. The bar displays the task name — and, when there is room, its date range and the secondary project path.

* A vertical line marks today; the **Today** button scrolls back to it.
* The timeline extends into the past as well as the future — keep scrolling left to review earlier plans.
* Bar edges snap to working days, so bookings line up with what people can actually work.

### Bookings with hours

A task that carries [start and end times](/help/documentation/gantt#giving-a-task-hours) is drawn at its real position inside the day column rather than filling the whole day, so a booking from 14:00 to 17:00 sits in the afternoon third of its cell. The stretches the owner does not work — before their day starts, their scheduled breaks, and after their day ends — are hatched behind the bar, which makes a booking placed outside working hours obvious at a glance. Bookings that run past midnight start late in one day's cell and end early in the next.

Dropping a booking onto a day its owner doesn't work is refused rather than silently accepted. Days that define a length but no working hours show the booked hours in proportion, with any overrun hatched.

### Grouping rows

Open the **⋯** menu on the view tab and use **Staffing by** to choose what the rows represent:

* **People** — One row per person, with their bookings and a capacity strip.
* **A project category** — Pick a category, then a level or **Lowest level**; one row per project at that choice, showing everyone booked on it.

**Lowest level** keeps only the projects that have nothing below them, so you never see a parent row duplicating the work of its children. With a project grouping, an owned booking that has no row to sit on — the task is linked to no project of that category, or only to a parent — falls into the row at the top of the view, labeled **No** followed by the grouping name.

***

## Creating a booking

A booking doesn't need a task name — the fastest way to staff someone is to book them on a project for a date range. Beebole names the booking automatically from the person and the project.

<Steps>
  <Step title="Drag on the timeline">
    In a person's row, click and drag across the dates you want to book — or just click an empty cell to create a booking spanning that one period. The booking editor opens right next to the bar.
  </Step>

  <Step title="Pick the project">
    Select the project the person is booked on — the booking saves as soon as you pick it, with no confirmation step. When grouping by project, you pick the person here instead. The editor stays open on the new booking so you can adjust it right away, and you can change or remove the assigned person later from the same editor.
  </Step>

  <Step title="Set the allocation">
    Enter the allocation in whichever way you think about it: **%** for a percentage of capacity, **h/day** for hours per working day, or **Total** for planned hours over the whole booking (100% by default). Press **Enter** to confirm.
  </Step>
</Steps>

The new bar appears immediately. If your active filters would hide it, Beebole tells you: **Booking added, but it's hidden by the current filter**.

### Tentative bookings

While plans are still firming up, mark a booking **Tentative** in its editor. A tentative booking is drawn with a hatched style and reserves the person's capacity, but stays out of reports until confirmed.

### Splitting and duplicating

From the booking's editor you can also **Split** it in two at a chosen date — useful when part of a booking moves — or **Duplicate** it.

<Tip>
  Give the booking a name later only if you need one — open it and type a name, exactly as you would rename a task. Unnamed bookings keep showing the person + project automatically, in Staffing, Gantt, and Kanban alike.
</Tip>

***

## Moving and resizing bookings

* **Move** — Drag a bar left or right to shift its dates; the duration is preserved and other bookings restack live as you drag.
* **Resize** — Drag the left or right edge to change the start or end date.
* **Move between rows** — Drag a bar vertically: drop it on another person's row to reassign the booking, on another project's row to move it to that project, or on the **Unassigned** row to clear its owner. A dashed ghost previews where the bar will land, and the whole move is one undo step. The booking's working time reflows over the destination person's own schedule and absences.
* **Work on several bookings at once** — Select multiple bars and drag them together to reschedule the group in one move, hold **⌘** (Alt on Windows/Linux) while dragging to drop dated copies, or grab any selected bar's edge to shift every selected bar's dates by the same amount — all undoable as a single step. ⌘-dragged copies land on the row you release them on, each on its own row rather than stacked on the row you dropped on. Press **Delete** (or **Backspace**) to remove every selected booking at once: one confirmation, and one undo for the whole batch.
* **Reach beyond the visible range** — Drag a bar to the edge of the timeline and it auto-scrolls, so a booking can be moved or extended past what is currently on screen.
* **Reassign** — Click a bar to open its editor and change the project, person, or allocation. Changes are saved automatically.

### Moving a booking inside its day

A booking that runs for part of a single day is dragged on the clock its cell draws. While the pointer stays in that cell the booking follows it hour by hour, snapping to the quarter hour, as on the timesheet calendar — and it lands on hours the owner works, reaching over a lunch break rather than sitting on it. The moment the pointer leaves the cell, the booking moves by whole days instead, keeping the hours it already had, so it never arrives on another day at hours nobody chose.

⌘-dragging a copy and dropping it in the cell it came from puts the copy right after its source: the first free minute of that day, holding as much of the day as the source holds. When there is no room left after it — an all-day booking, one spanning several days, or a day already full — the copy simply lands on its source, as it does elsewhere on the timeline.

### Dependencies in the Staffing view

Dependency links between bookings are drawn directly on the staffing timeline, color-matched to the tasks at each end, so you can see which bookings depend on which. Moving or resizing a booking cascades to its linked bookings live — dependent bars follow the drag on screen before you drop. If a linked task that moves isn't visible in your current view, a warning names it so you know what changed and can undo it. See [Task dependencies](/help/documentation/gantt#task-dependencies) for how links are created.

### Bookings managed in the Gantt

Some tasks have a schedule the Staffing view must not change. When you try to edit one, Beebole shows **Managed in the Gantt** with the reason:

| Reason                     | Message                                                                           |
| -------------------------- | --------------------------------------------------------------------------------- |
| Recurring task             | This is a recurring task, so its schedule is managed in the Gantt.                |
| Part of a recurring series | This task belongs to a recurring series, so its schedule is managed in the Gantt. |
| Has subtasks               | This task has subtasks, so its schedule is managed in the Gantt.                  |

Open the [Gantt chart](/help/documentation/gantt) to adjust these tasks.

***

## The Unassigned row

Planned work nobody has picked up yet sits in the **Unassigned** row. Drag a booking onto it to clear the owner, or drag one out of it onto a person to assign the work. The row can be collapsed out of the way — its tooltip reads **Show these bookings** or **Hide these bookings** — and ⌘-dragging an unassigned booking drops the copy straight onto the row you release it on.

The number next to the row label counts the unassigned bookings that fall inside the period you are looking at, not every unassigned booking on record — so it tells you how much work still needs an owner right now.

An account-wide reminder can warn everyone involved before an unassigned task starts — see [Timesheet and Planning Settings](/help/documentation/timesheetSettings).

***

## Locking the view to a period

By default the timeline is infinite — it scrolls by day or week as far as you need. Open the **⋯** menu on the view tab and use **Period** to lock the view to a fixed window instead:

* **Infinite by day** or **Infinite by week** — the endless scrolling timeline, at day or week granularity.
* **Day**, **Week**, **2 weeks**, **3 weeks**, **4 weeks**, or **6 weeks** — the chart fits that window to your screen and shows only the bookings that fall inside it.

With a fixed window, the view pages one period at a time: swipe or scroll sideways and it snaps cleanly onto the next or previous window, and the period containing today is always reachable.

Bookings that start before or end after the locked period are drawn cut off, with a dashed edge and a chevron — click it to jump to the hidden start or end date. Cut edges can't be resized, since the date they would move isn't on screen.

***

## Copying the previous period

With the view locked to a fixed period, **Copy the previous period** refills the current period from the one before it — with or without the people and project assignments. Choose **With people** or **Without people**, and **With projects** or **Without projects**, to decide how much of the booking is carried over.

Beebole looks back to the last period that actually holds bookings, not just the one immediately before, and fills every empty period between it and the one you are looking at — so a run of unstaffed weeks is refilled in a single action. Recurring tasks are skipped, and anything that would spill outside the period is clipped. If there is nothing to copy, Beebole says so: **No earlier bookings to copy**.

***

## Finding who's free

Click **Find capacity** to search for available people over a chosen period — including forward-looking ranges like **By year end** and **Next 12 months**:

| Search              | Who matches                                                                                                      |
| ------------------- | ---------------------------------------------------------------------------------------------------------------- |
| **Has free time**   | Anyone with unbooked capacity in the period                                                                      |
| **Free at least**   | People with at least the number of hours you enter — typing in the hours field applies this search automatically |
| **Nothing planned** | People with no bookings at all in the period                                                                     |
| **Overbooked**      | People booked beyond their capacity                                                                              |

A count shows how many people match. You can also filter the people list by person custom-field values, and search people and projects by name. Capacity is only computed when grouping by people.

***

## Workload and capacity

Each person's row includes a capacity strip: one cell per period comparing their planned load to their available capacity. Capacity comes from the person's [work schedule](/help/documentation/work-schedule) minus their absences, and each booking counts for its allocation percentage.

* **Hover a cell** to see the numbers — how much is planned against how much is available for that period.
* **Overload** — Load bars use a three-color scale: red while capacity remains, green when it is exactly met, and purple as soon as someone is booked beyond 100%. The headcount strip in the timeline header flags overloaded periods for the whole view.
* **Step through the load** — The strip at the top of the timeline header rolls every row up into one bar per period. Click a period there to step the scroll through the rows driving that period's load, one at a time.
* **Hours or days** — Open the **⋯** menu on the view tab and use **Durations in** to switch every figure between hours and days.

Use the free capacity to decide who takes the next booking — the gaps in the timeline are exactly the people and periods still available.

***

## Filtering

Use the **Filters** button to narrow the view — by task, status, owner, assigned person, project, or [tags](/help/documentation/tags) on people, projects, and tasks, with the active filter count shown on the button. Filters on people or projects hide entire rows; other filters hide only the bars that don't match, keeping the row visible. The filters can be switched off and back on without losing them — the button toggles them rather than clearing them.

***

## Related content

<CardGroup>
  <Card title="Tasks" icon="list-check" href="/help/documentation/planning">
    What tasks are in Beebole — creating, assigning, and tracking time on them.
  </Card>

  <Card title="Gantt chart" icon="chart-gantt" href="/help/documentation/gantt">
    Schedule tasks on a timeline, sequence them with dependencies, and manage recurring tasks.
  </Card>

  <Card title="List view" icon="table-list" href="/help/documentation/task-list">
    The same tasks as a sortable table, with in-place editing and mass edits.
  </Card>

  <Card title="Work schedules" icon="calendar" href="/help/documentation/work-schedule">
    Define the working hours that determine each person's capacity.
  </Card>

  <Card title="Planned vs. real report" icon="chart-column" href="/help/documentation/reports#planned-vs-real">
    Compare the time you planned in Staffing and Gantt with the hours actually logged.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between the Staffing view and the Gantt chart?">
    Both display the same tasks. The Gantt chart in Beebole is task-centric — one row per task, with dependencies and hierarchy. The Staffing view is person-centric — one row per person, with their bookings and remaining capacity. Use the Gantt to structure the work, and Staffing to balance who does it.
  </Accordion>

  <Accordion title="Does a booking need a task name?">
    No. In Beebole you can book a person on a project for a date range without naming a task — the booking is named automatically from the person and the project. You can add a name later if the work becomes a concrete task.
  </Accordion>

  <Accordion title="How does Beebole calculate a person's capacity?">
    Capacity comes from the person's work schedule minus their absences, per period. Each booking consumes capacity according to its allocation percentage — a 50% booking on a 40-hour week uses 20 hours.
  </Accordion>

  <Accordion title="Why can't I move a booking in the Staffing view?">
    The task's schedule is managed in the Gantt. Recurring tasks, tasks in a recurring series, and tasks with subtasks show a **Managed in the Gantt** message — open the Gantt chart to change their dates. Bookings with dependencies can be moved and resized directly in Staffing; their linked bookings follow along.
  </Accordion>

  <Accordion title="Can I plan further back than the visible timeline?">
    Yes. The Staffing timeline scrolls into the past as well as the future, and dragging a bar to the edge of the screen auto-scrolls so you can drop it beyond the visible range. The **Today** button brings you back to the current date.
  </Accordion>
</AccordionGroup>


# Subscription, plans, seats, and billing
Source: https://beebole.com/help/documentation/subscription

Manage your Beebole subscription: compare the Free, Essential, and Advanced plans, adjust seats, switch billing intervals, add add-ons, and manage payments.

Beebole's subscription page is where an administrator chooses a plan, sets the number of seats, and manages payment. Seats are billed per person, and payment runs through Stripe, so your card details are handled securely. Open it through **Settings** > **Subscription**.

<Info>
  Only administrators see and manage the subscription. Open it from **Settings** > **Subscription** — the **Settings** menu opens from the button with your initials at the bottom of the sidebar.
</Info>

## Plans

Beebole has three plans. Each higher plan includes everything in the one below it.

| Plan          | Who it's for                                        | Highlights                                                                                         |
| ------------- | --------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| **Free**      | Small teams getting organized (up to 5 seats)       | Project time tracking, resource planning, time off tracking, custom reports                        |
| **Essential** | Teams ready to bill clients and formalize workflows | Adds billing rates, time-off allowances, multi-level approvals, integrations, multiple currencies  |
| **Advanced**  | Teams that need full financial control              | Adds costs and profitability, expense tracking, project budgets, custom fields, configurable roles |

Prices are shown per seat per month, in your billing currency, on the subscription page. You can pay **Monthly** or **Yearly** — a yearly plan saves 10%.

<Info>
  The **Free** plan is limited to 5 seats. The paid plans bill for the number of seats you set.
</Info>

## Adjust seats

Seats are not added or removed automatically when you add or archive people. You set the seat count yourself, and a paid change is confirmed before it takes effect.

<Steps>
  <Step title="Open the subscription page">
    Go to **Settings** > **Subscription**.
  </Step>

  <Step title="Set the new seat count">
    Under the seats section, use the stepper to change the number. You cannot set fewer seats than the number of active people in your account.
  </Step>

  <Step title="Confirm the prorated charge">
    Beebole shows the prorated amount due for the rest of the current period. Click **Confirm** to authorize that amount and update your seats.
  </Step>
</Steps>

<Info>
  To reduce your seat count, archive people first so the active count drops — the subscription page links you to **People** to do this. The seat number cannot go below the number of active people.
</Info>

## Change your plan

Click **Change plan** on the subscription page to move between **Free**, **Essential**, and **Advanced**. Moving to a higher plan shows the prorated difference to confirm. Moving to a lower paid plan or to the free plan is a downgrade — see [Downgrade to the free plan](#downgrade-to-the-free-plan).

## Billing interval

Switch between **Monthly** and **Yearly** billing from the **Billing interval** control on the subscription page. A yearly plan saves 10% over paying monthly.

## Add-ons

Add-ons extend a plan without moving to a higher tier. Available add-ons appear on the subscription page alongside your current plan:

| Add-on                                                   | What it adds                                                                                     |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Costs, Expenses & Budgets**                            | Track employee costs, project margins, project expenses, and budgets                             |
| **Custom fields, custom roles & advanced configuration** | Add custom fields, define custom roles and permissions, and use advanced tag-based configuration |

<Info>
  Add-ons are offered on the **Essential** plan. On the **Advanced** plan, these capabilities are already included, so the add-ons are not shown.
</Info>

## Manage payment and invoices

Beebole uses a Stripe-hosted portal for payment details, invoices, and cancellation. Open it with the **Manage** button.

<Steps>
  <Step title="Open the subscription page">
    Go to **Settings** > **Subscription**.
  </Step>

  <Step title="Open the portal">
    Click **Manage** to open the Stripe billing portal.
  </Step>

  <Step title="Make your changes">
    Update your credit card or billing information, download invoices, or cancel your subscription.
  </Step>
</Steps>

<Info>
  Prefer to pay by wire transfer? The subscription page includes a wire-transfer option for yearly plans — it drafts an email to the Beebole team with your plan, interval, and seat count so they can set the account up manually.
</Info>

## Downgrade to the free plan

You can convert a paid subscription back to the **Free** plan (up to 5 seats) from the subscription page. Click **Convert**, then **Confirm**. You keep access to your core data, but the paid features your plan included are no longer available.

<Warning>
  Converting to the **Free** plan ends your paid subscription immediately. No refund is issued for the remaining period, so it is usually best to convert near the end of a billing cycle.
</Warning>

## Related content

<CardGroup>
  <Card title="Account Settings" icon="gear" href="/help/documentation/account-settings">
    Manage your organization profile, feature settings, and SSO.
  </Card>

  <Card title="Billing Rates" icon="coins" href="/help/documentation/billing">
    Set billing rates to track billable revenue on your projects.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How does seat-based pricing work in Beebole?">
    Beebole bills per seat per month, in your billing currency. You set the seat count yourself on the subscription page — it is not adjusted automatically when you add or archive people — and you cannot set fewer seats than the number of active people in your account.
  </Accordion>

  <Accordion title="What happens when I add seats mid-cycle?">
    Beebole shows the prorated amount due for the rest of the current period before anything changes. The new seats take effect only after you click **Confirm** to authorize that charge.
  </Accordion>

  <Accordion title="How do I switch between monthly and yearly billing?">
    Open **Settings** > **Subscription** and use the **Billing interval** control to switch between **Monthly** and **Yearly**. A yearly plan saves 10% over paying monthly.
  </Accordion>

  <Accordion title="Where do I find my invoices?">
    On the subscription page, click **Manage** to open the Stripe portal. Download past invoices, update your card or billing details, or cancel from there.
  </Accordion>

  <Accordion title="What happens if I downgrade to the free plan?">
    Your paid subscription ends immediately and no refund is issued for the remaining period. You keep access to your core data on the **Free** plan (up to 5 seats), but the paid features your plan included are no longer available.
  </Accordion>
</AccordionGroup>


# Tags: organize people, projects, and tasks
Source: https://beebole.com/help/documentation/tags

Group people, projects, and tasks in Beebole with hierarchical tags — departments, teams, locations — and cascade schedules, rates, and approvals through them.

Tags in Beebole are hierarchical labels you apply to people, projects, and tasks. While [projects](/help/documentation/projects) describe *what* your team works on, tags describe how that work is organized — by department, team, location, cost center, or any dimension that matters to you. Tags also carry configuration: schedules, rates, approval workflows, and more cascade from a tag to everyone and everything in it.

<div>
  <iframe title="Define Tags in Beebole" />
</div>

***

## How tags are organized

Tags use the same structure as projects:

* **Categories** — Each category captures one dimension of your organization. A new account starts with **Department** and **Location**.
* **Tags** — The labels inside a category, such as a department name or a country.
* **Sub-tags** — Nested tags for finer grouping. Each category names its own levels — the **Department** category starts with the levels **Division** and **Team**, and **Location** with **State** and **City**.

A person, project, or task can hold tags from several categories at once — someone can be in a **Department** tag and a **Location** tag at the same time, and each tag cascades its configuration independently.

***

## Creating tags

<Steps>
  <Step title="Open the Tags page">
    Click **Tags** in the sidebar.
  </Step>

  <Step title="Pick a category">
    Click the category name next to the **Tags:** heading and select a category. To create a new one, type its name in the field at the bottom of that menu and click **Add**.
  </Step>

  <Step title="Add the tag">
    Click the **Add \[category]** button at the top right — its label shows the active category, for example **Add Department**. Enter the tag name and click the **Save new…** button (its label ends with the level you are creating).
  </Step>

  <Step title="Add sub-tags (optional)">
    In the tag list, expand the parent tag, then click the **+** button next to the level name below it (its tooltip reads **Add** followed by the level name, for example **Add Team**).
  </Step>
</Steps>

### Importing multiple tags at once

To create a whole tag tree in one go, use the **Or add multiple entries** area in the add panel:

1. Open your list of tags in a spreadsheet and copy the rows — one tag per line, using **Tab** or spaces to indent sub-levels.
2. Click **Paste**.
3. Review the entries to be imported, then click **Add them all**. If something looks wrong, click **Undo**.

### Renaming hierarchy levels

Each category stores its own level names, so the interface can speak your organization's vocabulary. Expand a tag in the list and click the level name shown above its children — the tooltip reads **Click to edit the level name for the whole category**. The new name applies to that level across the whole category.

***

## Moving a tag

You move a tag by changing its parent from the tag's detail panel:

<Steps>
  <Step title="Open the tag">
    Click **Tags** in the sidebar, then click the tag to open its details.
  </Step>

  <Step title="Open the parent selector">
    Hover over the breadcrumb above the tag name and click the **Change parent** button that appears.
  </Step>

  <Step title="Pick the new parent">
    Select the new parent tag or the category root. The change is saved immediately, and the tag's sub-tags move with it.
  </Step>
</Steps>

<Info>
  A tag can only be moved within its own category — the parent selector lists destinations from the same category and excludes the tag's own sub-tags. To use a tag in another category, create it there and re-assign the tagged people or projects.
</Info>

***

## Tagging people, projects, and tasks

You can assign tags from either side of the relationship.

<Tabs>
  <Tab title="From the person, project, or task">
    Open the person's, project's, or task's details — for example, click **People** in the sidebar, then click the person. Click the **Tags** panel to open it, then pick a tag in the **Add a tag here** field. To remove a tag, hover over its badge and click **Remove tag**. Hovering over a tag badge also reveals a calendar button (**Pick a start date**) to set the date the assignment takes effect.
  </Tab>

  <Tab title="From the tag">
    Open the tag's details and click the **Who or what has been tagged?** panel. It has **People**, **Projects**, and **Tasks** sections — use the **Select person**, **Select project**, and **Select task** fields to add entries, and remove them from the same lists.
  </Tab>
</Tabs>

<Info>
  Tags applied to a parent project are inherited by its subprojects. An inherited tag shows where it was defined and can only be removed on the parent.
</Info>

***

## What cascades through tags

Configuration set on a tag applies to all people and projects in it, unless overridden at a more specific level. A tag's detail panel includes these settings panels:

| Panel                    | What inherits                                                                                                                                                   |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Work schedule**        | People in the tag follow the tag's schedule. See [Work schedules](/help/documentation/work-schedule).                                                           |
| **Billing** and **Cost** | Tag-level rates apply to tagged people and projects. See [Billing rates](/help/documentation/billing) and [Cost rates](/help/documentation/costs).              |
| **Approval workflow**    | Approval stages defined on the tag apply to its members. See [Approval](/help/documentation/approval).                                                          |
| **Absence allowances**   | Time-off allowances set on the tag apply to its people. See [Time off](/help/documentation/timeoff).                                                            |
| **Public holidays**      | A holiday calendar assigned to the tag covers its people. See [Public holidays](/help/documentation/public-holidays).                                           |
| **Timesheet settings**   | Timesheet rules — periods, timers, reminders — set on the tag override the organization defaults for its people.                                                |
| **Show or Hide**         | Which time off types, expense types, projects, tasks, and custom fields are available to people in the tag. See [Assignments](/help/documentation/assignments). |

Because a person can belong to tags in several categories, you can compose configuration: a work schedule from a **Location** tag and an approval workflow from a **Department** tag, for example.

<Info>
  Configuring these settings on tags is available on higher-tier Beebole plans. Creating tags and tagging people, projects, and tasks works on every plan.
</Info>

***

## Tags in reports

Tags appear as grouping and filtering dimensions in [Reports](/help/documentation/reports). Group a report by tag to break down time, costs, and billing by department, team, or location — or filter by a tag to narrow the report to one organizational unit.

***

## Managing tags

Each tag has a **⋯** action menu — it appears when you hover over the tag's row in the list, and next to the tag name in its detail panel. It offers **Duplicate**, **Rename**, **Archive**, **Unarchive**, and **Delete**.

Archived tags are hidden from the list — click **Show Archived** at the top of the page to display them, and **Hide Archived** to hide them again.

<Warning>
  **Delete** permanently removes the tag and its assignments. To retire a tag while keeping it available for historical reporting, use **Archive** instead. If you delete by mistake, click **Undo** in the notification that appears right after.
</Warning>

***

## Related content

<CardGroup>
  <Card title="People" icon="users" href="/help/documentation/people">
    Add and manage team members, then tag them to inherit schedules, rates, and availability.
  </Card>

  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Build your project hierarchy and tag projects by client type, service line, or business unit.
  </Card>

  <Card title="Work schedules" icon="clock" href="/help/documentation/work-schedule">
    Set a work schedule on a tag so everyone in the group inherits the same pattern.
  </Card>

  <Card title="Assignments" icon="user-check" href="/help/documentation/assignments">
    Control which projects, time off types, and expense types are available to each person or group.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What's the difference between tags and project categories?">
    Project categories are part of Beebole's project hierarchy — every project belongs to exactly one. Tags are a separate, cross-cutting dimension applied to people, projects, and tasks. Use categories to structure the work itself, and tags for organizational dimensions like departments or locations.
  </Accordion>

  <Accordion title="Can a person or project have multiple tags?">
    Yes. In Beebole, a person can hold tags from several categories at once — for example, an **Engineering** tag from a Department category and a **London** tag from a Location category. Each tag cascades its configuration independently.
  </Accordion>

  <Accordion title="Are tags required for time tracking?">
    No. Your team can track time in Beebole without any tags. Tags become valuable when you want group-level configuration — schedules, rates, approvals — or reporting by department, team, or location.
  </Accordion>

  <Accordion title="Can I move a tag to a different category?">
    The **Change parent** control in Beebole moves a tag anywhere within its own category, together with its sub-tags. To use a tag in another category, create it there and re-assign the tagged people or projects.
  </Accordion>

  <Accordion title="How do I create many tags at once?">
    Use the **Or add multiple entries** area in Beebole's add panel: copy your tag list from a spreadsheet — one tag per line, indenting sub-levels with **Tab** or spaces — click **Paste**, review the preview, and click **Add them all**.
  </Accordion>
</AccordionGroup>


# List view: tasks as a sortable table
Source: https://beebole.com/help/documentation/task-list

Work your Beebole tasks as a spreadsheet — the List view puts every task column in a sortable table, with in-place editing and multi-row mass edits.

Beebole's List view shows your [tasks](/help/documentation/planning) as a plain table — one header row, then one row per task — using the same columns as the Gantt chart, but sortable and without a timeline taking up half the screen. Use it when you want to work the list rather than look at it: find the tasks nobody owns, order everything by date, or change a field on twenty tasks at once. It is one of the four views of the **Planning** page, alongside the [Gantt chart](/help/documentation/gantt), the [Kanban board](/help/documentation/kanban), and the [Staffing view](/help/documentation/staffing) — all show the same tasks, so a change in one view appears instantly in the others.

***

## Opening a List view

<Steps>
  <Step title="Open the Planning page">
    Click **Planning** in the sidebar. Pick the planning you want at the top of the page.
  </Step>

  <Step title="Select a List view">
    Click a List view tab above the task list. To create another one, click **Add a view** and select **List** — each view keeps its own columns, sort order, and grouping.
  </Step>
</Steps>

***

## Reading the table

Every task you can see is one row. The header row stays visible while you scroll down, and the table scrolls sideways inside its own area when the columns are wider than the screen — the page itself never scrolls horizontally.

* **Row #** and **Task Name** are always shown, in that order. A new List view starts with just those two.
* Anything that is an entity — the owner, the potential owners, the tags, the dependencies, the projects of each category — is drawn as a badge with its ancestors, not as bare text. Click a badge to open that entity, or **Shift**+click it to add it as a filter.
* A task with subtasks shows a chevron in its **Task Name** cell. Click it to reveal the subtasks indented underneath, or hold **⌘** while clicking to expand or collapse every task at the same level at once (the chevron's tooltip says **⌘+Click for all**).
* Subtasks always stay under their parent. Sorting and grouping never separate a child from its parent.

<Info>
  Each List view remembers what you set on it: the columns shown, their order and widths, the sort, the grouping, which parents are expanded, which groups are collapsed, and its filters. Open it again tomorrow and it looks the way you left it.
</Info>

***

## Choosing columns

Open the **⋯** menu on the active view tab and hover over **Columns** to show or hide columns. Selected columns appear first in the submenu, the rest below in alphabetical order.

| Column               | What it shows                                                        |
| -------------------- | -------------------------------------------------------------------- |
| **Row #**            | The row's position in the current display, used to type dependencies |
| **Task Name**        | The task name, its parent, and the expand chevron                    |
| **Dependencies**     | Row numbers of the tasks this task depends on                        |
| **Dates**            | The task's start and end dates                                       |
| **Owner**            | The person who owns the task                                         |
| **Potential owners** | The people or tags the task is assigned to                           |
| **Planned**          | Planned time, in hours or days                                       |
| **Occupation**       | The share of the owner's capacity the task takes, as a percentage    |
| **Status**           | The task's current status                                            |
| **Tags**             | Tags applied to the task                                             |

In addition, one column per [project category](/help/documentation/projects) is available, showing the projects from that category linked to each task.

The **Planned** figures follow the unit chosen under **Durations in** in the same menu — **Hours** or **Days**.

### Reordering and resizing columns

* **Reorder** — Drag a column header sideways and drop it where you want it. **Row #** and **Task Name** stay first and can't be moved.
* **Resize** — Drag the right edge of any column header. Widths are saved with the view.

***

## Sorting

Click a column header to sort the table by that column. Click it again to reverse the direction, and a third time to go back to the manual order — a small arrow on the header shows which column is sorted and which way. One column is sorted at a time. The header's own menu offers the same actions by name: **Sort ascending**, **Sort descending**, and **Hide column**.

Sorting applies among siblings: top-level tasks are ordered among themselves, and each parent's subtasks among themselves, under their parent. With a grouping active, sorting applies inside each group.

| Column                                                 | Sorted by                                                                                      |
| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------- |
| **Task Name**, **Owner**, **Tags**, project categories | The displayed name, alphabetically — when a cell holds several entities, the first one decides |
| **Potential owners**                                   | The first person's name, or the first tag's name when no person is assigned                    |
| **Dates**                                              | Start date, then end date for ties                                                             |
| **Planned**, **Occupation**                            | The figure, numerically                                                                        |
| **Dependencies**                                       | The number of dependencies                                                                     |
| **Status**                                             | The order of the planning's statuses, not the alphabet                                         |
| **Row #**                                              | Nothing — it returns the table to the manual order                                             |

Tasks with an empty value in the sorted column sit at the end, whichever direction you choose.

<Info>
  **Row #** is the row's position in what you are looking at right now, like a spreadsheet, and dependencies point to those numbers. While a sort is active the row number replaces the drag handle used to reorder rows by hand — click the **Row #** header (or **Manual order** in its menu) to get the handles back.
</Info>

***

## Grouping rows

Open the **⋯** menu on the active view tab and hover over **Group by** to restructure the list without changing any task data:

* **Owner** — One group per task owner
* **Status** — One group per status
* **Project categories** — Group by a level of any project category
* **Tag categories** — Group by a level of any [tag](/help/documentation/tags) category

Select **None** to remove grouping. Each group gets a header line with the group as a badge and the number of tasks in it; click the header to collapse or expand that group, or hold **⌘** while clicking to collapse or expand them all. With a grouping active, **Show all groups** also displays the empty ones — useful to see owners or statuses that currently have no tasks.

***

## Editing in the table

Every value cell in the List is a control, so you can fill in a whole column without opening a single task.

| Column                         | How you change it                                                                                                                                   |
| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Status**                     | Step to the previous or next status with the chevrons, or click the status name to pick any of them                                                 |
| **Owner**                      | Click the badge's remove icon to clear the owner, or the person button on an empty cell to pick someone (**Select the owner**)                      |
| **Dates**                      | Click the cell to open the task's period editor                                                                                                     |
| **Planned**                    | Type the figure in the cell, in the unit set by **Durations in**                                                                                    |
| **Occupation**                 | Type a percentage between 0 and 100                                                                                                                 |
| **Potential owners**, **Tags** | Click the **+** button to open a small editor with the current badges — removable — and a picker to add more                                        |
| Project categories             | Same editor: remove the project that is set, then pick another from the category                                                                    |
| **Dependencies**               | Click the cell, then click the tasks it depends on or type their row numbers — see [task dependencies](/help/documentation/gantt#task-dependencies) |

Changes are saved as you make them. Editing a value never re-sorts the table under your cursor: the new order arrives the next time you click a header or reload the view.

<Tip>
  A parent task shows its subtasks' totals rather than its own values, so **Planned**, **Occupation**, and **Dates** aren't editable on a parent row. Change the subtasks instead.
</Tip>

### Editing several tasks at once

Build a selection first, then edit any row inside it — the change applies to every selected task:

* **⌘+Click** (Ctrl+Click on Windows) a row to add it to or remove it from the selection.
* **Shift+Click** extends the selection to a range.
* Change a value on any selected row and every selected task gets it. Change a row outside the selection and only that row changes.
* Press **Esc** to clear the selection, or **Delete** (or **Backspace**) to delete every selected task.

A mass change is a single undo step, however many tasks it touched: **⌘Z** brings all of them back at once, **⇧⌘Z** reapplies them.

<Warning>
  A task that has time records logged against it cannot be deleted, so a bulk delete stops on it. Archive those tasks instead, from the task's **⋯** menu.
</Warning>

***

## Filtering and searching

Use the **Filters** button to narrow the table — by task, status, owner, potential owner, project, or [tags](/help/documentation/tags) — with the active filter count shown on the button. Filters are saved with the view and can be switched off and back on without losing them: the button toggles them rather than clearing them.

To search by name, use the task filter's **contains** or **starts with** condition. **Shift**+clicking any badge in the table adds that entity as a filter, which is the fastest way to narrow down to one client, one owner, or one tag.

***

## Keyboard navigation

The List responds to the same keys as the Gantt chart:

| Key                           | Action                                                 |
| ----------------------------- | ------------------------------------------------------ |
| **Arrow Down** / **Arrow Up** | Move the selection to the next or previous row         |
| **Arrow Right**               | Expand the selected task and move into its first child |
| **Arrow Left**                | Collapse the selected task, or move up to its parent   |
| **Enter**                     | Open or close the detail panel of the selected task    |
| **Tab**                       | Make the selected task a subtask of the task above it  |
| **Shift+Tab**                 | Move the selected subtask up one level                 |
| **⌘+A**                       | Add a new task — a subtask if a task is open           |

***

## Saved views

The tabs above the task list are saved views, and a planning can hold as many List views as you need — one per way of working the list.

* **Create** — Click **Add a view**, then **List**.
* **Rename** — Double-click the tab (or long-press it on a touch screen) and type the new name, or use **Rename** in the tab's **⋯** menu.
* **Duplicate or delete** — Use **Duplicate** and **Delete** in the **⋯** menu. The last remaining view cannot be deleted.

***

## Related content

<CardGroup>
  <Card title="Tasks" icon="list-check" href="/help/documentation/planning">
    What tasks are in Beebole — creating, importing, assigning, and tracking time on them.
  </Card>

  <Card title="Gantt chart" icon="chart-gantt" href="/help/documentation/gantt">
    The same columns beside a timeline, with dependencies and a workload heatmap.
  </Card>

  <Card title="Kanban board" icon="square-kanban" href="/help/documentation/kanban">
    Move the same tasks through status columns with drag and drop.
  </Card>

  <Card title="Staffing" icon="users" href="/help/documentation/staffing">
    Book people onto projects on a per-person timeline and balance workload against capacity.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How do I sort my Beebole tasks by date or by owner?">
    Open a List view and click the **Dates** or **Owner** column header. The first click sorts ascending, the second descending, and the third returns the table to the manual order. Sorting happens among siblings, so subtasks stay grouped under their parent.
  </Accordion>

  <Accordion title="Can I change the same field on many tasks at once?">
    Yes. **⌘+Click** rows to build a selection (or **Shift+Click** for a range), then change the value on any row inside the selection — every selected task in Beebole gets it, as one undo step. **Delete** removes the whole selection at once.
  </Accordion>

  <Accordion title="What is the difference between the List view and the Gantt chart?">
    Both show the same tasks with the same columns. The Gantt chart pairs those columns with bars on a timeline, for scheduling and dependencies. The List view drops the timeline and gives the columns the whole width, adds sorting, and lets you reorder and resize them — better for finding, checking, and mass-editing tasks.
  </Accordion>

  <Accordion title="Why can't I move the Row # and Task Name columns?">
    Those two are fixed in Beebole: **Row #** carries the numbers dependencies point to, and **Task Name** carries the hierarchy chevron, so both stay at the left of the table. Every other column can be dragged into any order and resized.
  </Accordion>

  <Accordion title="Can I export the List view?">
    Not from the view itself — the List view in Beebole is a working table, not an export. Build the figures you need in [Reports](/help/documentation/reports) instead, then [download them](/help/documentation/data-exports) as Excel, CSV, or PDF.
  </Accordion>
</AccordionGroup>


# Time off: absence types, allowances, and balances
Source: https://beebole.com/help/documentation/timeoff

Configure absence types, set quotas, track balances, and manage vacation, sick leave, and other time-off requests for your team in Beebole.

Beebole's time-off management lets you define absence types, assign individual allowances, and track balances in real time. Your team records time off directly on their timesheets — each entry counts against the balance as soon as it's recorded — and the approval workflow lets managers review every absence.

<Info>
  Time off in Beebole is tracked through **absence types** — categories like vacation, sick leave, or parental leave that you define to match your organization's policies.
</Info>

<div>
  <iframe title="Add Time Off Types" />
</div>

***

## Understanding absence types

An absence type represents a category of leave your organization recognizes. Common examples include vacation, sick leave, parental leave, and personal days — but you can create as many types as you need.

Each absence type can be configured with:

* **A name** — The label your team sees when logging time off (e.g., "Vacation", "Sick Leave").
* **A unit** — Whether absences are tracked in **Hour** or **Day** units.
* **An allowance** — The amount of time off each person receives per period.
* **An accrual policy** — Rules describing how time off accumulates over the allowance period. See [Accruals](/help/documentation/accruals).

***

## Creating absence types

<Steps>
  <Step title="Open the Time Off settings">
    Go to **Settings** > **Time Off**.
  </Step>

  <Step title="Add a new absence type">
    Click **Add Time Off Type**, enter a **Name** for the absence type (e.g., "Vacation", "Sick Leave"), and click **Add Time Off Type**.
  </Step>

  <Step title="Choose the unit">
    In the **Units** panel, select whether this absence type is tracked in **Hour** or **Day** units. The change is saved automatically, and the new absence type is available for allowances and timesheet entry.
  </Step>
</Steps>

<Tip>
  Create separate absence types for each leave category your company offers. This gives you granular reporting and lets you set different allowance rules per type.
</Tip>

***

## Archiving absence types

When a leave category is no longer offered, archive its absence type instead of deleting it — past time-off records stay intact while the type disappears from day-to-day use.

1. Go to **Settings** > **Time Off** and open the absence type.
2. Click the **⋯** action menu next to its name, then **Archive**.

To restore an archived type, click **Show Archived** in the list, open the archived type, and click the **⋯** action menu, then **Unarchive**. The same menu also offers **Duplicate**, **Rename**, and **Delete**.

***

## Setting up allowances

An allowance (Beebole's term for a time-off quota) defines how much time off a person receives for a given absence type within a specific period. You can set allowances on the organization for everyone, on a tag for a group, or on an individual person.

<Steps>
  <Step title="Open the Absence allowances panel">
    For an organization-wide default, go to **Settings** > **Account Settings**. For a group, click **Tags** in the sidebar and open the tag. For one person, click **People** in the sidebar and open their profile. Each shows an **Absence allowances** panel.
  </Step>

  <Step title="Add the allowance">
    Click **+ Add new allowance** and select the absence type.
  </Step>

  <Step title="Define the period">
    Set the start and end dates of the allowance period (e.g., January 1 to December 31 for an annual allowance).
  </Step>

  <Step title="Set the amount">
    Enter the amount the allowance grants. Each field states the unit it is counted in — days or hours, following the absence type's own unit — so an hour-based allowance can't be mistaken for a day-based one. Every change is saved automatically — there is no save button.
  </Step>
</Steps>

<Info>
  To give specific people a different allowance, add one on their profile under **People** — person-level allowances override tag-level ones, which override the organization default. See [People](/help/documentation/people).
</Info>

### Carrying unused time off forward

Unused allowance can carry into the next period. Two fields on the allowance control it:

* **Valid until** — How long the carried balance remains usable after the period ends.
* **Carry forward limit** — The maximum amount that carries over. Leave it at 0 for no cap.

The carried balance counts everywhere the allowance does: booking limits respect it, and the [Absence quotas report](/help/documentation/reports#absence-quotas) shows it per person, including the **Valid until** and **Carry forward limit** columns.

***

## Tracking balances

Beebole tracks time-off balances based on allowances, accruals, and recorded absences. **Available**, **Consumed**, and **Accrued** sit at the top of each card in the **Absence allowances** panel, right after the absence type, and every figure carries its unit — days or hours — in the input and in the card's summary line:

| Balance field | What it shows                                                                                |
| ------------- | -------------------------------------------------------------------------------------------- |
| **Available** | The amount of time off granted for the allowance period                                      |
| **Consumed**  | The time off already recorded over the period (shown when you open an allowance on a person) |
| **Accrued**   | A manual adjustment field for accrued time                                                   |

The **Carry forward limit** states its unit the same way. Balances update as team members log time off on their timesheets and when you adjust the **Accrued** field on the allowance.

***

## Negative balance controls

By default, Beebole prevents people from booking more time off than their available balance. You can change this behavior per allowance.

To let a balance go below zero — useful for organizations that handle overdrawn leave manually or at year-end — open the allowance in the **Absence allowances** panel and check **Allow negative balance**. The change is saved automatically. When the box is unchecked, Beebole blocks time-off entries that would push the balance below zero.

<Warning>
  If you allow negative balances, monitor them regularly. Beebole can send notifications when a person's balance goes negative — see the notifications section below.
</Warning>

***

## Time off and people costs

Time off counts toward people cost totals. A leave day is valued with the person's [cost rate](/help/documentation/costs) for that day — Beebole multiplies the absence duration by the rate exactly as it would for a regular time entry — so leave appears in budgets and profitability reports alongside billable work, even though no project time was tracked.

<Info>
  There is no per-type switch for this today: every time off type is treated the same way in cost calculations. Time off never affects billing amounts — only costs.
</Info>

***

## Absence approval

Time-off entries follow the same approval workflow as regular time entries. When a person records an absence on their timesheet and submits it, the assigned manager reviews and approves or rejects it.

Approval does not gate the balance: every recorded time-off entry counts against the allowance immediately, even before it is reviewed. Approving locks the timesheet; if an absence is rejected, the person can edit or remove the entry, which restores the balance.

<Info>
  The approval workflow for absences is part of Beebole's general timesheet approval process. See [Approvals](/help/documentation/approval) for details on configuring approval stages and managers.
</Info>

***

## Absence notifications

Beebole can send automatic notifications related to time off to keep managers and administrators informed. They are configured per absence type, in the **Time off notifications** panel:

* **Going negative** — Triggered when a person's balance drops below zero.
* **Requesting in advance against accruals** — Triggered when someone requests time off they have not yet accrued.
* A frequency alert — Triggered when a person takes this absence type more than a set number of occurrences in a **Month** or **Year**.

To configure them, go to **Settings** > **Time Off**, click the absence type, and check the alerts you want in the **Time off notifications** panel. Changes are saved automatically. See [Notifications](/help/documentation/notifications) for the full setup.

***

## Recording time off on the timesheet

Team members record absences directly on their timesheets, just like regular time entries.

<Steps>
  <Step title="Open the timesheet">
    Click **Timesheet** in the sidebar and select the relevant week.
  </Step>

  <Step title="Add an absence row">
    Click **Add a row**. Select the absence type (e.g., "Vacation") instead of a project.
  </Step>

  <Step title="Enter the time off">
    Enter the number of hours or days for each day of the week.
  </Step>

  <Step title="Submit the timesheet">
    Click **Submit** to send the timesheet for approval. The time off counts against the balance as soon as it is recorded.
  </Step>
</Steps>

<Tip>
  If your organization tracks absences in days, a full day off equals the number of hours defined in the person's [work schedule](/help/documentation/work-schedule).
</Tip>

***

## Related content

<CardGroup>
  <Card title="Accruals" icon="calendar" href="/help/documentation/accruals">
    Configure how time-off allowances accrue on a recurring schedule.
  </Card>

  <Card title="Public Holidays" icon="clock" href="/help/documentation/public-holidays">
    Define non-working days so they don't consume time-off allowances.
  </Card>

  <Card title="Work Schedule" icon="users" href="/help/documentation/work-schedule">
    Set working hours so day-based absences calculate correctly.
  </Card>

  <Card title="Approvals" icon="check" href="/help/documentation/approval">
    Understand how absence entries flow through the approval workflow.
  </Card>
</CardGroup>

***

<Steps>
  <Step title="Open the timesheet">
    Navigate to **Timesheets** and select the relevant week.
  </Step>

  <Step title="Add an absence row">
    Click the **\[+]** button to add a new row. Select the absence type (e.g., "Vacation") instead of a project.
  </Step>

  <Step title="Enter the time off">
    Enter the number of hours or days for each day of the week.
  </Step>

  <Step title="Submit the timesheet">
    Click **Submit** to send the timesheet for approval. The time off counts against the balance once approved.
  </Step>
</Steps>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I set different time-off allowances for different people?">
    Yes. Add an allowance in the **Absence allowances** panel of a person's profile under **People**. Person-level allowances take priority over tag-level ones and the organization default.
  </Accordion>

  <Accordion title="What happens when someone exceeds their time-off balance?">
    It depends on the allowance. If **Allow negative balance** is checked, the person can continue booking time off and their balance shows a negative number. If not, Beebole blocks the entry.
  </Accordion>

  <Accordion title="How does time off interact with approvals?">
    Time-off entries follow the same approval workflow as regular timesheet entries. Absences count against a person's allowance as soon as they are recorded — approval reviews and locks the timesheet but does not change the balance. See [Approvals](/help/documentation/approval).
  </Accordion>

  <Accordion title="Can I track time off in both hours and days?">
    Each absence type uses a single unit — **Hour** or **Day**. If you need both, create separate absence types (e.g., "Vacation (days)" and "Medical appointments (hours)").
  </Accordion>

  <Accordion title="How do accruals work with time-off allowances?">
    Accrual policies describe how leave accumulates over time rather than being granted all at once. Accrued time is reflected on the allowance through its editable **Accrued** field, a manual adjustment to the accrued balance. See [Accruals](/help/documentation/accruals).
  </Accordion>
</AccordionGroup>


# Timesheet and planning settings: configuring time entry
Source: https://beebole.com/help/documentation/timesheetSettings

Configure the Beebole timesheet for your team: period and auto-submit, entry restrictions, time entry unit and timer, categories, and reminders.

Timesheet settings control how everyone in your Beebole account records time: the period they fill and submit, the unit and format for entries, what they can track time on, which restrictions apply, and when Beebole sends reminders. While people use the timesheet itself from the sidebar (see [Timesheets](/help/documentation/timesheets)), you configure it from the **Timesheet and Planning Settings** panel.

<Info>
  Every change in the **Timesheet and Planning Settings** panel is saved automatically — there is no save button.
</Info>

<Frame>
  <iframe title="Configure timesheet settings in Beebole" />
</Frame>

***

## Opening Timesheet and Planning Settings

<Steps>
  <Step title="Open the Settings menu">
    Click the button with your initials at the bottom of the left sidebar.
  </Step>

  <Step title="Go to Account Settings">
    Click **Account Settings** to open your organization's settings.
  </Step>

  <Step title="Open the Timesheet and Planning Settings panel">
    Open the **Timesheet and Planning Settings** panel. Its options are grouped into five tabs: **Period & submission**, **Categories**, **Time entry**, **Reminders**, and **Auto Timesheet from Planning**.
  </Step>
</Steps>

Settings made here apply account-wide. The same panel also exists on every tag and on each person's profile, so you can override any setting for one team or one person — see [Different settings for different teams](#different-settings-for-different-teams).

***

## Period & submission

### Timesheet period

The **Timesheet period** defines the stretch of time a timesheet covers — the period people fill in, submit, and have approved as one unit. It is not just a display preference: each period is one timesheet.

| Period           | The timesheet covers                                                                |
| ---------------- | ----------------------------------------------------------------------------------- |
| **Daily**        | A single day. The grid shows one day with each row's full entry form inline.        |
| **Weekly**       | One week, starting on your account's first day of the week. This is the default.    |
| **Bi-weekly**    | Two consecutive weeks.                                                              |
| **Semi-monthly** | Half a month: the 1st through the 15th, then the 16th through the end of the month. |
| **Monthly**      | A calendar month.                                                                   |

<Info>
  Weekly and bi-weekly periods start on the day set as **First day of the week** in the **Localization** panel of **Account Settings**.
</Info>

### Auto-submit

**Auto-submit timesheets after X days** submits unsubmitted timesheets automatically once the configured number of days has passed since the period ended. The auto-submitted timesheet enters the [approval workflow](/help/documentation/approval) like a manual submission. Leave the value at 0 to disable auto-submit.

At the deadline, [suggested time entries](/help/documentation/ai) still pending on the period are converted into real entries before the submission, so a timesheet assembled from suggestions submits itself. Every entry still respects the entry rules — a suggestion a restriction refuses is trimmed to fit the day's remaining scheduled time, or skipped if it still doesn't fit. [Timesheet reminders](#reminding-people-to-submit) announce the deadline in advance, so nobody is surprised by an automatic submission.

Auto-submit only ever acts on one period per person: the most recent one whose deadline has passed. Older periods are never revisited, so switching the setting on doesn't submit months of history at once. A period that already has a status — submitted, approved, or rejected — is left alone, and an empty period is never submitted: if it holds no time entries and no suggestion could be converted, nothing is sent to approvers.

If a period can't be processed, it stays a draft and is badged **Auto-submit failed** in the approval view — administrators are notified so they can review it by hand.

### Lock date

The **Lock date** freezes every time record on or before the chosen day. Time records on or before that day can no longer be created, edited, moved, or deleted — by anyone, administrators included. Attempts are refused with the message **Timesheet and Planning Settings prevent any change to the locked date**.

Use it to close accounting periods: once payroll or invoicing for a month is done, set the lock date to the end of that month and the underlying data can't drift. The freeze applies everywhere time records change hands, including the [BambooHR time-off sync](/help/integrations/bamboohr).

The lock also closes the period to submission. A period whose last day is on or before the lock date can no longer be submitted for approval — Beebole answers **This period is locked and cannot be submitted for approval.** A period that straddles the lock date stays submittable by hand, since its unlocked days are still the person's to account for, but auto-submit leaves it alone: it skips any period that starts on or before the lock date.

When several entries are deleted at once — clearing a section, or deleting a selection in the calendar — Beebole checks every entry before removing any of them. If one of them falls on or before the lock date, nothing is deleted.

<Info>
  To correct data in a locked period, move the **Lock date** back first, make the fix, then restore it. Like every timesheet setting, the lock date can also be set per person or per team — see [Different settings for different teams](#different-settings-for-different-teams).
</Info>

### Restrictions

The **Restrictions** list controls what time entries the timesheet accepts. New accounts start with two restrictions active: **An absence can't be longer than a day** and **Require filling the whole schedule to submit** (period). When none is active, the panel shows **No restrictions configured**. Pick a rule from the **Add restriction** menu to activate it; click the × on a restriction's chip to remove it.

| Restriction                                           | What it does                                                                                                                                                                                                                                                            |
| ----------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **No overtime beyond the schedule**                   | Blocks time beyond the hours in the person's [work schedule](/help/documentation/work-schedule). Available in a **daily** variant (per day) and a **period** variant (per timesheet period).                                                                            |
| **Require filling the whole schedule to submit**      | The timesheet can only be submitted once all scheduled time is filled — per day (**daily**) or across the period (**period**).                                                                                                                                          |
| **Only time off can be recorded in the future**       | Blocks time entries on future dates. Future entries are limited to time off requests, so people can still plan vacation ahead.                                                                                                                                          |
| **Only allow time entries on scheduled working time** | Blocks entries on scheduled days off and public holidays — time off entries are exempt.                                                                                                                                                                                 |
| **Keep start/end times within the scheduled hours**   | When start and end times are recorded, an entry's times must fall within the person's scheduled working hours. Available as a **warning** (the entry form warns but allows saving) or a **block** (the entry is refused, including when copying entries to other days). |
| **An absence can't be longer than a day**             | Caps a single time off entry at one day.                                                                                                                                                                                                                                |
| **Only the owner or an admin can edit entries**       | Only the person the timesheet belongs to, or an admin, can add or edit its entries.                                                                                                                                                                                     |
| **Only an admin can edit someone else's timesheet**   | Managers can still view their team's timesheets, but adding or editing entries on someone else's timesheet is reserved for admins.                                                                                                                                      |

Restrictions with **daily** and **period** variants show each active variant as a tag on the chip, and you can activate one or both. The **warning** and **block** variants are exclusive — activating one replaces the other.

Independently of any restriction, a submitted or approved period is locked for its owner while it waits in the [approval workflow](/help/documentation/approval), and records on or before the [**Lock date**](#lock-date) can't change at all.

### Rules set elsewhere

Two more rules apply to every time entry without appearing in the **Restrictions** list, because they are configured on the entities they protect:

* **Valid period for time entry** — This panel, available on a project, a person, and a tag, sets a **From** and **To** date between which time can be logged. An entry outside the window is refused with **This time record falls outside the validity period of:** followed by the project or person it comes from. When several windows could apply, the most specific one wins: the entry's project first (its deepest level first), then the person, and a person or project inherits a window set on its tags.
* **Time off allowances** — A time off entry can't push the person past the balance of the [allowance](/help/documentation/timeoff) that covers that day. Beebole refuses it with **This booking exceeds the available quota for:** followed by the absence type. An allowance with **Allow negative balance** checked lifts the limit for the days it covers, and an absence type with no allowance is never limited.

***

## Time entry

The **Time entry** tab defines what people type into a timesheet cell.

### Unit for time entry

**Unit for time entry** sets the unit for every timesheet cell:

| Unit                       | People enter                                       |
| -------------------------- | -------------------------------------------------- |
| **Hours**                  | A duration in hours, in the format set below.      |
| **Day or fraction of day** | Full or partial workdays, such as `1` or `0.5`.    |
| **% of schedule**          | A percentage of their scheduled time for that day. |

### Duration format

When the unit is **Hours**, two more options appear:

* **Duration format** — how hour values are displayed and typed: **3:15** (hours and minutes), **3.25** (decimal hours), or **3h15** (compact hours-and-minutes notation).
* **Minimum time interval accepted** — the smallest increment the timesheet accepts. Durations are rounded up to the nearest multiple of this interval; new accounts start at 15 minutes.

### Timer, start and end times, and comments

* **Enable timer** adds a timer button to each timesheet row so people can time their work as it happens — see [Using the timer](/help/documentation/timesheets#using-the-timer). Check **Mandatory** next to it to require the timer: durations can then only be recorded by running it.
* **Record start and end times** adds **Start time** and **End time** fields to each entry's details, and Beebole calculates the duration. Check **Mandatory** next to it to require start and end times on every entry.
* **Require comments for submission** requires a note on time entries before the timesheet can be submitted.

Checking **Mandatory** switches its parent option on automatically, and disabling a parent option clears its **Mandatory** checkbox.

***

## Categories

The **Categories** tab decides what people can track time on. Each choice becomes a section of rows in everyone's timesheet.

### Project categories

**Record time on these project categories** lists the [project](/help/documentation/projects) categories available in the timesheet. Each row of the list is one timesheet section:

* A row with a single category — for example **Client** — lets people pick one project from that category per timesheet row.
* A row with chained categories — **First** **Client**, **then** **Activity** — makes people pick one entry for each level: first a client project, then an activity.
* Click **Add a row** to offer an alternative section, and pick its categories with **Pick a category**.

### Plannings

**Record time on these plannings** does the same for [tasks](/help/documentation/planning): people can add timesheet rows for tasks in the selected plannings (task categories). Add one with **Pick a planning**.

### Time off

**Allow recording time off** controls whether a **Time Off** section appears in the timesheet, where people add rows for absence types. See [Time off](/help/documentation/timeoff).

<Info>
  Removing a category here does not delete any time entries. Existing entries remain visible in timesheets and reports — people just can't add new rows for that category.
</Info>

***

## Reminders

The **Reminders** tab configures two kinds of follow-up.

### Reminding people to submit

**Remind to submit** sends a reminder by email, following each person's [notification settings](/help/documentation/notifications), to anyone who hasn't submitted their timesheet. Choose when it goes out:

* **Start of next period** — on the first day of the new period, about the period that just ended.
* **End of current period** — on the last day of the period being filled.

Then pick the hour. The reminder is sent at that hour in each person's time zone, includes a summary of their timesheet, and lets them submit directly from the email. People who already submitted are skipped, and reminders don't apply when the timesheet period is **Daily**.

### Reminding approvers

**Remind approvers after** a number of **days if not yet approved** follows up on submitted timesheets that are still waiting for review. The first reminder goes out the configured number of days after the approver's initial notification; while the timesheet stays pending, Beebole follows up a few more times at increasing intervals. Leave the value at 0 to disable approver reminders.

### Warning about unassigned tasks

**Notify everyone involved** a number of **days before an unassigned task starts** warns about planned work nobody has picked up. The task manager and the people assigned to the task are notified — the admins when the task has no manager. This setting exists account-wide only, and 0 disables it.

***

## Auto Timesheet from Planning

The **Auto Timesheet from Planning** tab turns work planned on [tasks](/help/documentation/planning) into timesheet entries, so people who did what was planned don't have to fill their timesheet by hand.

<Steps>
  <Step title="Enable it">
    Check **Enable Auto Timesheet from planning**.
  </Step>

  <Step title="Pick a planning">
    Add a planning with **Pick a planning**, then choose its **Start** and **End** statuses from the planning's [Kanban workflow](/help/documentation/kanban). Moving a task to the start status starts its clock; moving it to the end status generates the time entries. Remove a planning with the × on its row.
  </Step>

  <Step title="Review the suggestions">
    Generated entries always arrive as [suggestions](/help/documentation/ai) — badged **Kanban** — that the person reviews and accepts. Nothing is written into the timesheet without their say (or, if [auto-submit](#auto-submit) is enabled, until the deadline converts pending suggestions).
  </Step>
</Steps>

When several tasks finish the same day, the day is split between them. Entries the person logged manually are never touched — automatic entries rebalance around them, and each accepted entry records which source it came from.

***

## Different settings for different teams

Timesheet settings cascade. Values set on **Account Settings** apply to everyone, but the same **Timesheet and Planning Settings** panel also appears on every [tag](/help/documentation/tags) and on every person's profile:

* Set a value on a **tag** to override the account default for everyone under that tag — for example, a monthly **Timesheet period** for one department.
* Set a value on a **person** to override both the tag and the account default for that one person.

Next to each setting, an icon shows where its current value is inherited from. After overriding a value, you can reset it to fall back to the inherited one.

***

## Related content

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    How your team uses the timesheet: adding rows, entering time, the timer, and submitting.
  </Card>

  <Card title="Approvals" icon="check" href="/help/documentation/approval">
    Submission, multi-stage approval workflows, and reviewing your team's timesheets.
  </Card>

  <Card title="Work schedules" icon="calendar" href="/help/documentation/work-schedule">
    Define the expected hours that schedule-based restrictions check against.
  </Card>

  <Card title="Account Settings" icon="gear" href="/help/documentation/account-settings">
    Organization-wide settings, including localization and the first day of the week.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How do I change the timesheet from weekly to monthly in Beebole?">
    Open **Account Settings** from the button with your initials at the bottom of the sidebar, open the **Timesheet and Planning Settings** panel, and on the **Period & submission** tab set **Timesheet period** to **Monthly**. The change applies account-wide unless a tag or person overrides it.
  </Accordion>

  <Accordion title="How do I stop people from logging time in the future?">
    In Beebole's **Timesheet and Planning Settings**, on the **Period & submission** tab, open **Add restriction** and pick **Only time off can be recorded in the future**. Work entries on future dates are then blocked, while time off can still be requested ahead of time.
  </Accordion>

  <Accordion title="Can different teams have different timesheet settings?">
    Yes. The **Timesheet and Planning Settings** panel also appears on tags and on each person's profile in Beebole. A value set on a tag overrides the account default for everyone under that tag, and a value set on a person overrides both. Everything else stays inherited.
  </Accordion>

  <Accordion title="What happens if someone forgets to submit their timesheet?">
    Two Beebole settings cover this. **Remind to submit** emails anyone who hasn't submitted, at the hour you choose, with a link to submit directly from the email, announcing the auto-submit deadline when one is set. **Auto-submit timesheets after X days** then submits the timesheet automatically once the configured number of days has passed since the period ended, converting any pending suggested entries into real entries first.
  </Accordion>

  <Accordion title="How do I change the first day of the week?">
    The first day of the week is a regional setting, not a timesheet setting. In **Account Settings**, open the **Localization** panel and set **First day of the week**. Weekly and bi-weekly timesheet periods in Beebole start on that day.
  </Accordion>
</AccordionGroup>


# Timesheets: tracking and submitting your time
Source: https://beebole.com/help/documentation/timesheets

Track time in Beebole's timesheet: add rows for projects, tasks, or time off, enter hours or run a timer, copy periods, and submit for approval.

The timesheet is where each person in Beebole records the time they spend on projects, tasks, and time off. Every entry feeds reports, budgets, billing calculations, and the approval workflow. Open it by clicking **Timesheet** in the left sidebar.

<Info>
  Your administrator chooses the **Timesheet period** — daily, weekly, bi-weekly, semi-monthly, or monthly — along with the time entry unit and any entry restrictions. See [Timesheet and Planning Settings](/help/documentation/timesheetSettings).
</Info>

***

## The timesheet layout

The timesheet is a grid:

* **Sections** group rows by the project or task categories your administrator selected in [Timesheet and Planning Settings](/help/documentation/timesheetSettings). A **Time Off** section appears when recording time off is allowed.
* **Rows** are what you track time against — a project (or chain of projects), a task, or an absence type.
* **Columns** are the days of the current period. Today's date is highlighted, and each day's header shows the time reported so far against your scheduled hours.

Use the date picker at the top of the page to move between periods or jump back to **Today**.

With a **Daily** timesheet period, the grid shows a single day and each row displays its full entry form — duration, times, and note — inline.

The grid is one of two ways to see your timesheet: the toggle at the top of the page switches between **Grid view** and **Calendar view**. See [Calendar view](#calendar-view) below.

***

## Entering time

<Steps>
  <Step title="Open your timesheet">
    Click **Timesheet** in the left sidebar. The timesheet opens on the current period.
  </Step>

  <Step title="Add a row">
    Click the **+** button (**Add a row**) next to a section name. Pick a project from the **Select a project** list — or a task or absence type, depending on the section. If your account chains several project categories, pick one entry for each level.
  </Step>

  <Step title="Type your time in a day cell">
    Click the cell for the right day and type the time you spent. You enter time in the unit your administrator configured — hours, days, or a percentage of your schedule.
  </Step>
</Steps>

Every change is saved automatically — there is no save button on the timesheet.

<Tip>
  Rows you use every period are worth pinning. Open the row's **⋯** action menu and click **Pin to top** so the row keeps its place at the top of its section. Click **Unpin** in the same menu to remove it.
</Tip>

### Entry details

Hover over a cell and click the info icon that appears in its corner to open the entry details. Depending on your account's settings, an entry can hold:

| Field                             | What it does                                                                                                         |
| --------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| **Time spent**                    | The entry's duration.                                                                                                |
| **Start time** and **End time**   | When you started and stopped, if your administrator enabled start and end times. The duration is calculated for you. |
| **Add a note to your time entry** | A free-text note, visible to approvers and in reports. A small text icon marks cells that carry a note.              |
| **Non-billable**                  | Marks this entry as non-billable, regardless of the project's [billing rates](/help/documentation/billing).          |
| **Work from home**                | Flags the entry as remote work.                                                                                      |
| Custom fields                     | Any [custom fields](/help/documentation/custom-fields) your administrator defined for time entries.                  |

The **Non-billable** and **Work from home** checkboxes apply to work entries only — they don't appear on time off entries.

***

## Calendar view

The calendar view lays your period out day by hour, so you place entries in time instead of typing durations. It is the view you land on the first time you open your timesheet; switch between the two with the **Calendar view** and **Grid view** toggle at the top of the page, and Beebole remembers which one you used last. The day grid is tall enough for short entries to stay readable, and a full day fills its column exactly to the end of your schedule — only a genuinely over-booked day is drawn as overflowing.

The day headers are the same as in the grid view — each one shows the time reported so far against the day's scheduled hours, with its progress bar — so the two views always agree on where a day stands.

* **Create an entry** — Click and drag across an empty time slot; the selection shows the total duration alongside the start and end times as you draw. The entry popup opens with the activity picker built in — the entry is created as soon as you pick the project, task, or absence type, and you can still drag the new block to another time or day, or resize it from either edge, before you're done.
* **Create an entry with one click** — Click an empty slot without dragging. When your account doesn't record start and end times, the new entry is pre-filled with the time still missing from that day's schedule — the same figure the day header shows — so the last entry of the day always completes it. On a full, overrun, or unscheduled day, and whenever start and end times are on, the click places a one-hour entry instead.
* **Move an entry** — Drag it to another slot or day. Its duration is preserved.
* **Resize an entry** — Drag its top or bottom edge to change the start or end time. Edges snap to 15-minute steps; hold **⌘** (Ctrl on Windows/Linux) while dragging an edge to snap to whole hours instead.
* **Give an entry a time** — When start and end times are recorded, an entry that has none yet — typed in the grid, for example — sits stacked at the top of its day. Drag it to a slot and it takes the clock time where you release it.
* **Duplicate an entry** — Hold **⌘** (Ctrl on Windows/Linux) while dragging an entry to a new slot.
* **Delete an entry** — Hover over it and click the delete button that appears.
* **Work on several entries at once** — Shift-click to select a range, or **⌘**-click (Ctrl on Windows/Linux) to pick individual entries, then move, duplicate, resize, or delete the whole selection — one undo step reverses the batch.
* **Time an entry** — Hover an entry on today and a play/pause button appears next to the delete button. See [Using the timer](#using-the-timer).

### Favorites

Above the calendar, a favorites bar shows the activities you log most often — the rows you [pinned](#managing-rows) and your recently used projects, tasks, and time off types:

* **Click a favorite** to log it instantly: the entry lands on today (or the first visible day), starts right after your last entry of that day — or at the time you usually begin, when the day is empty — and uses your usual duration for that activity, trimmed so it never exceeds the hours still missing for the day.
* **Drag a favorite** onto the calendar grid to place it exactly where you want it.

Either way, the entry popup opens on the new entry so you can adjust or confirm it without a second click.

<Info>
  Each time entry holds exactly one activity — a task, an absence, or projects. Switching an entry's activity replaces the previous one, so nothing counts twice in reports or totals.
</Info>

Entries created or adjusted here carry real start and end times, which can appear in reports. [Suggested time entries](/help/documentation/ai#suggested-time-entries) show up as ghost entries in the calendar — drag a suggestion to a time slot to schedule it, or accept it as-is.

***

## Using the timer

When your administrator has enabled the timer, each row shows a timer button for the current day. In the [calendar view](#calendar-view), you can also start or pause the clock without leaving the grid:

* **On a calendar entry** — Hover an entry on today for a play/pause button. The entry being recorded is marked with a pulsing red dot and its duration ticks up live, in place.
* **On a favorite chip** — Each chip in the [favorites bar](#favorites) carries its own play/pause button, so a frequent project or task starts tracking in one click.
* **On a suggestion** — The play button on today's [suggested entries](/help/documentation/ai#suggested-time-entries) accepts the suggestion and keeps the clock running on it, in a single undoable step.

<Steps>
  <Step title="Start the timer">
    Click the timer button (**Start timer**) on the row you are working on. The elapsed time starts counting.
  </Step>

  <Step title="Keep working">
    The timer keeps running while you use other parts of Beebole. A floating timer stays on screen so you can check or pause it from any page — see [The floating timer](#the-floating-timer) below.
  </Step>

  <Step title="Pause it when you stop">
    Click the timer button again (**Pause timer**). Beebole saves the elapsed time to the entry, rounded up to the **Minimum time interval accepted** set by your administrator.
  </Step>
</Steps>

A plain click on any play button switches timers: whatever was running is paused and its time saved, then the activity you clicked starts. To run several timers at once, hold **⌘** (Ctrl on Windows/Linux) while clicking a play button — the tooltip reads **⌘+Click to start it without stopping the others** whenever a timer is already running. Each timer counts its own time in full, so two timers running for an hour log two hours. The gesture is the same on every play button: timesheet rows, calendar entries, favorites, suggestions, and the floating timer itself.

<Info>
  When start and end times are enabled and a record for today is already finished, the row's timer button shows **Duplicate and start** — it creates a new entry on the same row and starts timing it. Administrators can also make the timer mandatory, in which case durations can only be recorded by timer.
</Info>

### The floating timer

On desktop, a floating panel appears as soon as a timer runs, and you can drag it anywhere on the page. It lists the activities you timed today, one line each:

* A **running** line shows a pulsing dot, its name, a live counter, and a **Pause timer** button.
* A **paused** line stays listed with the time saved on its entry. Its play button resumes it — a plain click pauses the others first, **⌘**-click (Ctrl-click) adds it to the ones running — and the **×** (**Remove from the timer list**) takes it off the panel. A running line has no **×**: pause it first, so time is never discarded while it is still counting.
* When more than one timer is running, a **Pause all** button appears under the lines and stops them all at once, saving each entry's own time.

Click the chevron on the first line to collapse the panel to dots and counters; hover a dot for the activity's name. The panel only tracks today's activities, and when several entries exist for a day, one line stands for each activity.

If a restriction refuses the time a pause would save — for example **No overtime beyond the schedule** — the timer keeps running and an error explains why, so no time is lost while you fix the day.

<Tip>
  Your browser tab keeps you posted: its title shows the elapsed time while one timer runs, and switches to a count — **2 timers running** — when several do.
</Tip>

***

## Managing rows

Each row has a **⋯** action menu with:

* **Pin to top** / **Unpin** — keep the row at the top of its section.
* **Edit** — change the row's project, task, or absence type selection.
* **Remove row** — take the row off your timesheet.

To clear a whole section at once, hover over the section's header and click the trash button (**Clear all rows in this section**) that appears — it removes that section's rows and their time entries for the current period. The button is hidden on locked periods and when reviewing someone else's timesheet.

There is no confirmation dialog for these actions — press **⌘+Z** (Ctrl+Z on Windows/Linux) to undo.

***

## Copying a period

To reuse a period's rows and entries:

<Steps>
  <Step title="Copy the current period">
    Click the copy button in the cluster at the top-left corner of the grid. A **Copied!** confirmation appears.
  </Step>

  <Step title="Go to another period">
    Use the date picker to open the period you want to fill.
  </Step>

  <Step title="Paste">
    Click the **Paste period** button that now appears next to the copy button. If the period already contains time entries, Beebole asks whether to **Add** the copied entries on top or **Replace** the existing ones.
  </Step>
</Steps>

***

## Undoing and redoing changes

Beebole tracks your recent changes across the app:

| Action | Mac           | Windows / Linux |
| ------ | ------------- | --------------- |
| Undo   | **⌘+Z**       | Ctrl+Z          |
| Redo   | **⌘+Shift+Z** | Ctrl+Shift+Z    |

Undo and redo buttons also appear in the top bar whenever there is history to step through. Deleted entries and rows come back exactly as they were.

***

## Recording time off

When your administrator allows recording time off, the timesheet shows a **Time Off** section. Click its **+** button (**Add a row**), pick an absence type, and enter the time — absence types tracked in days are entered as full or partial days. See [Time off](/help/documentation/timeoff) for absence types, allowances, and approval.

***

## Importing calendar events

You can bring your Google or Microsoft calendar events into the timesheet instead of re-typing meetings.

<Steps>
  <Step title="Open the calendar pane">
    Click the calendar button (**Import your calendar events**) in the cluster at the top-left corner of the grid.
  </Step>

  <Step title="Connect your calendar">
    Click **Sign in with Google** or **Sign in with Microsoft** and authorize access. The connection is personal to you, and Beebole only reads your events.
  </Step>

  <Step title="Assign events to a row">
    Your events for the current period appear in the pane. Click one or more events to select them, then click a timesheet row to assign them — or drag an event straight onto a row. Imported events show a **Tracked** badge.
  </Step>
</Steps>

***

## Submitting your timesheet

When your period is complete, click **Submit** at the top of the timesheet. The timesheet enters the [approval workflow](/help/documentation/approval) and is locked while it waits for review. If an approver rejects it, fix your entries and click **Resubmit**.

Your administrator can also configure automatic submission a set number of days after the period ends, and email reminders to submit — see [Timesheet and Planning Settings](/help/documentation/timesheetSettings).

***

## Reviewing your team

Managers and administrators see two extra buttons in the cluster at the top-left corner of the grid:

* The approval button (**Approval**) opens the **Pending** pane with timesheets waiting for review. A red badge shows how many are pending. From here you can open a person's timesheet, **Approve** or **Reject** submissions, and **Remind** people who haven't submitted.
* The team button (**Team**) opens the **Team** pane listing your team members with their reported time for the period.

For the full review workflow, see [Approvals](/help/documentation/approval).

### Timesheet score

In the team panes, a colored ring around each person's avatar shows their **Timesheet score** — a 0 to 100 measure of how reliably they submit on time. The ring is green from 80 up, amber from 50 to 79, and red below 50. Hover over it for the breakdown: **On time**, **Late submissions**, **Not submitted**, and **Rejections**.

***

## Related content

<CardGroup>
  <Card title="Timesheet and Planning Settings" icon="sliders" href="/help/documentation/timesheetSettings">
    Configure the timesheet period, entry unit, restrictions, categories, and reminders.
  </Card>

  <Card title="Approvals" icon="check" href="/help/documentation/approval">
    Submit timesheets and manage multi-stage approval workflows.
  </Card>

  <Card title="Time off" icon="umbrella-beach" href="/help/documentation/timeoff">
    Set up absence types and allowances, and record time off.
  </Card>

  <Card title="Mobile and tablet" icon="mobile" href="/help/documentation/mobile">
    Log time and submit timesheets from your phone or tablet.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How do I submit my timesheet in Beebole?">
    Click **Submit** at the top of the **Timesheet** page when your period is complete. The timesheet then enters Beebole's approval workflow and is locked while it waits for review. If it comes back rejected, correct your entries and click **Resubmit**.
  </Accordion>

  <Accordion title="How do I copy my timesheet from the previous period?">
    Open the period you want to copy, click the copy button at the top-left corner of the grid, navigate to the new period, and click **Paste period**. If the new period already has entries, Beebole asks whether to **Add** or **Replace**.
  </Accordion>

  <Accordion title="Why can't I add time to a certain day?">
    Your administrator may have added restrictions in Beebole's **Timesheet and Planning Settings** — for example blocking time entries on future dates, on non-working days, or beyond your scheduled hours. A submitted or approved period is also locked until it is rejected or reopened.
  </Accordion>

  <Accordion title="Can I track time on my phone?">
    Yes. Beebole's timesheet adapts to small screens with a mobile layout, and you can install Beebole as an app on your phone. See [Mobile and tablet](/help/documentation/mobile).
  </Accordion>

  <Accordion title="Who decides whether I enter time in hours or days?">
    Your administrator. The unit for time entry — hours, days, or a percentage of your schedule — is set in Beebole's **Timesheet and Planning Settings**, along with the duration format and the timesheet period. See [Timesheet and Planning Settings](/help/documentation/timesheetSettings).
  </Accordion>
</AccordionGroup>


# Troubleshooting: connection issues and diagnostics
Source: https://beebole.com/help/documentation/troubleshooting

Fix Beebole connection issues: what the compatibility-mode indicator means, how to run the built-in diagnostics page, and what to send to support.

Beebole runs on a secure real-time connection between your browser and its servers. When that connection is blocked or unstable — most often by a corporate firewall, VPN, or proxy — Beebole tells you what's happening and gives you the tools to pinpoint the cause. This page covers the two connection states you may see and the built-in diagnostics page that helps you (or your IT team) fix them.

<Info>
  First, rule out the basics: reload the page, and try a different network — for example your phone's mobile data. If Beebole works there, the issue is in the original network, not your account.
</Info>

***

## "Can't establish a secure connection"

If Beebole can't open its real-time connection at all, it stops with the message **Can't establish a secure connection**: Beebole needs a secure real-time (WebSocket) connection to load, and it couldn't be established. This is usually caused by a corporate firewall, VPN, or proxy blocking it.

* Try a different network — for example your phone's mobile data — to confirm the block.
* Ask your IT team to allow secure WebSocket connections (`wss`) to your Beebole site.
* Click **Try again** once the network is fixed.

***

## "Running in slower compatibility mode"

When the real-time connection is blocked but Beebole can still reach its servers another way, the app keeps working in a slower fallback mode and shows an indicator in the sidebar: **Running in slower compatibility mode**.

Everything still functions — changes just take longer to appear, and live updates from teammates arrive with a delay. Click the indicator for the explanation: your network is blocking the real-time (WebSocket) connection, and your IT team can restore full speed by allowing secure WebSocket (`wss`) connections to your Beebole server.

***

## Run the diagnostics page

For anything beyond the basics, Beebole ships a standalone **Connection Diagnostics** page. Open `/diagnostics` on your Beebole server address — for example `app.beebole.com/diagnostics`. It works even when the app itself won't load.

The page runs automatically and shows:

| Section                   | What it tells you                                                      |
| ------------------------- | ---------------------------------------------------------------------- |
| **Health checks**         | Whether each part of the connection to Beebole works from this browser |
| **Latency (ping)**        | How fast your network reaches the Beebole server                       |
| **Environment & storage** | Browser, network, and local storage details relevant to support        |

### Share the results with support

Click **Download snapshot (.json)** or **Copy snapshot** and send the result to [support@beebole.com](mailto:support@beebole.com) — it contains exactly the technical context needed to diagnose your case quickly.

### Reset the local app data

The **Actions** section offers two cleanup buttons:

* **Clear app cache** — wipes only the app's offline database. Beebole re-downloads your data on the next load; nothing on the server is touched.
* **Clear ALL site data** — also removes local and session storage, service workers, and readable cookies, then reloads.

<Warning>
  Use the cleanup buttons only when support suggests it. They can't lose your timesheets — all records live on Beebole's servers — but any unsynced local state is discarded and the app reloads from scratch.
</Warning>

***

## For IT teams

To give Beebole full speed on a managed network, allow outbound secure WebSocket (`wss`) connections to your Beebole server's domain. Beebole's fallback mode exists precisely for networks where that isn't possible — but native real-time is faster and lighter for your users.

***

## Related content

<CardGroup>
  <Card title="Key concepts" icon="lightbulb" href="/help/documentation/concepts">
    How Beebole's real-time sync and local caching work in normal operation.
  </Card>

  <Card title="Mobile app (PWA)" icon="mobile" href="/help/documentation/mobile">
    Install Beebole on your device — and what to check when the installed app misbehaves.
  </Card>

  <Card title="Notifications" icon="bell" href="/help/documentation/notifications">
    Web push and email notifications, and their delivery settings.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Why is Beebole slow on my office network but fine at home?">
    Your office firewall, VPN, or proxy is probably blocking Beebole's secure real-time (WebSocket) connection, so the app falls back to a slower compatibility mode — the sidebar shows **Running in slower compatibility mode** when this happens. Ask your IT team to allow secure WebSocket (wss) connections to your Beebole server.
  </Accordion>

  <Accordion title="How do I run a connection diagnostic for Beebole?">
    Open `/diagnostics` on your Beebole server address — for example `app.beebole.com/diagnostics`. The page checks the connection, measures latency, and lists environment details, and it loads even when the app itself won't. Use **Download snapshot (.json)** to save the results.
  </Accordion>

  <Accordion title="Will clearing the app cache delete my time entries?">
    No. All records live on Beebole's servers — **Clear app cache** only wipes the local offline copy, and Beebole re-downloads your data the next time it loads. Only unsynced local state is discarded, so use it when support suggests it.
  </Accordion>

  <Accordion title="What should I send to Beebole support about a connection problem?">
    A diagnostics snapshot. Open `/diagnostics` on your server address, let the checks finish, click **Copy snapshot** or **Download snapshot (.json)**, and include it in your email to [support@beebole.com](mailto:support@beebole.com) along with what you were doing when the problem appeared.
  </Accordion>
</AccordionGroup>


# Work schedules: define and assign work patterns
Source: https://beebole.com/help/documentation/work-schedule

Define work schedules in Beebole — weekly or longer cycles — and assign them at the organization, tag, or person level, each from its own start date.

Work schedules in Beebole define the hours each person is expected to work on every day of a repeating cycle. Beebole uses them to show scheduled hours on the timesheet, calculate overtime in reports, and measure capacity in the Gantt workload heatmap — so setting them up is one of the first steps when configuring your account.

<Info>
  If no work schedule is assigned anywhere, Beebole falls back to a virtual **24/7 work schedule** that treats every day as a full working day. Assign a default schedule to your organization so scheduled hours reflect reality.
</Info>

***

## How work schedules work

A work schedule is a repeating pattern. Each day of the cycle defines the expected **Hours**, optional **Intervals** with **Start** and **End** times, and whether it is a **Work From Home** day. The cycle is 7 days by default — a weekly pattern — but the **Length in days** can be any number, so rotating patterns are possible too.

Beebole supports multiple work schedules in one account. Create one schedule per work pattern — full-time, part-time, shift rotation — and assign each to the right people.

***

## Creating a work schedule

<Steps>
  <Step title="Open the Work Schedules settings">
    Click the button with your initials at the bottom of the sidebar, then go to **Settings** > **Work Schedules**.
  </Step>

  <Step title="Add the schedule">
    Click **Add Schedule**, type a name — for example "Full-time 40h" or "4-day week" — and click **Add Schedule** to confirm.
  </Step>

  <Step title="Define the daily pattern">
    In the **Details** panel, enter the **Hours** for each working day and leave non-working days empty. Use **Copy to next day** to repeat a day's setup and **Clear that day** to reset one. Every change is saved automatically.
  </Step>

  <Step title="Refine each day if needed">
    Add **Intervals** with **Start** and **End** times to spell out when work happens, and turn on **Work From Home** for the days it applies.
  </Step>
</Steps>

<Tip>
  Give each schedule a name your team recognizes at a glance — like "Full-time 40h" or "Night shift rotation" — so assignments stay easy to read.
</Tip>

***

## Cycles longer than a week

A work schedule doesn't have to repeat weekly. Increase the **Length in days** to build longer rotations — for example a 14-day cycle where the two weeks differ, or a 10-day shift rotation. Each day in the cycle gets its own hours, and Beebole repeats the full cycle indefinitely. Use **Start from** to anchor day 1 of the cycle to a calendar date, so Beebole knows where the rotation begins.

***

## Assigning a work schedule

You can assign work schedules at three levels. The most specific assignment wins: a person's own schedule overrides their tag's, and a tag's schedule overrides the organization default.

| Level        | Where to assign                                                                    | Use case                              |
| ------------ | ---------------------------------------------------------------------------------- | ------------------------------------- |
| Organization | **Settings** > **Account Settings**, in the **Work schedule** panel                | The default pattern for everyone      |
| Tag          | Click **Tags** in the sidebar, open the tag, then the **Work schedule** panel      | A team or department shares a pattern |
| Person       | Click **People** in the sidebar, open the person, then the **Work schedule** panel | An individual arrangement             |

In each **Work schedule** panel, use the **Select schedule** picker and type the name of a schedule to assign it. The assignment is saved automatically. On the schedule's own page in **Settings** > **Work Schedules**, the **Assigned to** panel shows where it is in use.

Which schedules an entity may *use* is managed separately from which schedule *applies*: the **Show all schedules** default (with per-entity **Show schedules** overrides) controls availability, while the dated assignment timeline records which schedule takes effect from when. That's what makes schedule changes over time possible without losing history — see the next section.

<Info>
  Configure exceptions only. Set the most common pattern on the organization, override it with tags for teams that differ, and override per person for individual cases.
</Info>

***

## Changing a schedule over time

Work patterns change — someone moves from full-time to part-time, or a team adopts a 4-day week. In Beebole, you don't end one assignment and start another: you simply assign the new schedule, and it takes over from its start date.

* While a single schedule is assigned, it applies without any date.
* When you assign a second schedule at the same level, each assignment shows a **Start date:** with a date picker so you can adjust when it begins.
* On any given day, the assignment with the most recent start date on or before that day applies. Days before the earliest dated assignment follow the first schedule in the list.

There is no end date to manage — a newer assignment supersedes the older one from its start date forward, and the history of past assignments is preserved.

***

## Archiving and deleting a work schedule

To retire a schedule you no longer assign, open it in **Settings** > **Work Schedules** and click the **⋯** action menu next to its name. The menu offers **Duplicate**, **Rename**, **Archive**, **Unarchive**, and **Delete**.

Archived schedules disappear from the list. Click **Show Archived** to display them, then use the **⋯** action menu and **Unarchive** to restore one.

<Warning>
  **Delete** removes the work schedule entirely. If you might need it again — or want to keep its history visible — choose **Archive** instead.
</Warning>

A schedule that is still assigned to people or tags can't be deleted — Beebole refuses the deletion until you reassign or remove those assignments, so nobody silently loses their working pattern.

***

## Where Beebole uses work schedules

* **Timesheets** — Each day's header on the timesheet shows time reported against scheduled hours, non-working days appear hatched, and the total row compares logged time with the scheduled total. See [Timesheets](/help/documentation/timesheets).
* **Reports** — Reports can compare worked hours against scheduled hours to surface overtime, and break down work-from-home time. See [Reports](/help/documentation/reports).
* **Time off** — When absences are tracked in days, a full day off converts to the hours defined in the person's schedule for that day. See [Time off](/help/documentation/timeoff).
* **Task planning** — The [Gantt chart](/help/documentation/gantt) workload heatmap measures planned effort against each person's capacity, which comes from their work schedule.

***

## Related content

<CardGroup>
  <Card title="People" icon="users" href="/help/documentation/people">
    Open a person's profile to assign their individual work schedule.
  </Card>

  <Card title="Tags" icon="tags" href="/help/documentation/tags">
    Cascade a shared schedule to a whole team or department through tags.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    See how scheduled hours appear next to reported time on the timesheet.
  </Card>

  <Card title="Time Off" icon="calendar" href="/help/documentation/timeoff">
    Absences tracked in days convert to hours using the work schedule.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I have different work schedules for different teams?">
    Yes. Beebole supports multiple work schedules in one account. Create one schedule per pattern and assign each to the right tag or person — the most specific assignment overrides the organization default.
  </Accordion>

  <Accordion title="What happens if a person has no work schedule assigned?">
    Beebole falls back to a virtual **24/7 work schedule** that counts every day as a full working day. The fallback appears grayed out in the **Work schedule** panel. Assign a default schedule to your organization so scheduled hours match your real working pattern.
  </Accordion>

  <Accordion title="Can I create a schedule that rotates every two weeks?">
    Yes. Set the schedule's **Length in days** to 14 and define each of the 14 days separately. Beebole repeats the full cycle indefinitely, and **Start from** anchors where the rotation begins.
  </Accordion>

  <Accordion title="How do I change someone's schedule from a specific date?">
    Assign the new schedule in the person's **Work schedule** panel and set its **Start date:**. Beebole applies the old schedule before that date and the new one from that date forward — there is no end date to configure.
  </Accordion>

  <Accordion title="How do I set up a part-time schedule in Beebole?">
    Create a new work schedule and enter **Hours** only on the days the person works — for example 4 hours from Monday to Friday, or full days from Monday to Wednesday. Then assign it to the person.
  </Accordion>
</AccordionGroup>


# Employee Guide: track and submit your time
Source: https://beebole.com/help/guides/employee

A Beebole guide for employees: log your hours on the timesheet, record time off, submit your week for approval, and track time from the mobile app.

Beebole is where you log the hours you work and the time you take off. As an employee, your day-to-day work happens on the **Timesheet** — you record what you worked on, submit your week, and request leave. This guide walks through those tasks in the order you meet them.

<Info>
  Your administrator sets up Beebole — projects, time-off types, and approval rules are already in place. You sign in with a one-time 6-digit code emailed to you, a passkey, your Google or Microsoft account, or your company's single sign-on. There are no passwords to remember.
</Info>

## Log your time

Open **Timesheet** in the sidebar to record your hours. The timesheet is a grid: each row is a project (and optionally a task), and each column is a day in the period.

1. Add a row for what you worked on, then pick the project or task.
2. Enter your hours in the **Time spent** field for the right day.
3. Repeat for each piece of work — Beebole saves entries as you go.

If your administrator turned on the timer, you can click **Start timer** on a row to time your work live instead of typing hours, then **Pause timer** to save the elapsed time. You can also copy a previous period to reuse the same rows.

See [Timesheets](/help/documentation/timesheets) for the full grid, timer, and copy-period details.

## Record time off

To log vacation, sick leave, or any other absence, add a **Time off** row on your timesheet and enter the time against the right time-off type. Depending on how your administrator configured that type, your request may need approval before it counts.

Your available balance for each type — what you have **Taken**, **Accrued**, and **Available** — is tracked for you. Learn more in [Time off](/help/documentation/timeoff).

## Submit your timesheet

When your period is complete, click **Submit** at the top of the timesheet. This locks the period and sends it into your organization's approval workflow.

An approver then reviews it and either approves it or rejects it. If it is **Rejected**, a comment tells you why — fix the entries and click **Resubmit**. Once every stage approves, the timesheet is **Approved** and stays locked.

See [Approval](/help/documentation/approval) for how the review process works stage by stage.

## Track time on mobile

The Beebole mobile app lets you log time, run the timer, and request time off from your phone — useful when you work away from your desk. Your entries sync with the web app automatically.

See [Mobile](/help/documentation/mobile) to install the app and get started.

## Related content

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Add rows, enter hours, run the timer, and submit your period.
  </Card>

  <Card title="Time off" icon="calendar" href="/help/documentation/timeoff">
    Request leave and check your available balance by type.
  </Card>

  <Card title="Approval" icon="circle-check" href="/help/documentation/approval">
    See how submitted timesheets are reviewed, approved, or rejected.
  </Card>

  <Card title="Mobile" icon="mobile" href="/help/documentation/mobile">
    Log time and request time off from the Beebole mobile app.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How do I log my hours in Beebole?">
    Open **Timesheet** in the sidebar, add a row for the project or task you worked on, and enter your hours in the **Time spent** field for the right day. Beebole saves each entry as you make it.
  </Accordion>

  <Accordion title="How do I submit my timesheet for approval?">
    When your period is complete, click **Submit** at the top of the timesheet in Beebole. The period locks and enters your organization's approval workflow, where an approver reviews it.
  </Accordion>

  <Accordion title="What happens if my timesheet is rejected?">
    A rejected Beebole timesheet returns to you with a required comment explaining why. Correct the entries and click **Resubmit** to send it back into the approval workflow.
  </Accordion>

  <Accordion title="Can I track time from my phone?">
    Yes. The Beebole mobile app lets you log time, run the timer, and request time off on the go, and your entries sync automatically with the web app.
  </Accordion>

  <Accordion title="Do I need a password to sign in to Beebole?">
    No. Beebole has no passwords — you sign in with a one-time 6-digit code emailed to you, a passkey, your Google or Microsoft account, or your company's single sign-on.
  </Accordion>
</AccordionGroup>


# Frequently Asked Questions and Support
Source: https://beebole.com/help/guides/faq

Answers to common Beebole questions about timesheets, projects, time off, reports, billing, integrations, mobile access, and account administration.

Beebole is a project time-tracking app that teams use to log hours, manage time off, plan tasks, and report on billing and cost. This page collects the questions customers ask most often, grouped by area. For step-by-step setup, start with the [Quickstart](/help/documentation/quickstart); for a specific feature, follow the links in each answer.

## Getting started

<AccordionGroup>
  <Accordion title="Is there a limit to how many projects or team members I can add during the trial?">
    Your trial gives you full access to Beebole with no feature restrictions. You can add as many projects and people as you need to evaluate the tool. Contact [support@beebole.com](mailto:support@beebole.com) with any questions about your trial.
  </Accordion>

  <Accordion title="Do I need to set up everything before my team can start tracking time?">
    No. You need at least one project and one person. Tags are optional but recommended, since they unlock powerful reporting and configuration. See the [Quickstart](/help/documentation/quickstart) for the minimum setup.
  </Accordion>

  <Accordion title="Can I add several people at once instead of one by one?">
    Yes. Click **People** in the sidebar, choose to add people, then copy rows from a spreadsheet (one person per line, name then a tab then email) and click **Paste**. Beebole imports the whole list at once. Projects and tags support the same paste flow.
  </Accordion>

  <Accordion title="What's the difference between a project and a category?">
    A project category is a top-level grouping, such as a client name or a department. Projects sit inside categories and represent the work being tracked, and a project can hold subprojects for finer detail. Only the project level is required; use whatever depth makes sense for your team. See [Projects](/help/documentation/projects).
  </Accordion>

  <Accordion title="Will my team members see each other's time entries?">
    By default, people see only their own timesheet. Managers see the timesheets of people assigned to them, and admins see the whole account. You tune this with roles, configured under **Settings** > **Person Roles**. See [Roles and permissions](/help/documentation/roles-authorisations).
  </Accordion>
</AccordionGroup>

## Subscription and pricing

<AccordionGroup>
  <Accordion title="What is a seat?">
    A seat represents one active person in your Beebole account, and your subscription is billed per active person. Adding a person bills another seat; archiving a person releases the seat at the next billing cycle. See [Subscription and billing](/help/documentation/subscription).
  </Accordion>

  <Accordion title="Can I switch between monthly and annual billing?">
    Yes. Go to **Settings** > **Subscription** and open the billing portal to change your billing interval. See [Subscription and billing](/help/documentation/subscription).
  </Accordion>

  <Accordion title="What happens if my payment fails?">
    Beebole retries failed payments automatically. If the issue persists, you receive an email asking you to update your payment method, and your account stays accessible during the grace period.
  </Accordion>

  <Accordion title="Can I cancel my subscription at any time?">
    Yes. Cancel from the billing portal under **Settings** > **Subscription**. Your account stays active until the end of the current billing period, then converts to the free plan. See [Subscription and billing](/help/documentation/subscription).
  </Accordion>
</AccordionGroup>

## Timesheets and time entry

<AccordionGroup>
  <Accordion title="Can I track time on my phone?">
    Yes. Beebole is an installable web app (PWA) you add from your browser, with no app store download. You can enter time, run timers, and submit timesheets from your phone. See [Mobile](/help/documentation/mobile).
  </Accordion>

  <Accordion title="What happens if I forget to fill in my timesheet?">
    If reminders are enabled, Beebole emails you. If auto-submit is configured, your timesheet submits automatically after the deadline, even if incomplete. See [Notifications](/help/documentation/notifications).
  </Accordion>

  <Accordion title="Can I enter time for a past week?">
    Yes. Navigate to a previous week and enter or edit your time. If that week's timesheet has already been approved, your approver needs to reject it first so you can change it.
  </Accordion>

  <Accordion title="Where is the timesheet period configured?">
    Your administrator sets the timesheet period and entry rules in **Timesheet settings**. The new platform uses a single configurable period (weekly, bi-weekly, 1st–15th, and so on) rather than separate daily and weekly views. See [Timesheet and Planning Settings](/help/documentation/timesheetSettings).
  </Accordion>

  <Accordion title="Can I change the duration format after my team has started tracking time?">
    Yes. Changing the format updates how values display going forward; existing time data is preserved and shown in the new format. The duration format is an account-wide setting, so it applies to everyone for consistency across reports and approvals.
  </Accordion>
</AccordionGroup>

## Projects and organization

<AccordionGroup>
  <Accordion title="Is there a limit to how many levels I can nest?">
    No. Beebole supports unlimited project nesting depth, though for the best experience we recommend keeping it under four levels. See [Projects](/help/documentation/projects).
  </Accordion>

  <Accordion title="What's the difference between a subproject and a task?">
    A subproject is part of the project hierarchy — a subdivision of a larger project that you track time against. A task is an independent planning item with its own status, owner, dependencies, and effort. Tasks can be linked to projects but exist separately, and are managed on the [Gantt chart](/help/documentation/gantt) and [Kanban board](/help/documentation/kanban).
  </Accordion>

  <Accordion title="What's the difference between tags and project categories?">
    Project categories are part of the project hierarchy and group projects structurally. Tags are a separate, cross-cutting dimension you apply to people, projects, and tasks. Use categories for your project structure and tags for organizational dimensions like departments or locations. See [Tags](/help/documentation/tags).
  </Accordion>

  <Accordion title="Can a person or project have multiple tags?">
    Yes. A person can belong to several tag trees at once (for example tagged as both "Engineering" and "London Office"), and a project can be tagged the same way. Configuration from all of a tag's trees combines.
  </Accordion>

  <Accordion title="Can I restrict which people see certain projects?">
    Yes. Control project visibility through [assignments](/help/documentation/assignments) and [roles and permissions](/help/documentation/roles-authorisations).
  </Accordion>

  <Accordion title="Can I change my structure after my team has started tracking time?">
    Yes. Reorganize projects, update tags, and change rates at any time — historical time entries are preserved. Structural changes can affect how existing data appears in filtered reports.
  </Accordion>
</AccordionGroup>

## People and permissions

<AccordionGroup>
  <Accordion title="What happens when someone leaves the company?">
    Archive their profile instead of deleting it. Archiving preserves their historical time data for reports while releasing their seat on your subscription. See [People](/help/documentation/people).
  </Accordion>

  <Accordion title="Can one person have multiple roles?">
    No. Each person has exactly one role. If someone needs a mix of permissions, create a custom role that includes everything they need. See [Roles and permissions](/help/documentation/roles-authorisations).
  </Accordion>

  <Accordion title="What is the difference between assignments and role permissions?">
    Roles control what a person can do — view data, edit timesheets, approve. Assignments control what is visible — which projects, tasks, absence types, and expense types appear on a person's timesheet. The two work together. See [Assignments](/help/documentation/assignments).
  </Accordion>

  <Accordion title="Can I sign in as another person for troubleshooting?">
    Yes. Administrators can use the **Sign in as…** action to view Beebole exactly as another person sees it, which helps diagnose issues. See [People](/help/documentation/people).
  </Accordion>
</AccordionGroup>

## Time off, holidays, and schedules

<AccordionGroup>
  <Accordion title="Can I set different time-off allowances for different people?">
    Yes. Override the default allowance for any person from their profile under **People**. The per-person allowance takes priority over the default set on the absence type. See [Time off](/help/documentation/timeoff).
  </Accordion>

  <Accordion title="What happens when someone exceeds their time-off balance?">
    It depends on your configuration. If negative balances are allowed, the person keeps booking and the balance goes negative; if restricted, Beebole blocks the entry. See [Time off](/help/documentation/timeoff).
  </Accordion>

  <Accordion title="Do public holidays count against a person's time-off balance?">
    No. Public holidays are separate from absence types like vacation or sick leave. They reduce expected working hours for a period but do not consume any allowance. See [Public holidays](/help/documentation/public-holidays).
  </Accordion>

  <Accordion title="Can I have different holiday calendars for different offices?">
    Yes. Use tags to assign country-specific holiday calendars to groups of people — for example a US calendar for everyone tagged "US Office" and a UK calendar for "UK Office". See [Public holidays](/help/documentation/public-holidays).
  </Accordion>

  <Accordion title="Can I have different schedules for different teams?">
    Yes. Beebole supports multiple [work schedules](/help/documentation/work-schedule). Create one per team or work pattern and assign it via tags or individual profiles.
  </Accordion>

  <Accordion title="Do schedules affect time-off calculations?">
    Yes. When a person takes a day off, Beebole deducts the hours their schedule defines for that day. A person scheduled for 6 hours on Fridays uses 6 hours of leave for a Friday off. See [Work schedules](/help/documentation/work-schedule).
  </Accordion>
</AccordionGroup>

## Approvals and notifications

<AccordionGroup>
  <Accordion title="Can I approve timesheets on my phone?">
    Yes. The approval flow works on mobile, and you can also approve or reject directly from email notifications. See [Approvals](/help/documentation/approval).
  </Accordion>

  <Accordion title="Is there a record of approval actions?">
    Yes. Beebole logs every approval action — who approved or rejected, when, and with what comment. You see this history on the timesheet itself and in the account-wide [audit trail](/help/documentation/audit-trail).
  </Accordion>

  <Accordion title="Can I turn off all email notifications?">
    Yes. In your notification preferences, disable email per event type. You still see updates in the in-app [Journal](/help/documentation/journal). See [Notifications](/help/documentation/notifications).
  </Accordion>

  <Accordion title="Can I respond to approval notifications by email?">
    Yes. Approval emails include buttons to approve or reject the timesheet directly. You can also reply to Journal notification emails to post a comment. See [Approvals](/help/documentation/approval).
  </Accordion>
</AccordionGroup>

## Tasks

<AccordionGroup>
  <Accordion title="How does the Gantt chart relate to the Kanban board?">
    Both views show the same tasks. The [Kanban board](/help/documentation/kanban) organizes tasks by status, while the [Gantt chart](/help/documentation/gantt) organizes them on a timeline. A change in one view appears immediately in the other.
  </Accordion>

  <Accordion title="Can I track time on a task?">
    Yes. Tasks are independent planning items, and people can log time directly against the tasks assigned to them. Linking a task to a project lets it inherit project attributes such as billing rates. See [Task planning](/help/documentation/planning).
  </Accordion>

  <Accordion title="Can I limit who can move tasks on the Kanban board?">
    Yes. Use [roles and permissions](/help/documentation/roles-authorisations) to control who can edit tasks. People with read-only access can view the board but cannot move cards.
  </Accordion>
</AccordionGroup>

## Reports and data exports

<AccordionGroup>
  <Accordion title="Why do I see different data than my colleague in the same report?">
    Reports respect each person's permissions. You only see data for the projects and people you are authorized to access, so an admin sees everything while a team leader sees only their team. See [Reports](/help/documentation/reports).
  </Accordion>

  <Accordion title="Can I include custom fields in my reports?">
    Yes. Any [custom field](/help/documentation/custom-fields) you create is available as both a column and a filter in reports, so you can slice data by region, priority, or any custom attribute.
  </Accordion>

  <Accordion title="Can I save and reuse report configurations?">
    Yes. Save a report configuration and organize saved reports into folders. Each report can display as a table, a chart, or both. See [Custom reports](/help/documentation/custom-reports).
  </Accordion>

  <Accordion title="Do archived projects appear in reports?">
    Yes. Archived projects and their time entries stay fully available in reports. Archiving only removes a project from active timesheets, not from historical data.
  </Accordion>

  <Accordion title="How is the spreadsheet add-in different from a CSV export?">
    The add-in keeps a live link to a saved Beebole report: you configure it once and refresh the data on demand. A [CSV export](/help/documentation/data-exports) gives you a static file each time. See the [Google Sheets add-in](/help/documentation/gsheets-addon) and [Excel add-in](/help/documentation/excel-addin).
  </Accordion>
</AccordionGroup>

## Billing rates, costs, and budgets

<AccordionGroup>
  <Accordion title="What's the difference between billing rates and cost rates?">
    In Beebole, billing rates are what you charge (revenue) and cost rates are what the work costs you (expense). The difference is your margin. See [Billing rates](/help/documentation/billing) and [Cost rates](/help/documentation/costs).
  </Accordion>

  <Accordion title="Can I bill the same person at different rates on different projects?">
    Yes. Set a billing rate on each project, and use **Split by persons** on a project to give each team member their own amount. Project rates take priority over the person's own rate. See [Billing rates](/help/documentation/billing).
  </Accordion>

  <Accordion title="If a rate is set on a tag and a different rate on a project, which one applies?">
    The most specific rate wins. For each time entry, Beebole looks at the project it was logged against — starting at the deepest subproject and walking up the project hierarchy — and only falls back to the person's rate if no project in the chain has one. Rates inherited from a tag or the organization count as the rate of the project or person they cascade to. See [Billing rates](/help/documentation/billing).
  </Accordion>

  <Accordion title="Do expenses count toward project budgets?">
    Yes. When a cost budget is configured on a project, expense amounts contribute to budget consumption alongside labor costs. See [Budgets](/help/documentation/budgets) and [Expenses](/help/documentation/expenses).
  </Accordion>
</AccordionGroup>

## Integrations

<AccordionGroup>
  <Accordion title="Where do I find integrations in Beebole?">
    All integrations are managed under **Settings** > **Integrations**. You need administrative access to reach this page. See [Integrations](/help/integrations/introduction).
  </Accordion>

  <Accordion title="Can I use multiple integrations at the same time?">
    Yes. You can enable several integrations at once — for example import projects from Asana and export time records to QuickBooks. See [Integrations](/help/integrations/introduction).
  </Accordion>

  <Accordion title="What happens to my data if I disable an integration?">
    Disabling an integration stops future syncing, but the data already imported (projects, tasks, people) stays in Beebole as local records. Re-enable it any time to resume syncing.
  </Accordion>

  <Accordion title="Does Beebole change my calendar when I connect it?">
    No. The calendar connection in the timesheet is per-user and read-only — Beebole reads your events so you can drag them onto timesheet rows, but it never creates, edits, or deletes calendar events. See [Google Calendar](/help/integrations/google-calendar) and [Microsoft Calendar](/help/integrations/microsoft-calendar).
  </Accordion>

  <Accordion title="Can I build my own integration with Beebole?">
    Yes. Beebole provides a [GraphQL API](/help/api/introduction) you can use to build custom integrations with any tool or internal system. See [Custom integrations](/help/integrations/custom-integrations).
  </Accordion>
</AccordionGroup>

## Account and security

<AccordionGroup>
  <Accordion title="How do I sign in to Beebole?">
    Beebole has no passwords. You sign in with a one-time 6-digit code emailed to you, a passkey, your Google or Microsoft account, or your organization's SSO provider — whichever is most convenient. See [Authentication](/help/documentation/authentication).
  </Accordion>

  <Accordion title="Does Beebole store my Google or Microsoft password?">
    No. Beebole never sees or stores your password. Sign-in runs through the provider's secure flow, and Beebole only receives confirmation that you authenticated. See [Authentication](/help/documentation/authentication).
  </Accordion>

  <Accordion title="Does turning off a feature delete its data?">
    No. Disabling a feature in Beebole hides it from the interface but keeps your existing data. Re-enable it later and the data is still there. See [Account settings](/help/documentation/account-settings).
  </Accordion>

  <Accordion title="Where can I see who changed what in my account?">
    The Beebole [audit trail](/help/documentation/audit-trail) records every create, update, and delete, with who made the change and when. The Journal feed shows these messages across the account, and each record's **Logs** view shows its own change history.
  </Accordion>
</AccordionGroup>

## Related content

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/help/documentation/quickstart">
    Set up your Beebole account in a few steps.
  </Card>

  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Log and submit time entries for your projects.
  </Card>

  <Card title="Subscription and billing" icon="credit-card" href="/help/documentation/subscription">
    Manage your plan, payment method, and invoices.
  </Card>

  <Card title="Authentication" icon="lock" href="/help/documentation/authentication">
    Sign-in methods, passkeys, SSO, and API keys.
  </Card>
</CardGroup>


# Moving to the New Beebole Platform
Source: https://beebole.com/help/guides/migration

A guide for existing Beebole customers moving to the new platform: how the two systems coexist, how to test the new app, and what has changed.

This migration guide covers everything you need to know to move your account to the new Beebole platform, available at [app.beebole.com](https://app.beebole.com). You'll learn how the new and Legacy systems coexist during the transition, what's new and different, and how the updated API and architecture might affect your planning.

Note that this guide is for existing customers. If you are starting fresh with no prior Beebole account, the [Quickstart](/help/documentation/quickstart) is a better place to start.

The new Beebole is significantly different from Legacy, so the [Quickstart](/help/documentation/quickstart) is worth a read even if you've been using Beebole for years. It covers how the new system is structured and will help you get oriented before diving in.

<Warning>
  The new Beebole is currently in **beta**. You may encounter occasional bugs or rough edges as we continue to improve the platform. We're committed to fixing issues quickly and releasing improvements regularly — and your feedback is a meaningful part of that process. If you notice anything, reach out via the in-app chat or email us at [support@beebole.com](mailto:support@beebole.com).
</Warning>

<Info>
  Your Beebole Legacy account stays active throughout this process. There is no disruption to your current usage or data, and there is no deadline to switch yet.
</Info>

## Where things stand

**What you can do right now, during the beta:**

* Test the new platform with a free trial account. We can extend your trial as needed.
* Request a copy of your Legacy data in your trial account, to see how the new Beebole feels with your own data in it.
* Review your current structure and think about how the new features could improve it.
* Talk to us about the best setup for your team. Reach out via the in-app chat or at [support@beebole.com](mailto:support@beebole.com).
* Ask us to migrate your Legacy account when you are ready to switch. Migrations are run by Beebole's support team, and you choose which data comes over — see [Legacy migration](/help/documentation/legacy-migration).

## How the transition works

There's no deadline to switch yet, and we'll give you plenty of notice before anything changes. In the meantime, starting to explore the new platform now means an easier switch later.

* Your Legacy data stays safe and untouched. You can keep using your Legacy account while you test the new platform and plan your transition.
* Migrations are performed by Beebole's support team on request, not by a tool in the app. Email [support@beebole.com](mailto:support@beebole.com) when you want one, and tell us which data to bring over — for example your people and projects but no time records, or history only from a given date. See [Legacy migration](/help/documentation/legacy-migration) for what is imported and how the imported history behaves.
* Before committing, we can add a copy of your Legacy data to your free trial account, so you can see how the new Beebole feels with your own data in it. There is no commitment to keep that setup. Contact us at [support@beebole.com](mailto:support@beebole.com) to request a copy.
* You can have open accounts in both systems simultaneously, at no extra cost. When you're ready to switch officially, you can start fresh with a clean account, so nothing you try now locks you in.
* You can still sign in to the Legacy system from the login button at [beebole.com](http://beebole.com), or at [beebole-apps.com/signin](http://beebole-apps.com/signin/). You sign in to the new system at [app.beebole.com](https://app.beebole.com/signin).
* If you use Beebole's API, your integrations need to be updated for the new [GraphQL API](/help/api/introduction). We're here to help. Your Legacy integrations will continue working in your Legacy account in the meantime.

<Warning>
  Data from the Legacy system can only be migrated into the new Beebole **as is**. You choose *which* data to migrate, but not to change its configuration on the way in. For example, migrated projects keep the same *client > project > subproject* hierarchy they had in the Legacy system. If you want a different structure in the new platform, we recommend exporting and saving your historical data and starting fresh. See [Review your structure before you switch](#review-your-structure-before-you-switch).
</Warning>

## Try out the new platform first

You can create a free account on the new platform without affecting your Legacy account. Treat this stage as a sandbox — nothing you try now locks you in.

<Steps>
  <Step title="Sign up in the new system">
    Create a free trial account at [app.beebole.com/signup](https://app.beebole.com/signup). You can use the same email address as your Legacy account, and we can extend your trial as needed.
  </Step>

  <Step title="Explore the new features">
    Use the trial account to explore new features, create time entries, discover resource planning, and play around with reports. Bear in mind that, when you're ready to switch permanently, you can start fresh with a clean account.
  </Step>

  <Step title="See it with your own data">
    If you'd like to see how the new Beebole feels with your existing data in it, contact us at [support@beebole.com](mailto:support@beebole.com), and we'll add a copy of your Legacy data to your trial account. This is for testing only — it doesn't commit you to keeping that account or setup.
  </Step>

  <Step title="Share your feedback">
    The new Beebole is still in beta and, as with any new system, we anticipate some initial kinks. Please share them with us. You can reach out via the in-app chat or email [support@beebole.com](mailto:support@beebole.com) with questions or feedback.
  </Step>
</Steps>

## Signing in on both systems

The new and Legacy systems have separate sign-in pages.

* You still sign in to Legacy at [beebole-apps.com/signin](http://beebole-apps.com/signin/), or from the login button at [beebole.com](http://beebole.com). Nothing changes for your employees still using Legacy.
* You sign in to the new system at [app.beebole.com](https://app.beebole.com/signin).
* Signing in to the new system is passwordless: you confirm your identity with a one-time 6-digit code emailed to you, a passkey, your Google or Microsoft account, or your organization's SSO provider. See [Authentication](/help/documentation/authentication) for details.

## Review your structure before you switch

In most cases, **we recommend starting fresh in the new platform** rather than migrating. The project structure can be significantly improved in the new system — unlimited project levels, tags that carry configuration, custom roles — and migrating your Legacy hierarchy as is means carrying its limitations with you. Your historical data stays safe in your Legacy account either way, and you can export and save it at any time.

**Before you settle on a setup, it is worth asking:**

* Does your current project hierarchy still reflect how work is delivered?
* Are people grouped efficiently for reporting and approvals?
* Have timesheet settings, localization, costs, and billing rates drifted into something hard to follow?
* Which [custom fields](/help/documentation/custom-fields) would improve your data and invoicing on projects, people, tasks, or time records?

The [Key concepts](/help/documentation/concepts) page explains Beebole's new core entities (projects, people, tasks, and tags) and how they relate to each other. Try mapping out your structures and settings ahead of time and, when in doubt, reach out to us.

## New API and developer readiness

The new platform includes a [GraphQL API](/help/api/introduction) for querying and mutating Beebole data. This is the primary developer-facing change for customers with integrations or automation.

Review the [GraphQL API](/help/api/introduction) for the API basics and authentication model. Then, start planning the migration of any Legacy integrations as part of the manual account migration.

<Info>
  The API is a major reason to evaluate the new platform early. It is also the right time to document your current integration points and look for improvements and optimizations.
</Info>

## What has changed

The tables below summarize the main changes from the Legacy system. Most will feel familiar.

### Time tracking

| Topic                             | What's new                                                                                                                                                                                              |
| :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Timesheet submission**          | You submit a full timesheet period (such as a whole week), not individual entries. Submitting locks that period.                                                                                        |
| **Timesheet periods**             | Fixed daily, weekly, or monthly views are replaced by a configurable period — weekly, bi-weekly, 1st–15th, and so on — set in [Timesheet and Planning Settings](/help/documentation/timesheetSettings). |
| **Entry formats**                 | Log time in hours (hh:mm), decimal hours, days, or a percentage of a workday.                                                                                                                           |
| **Work from home flag**           | Mark an individual entry as remote work directly on the entry.                                                                                                                                          |
| **Non-billable flag**             | Mark individual entries as non-billable.                                                                                                                                                                |
| **Auto-submit**                   | Configure a timesheet to submit automatically after a set number of days, so forgotten periods still lock.                                                                                              |
| **Direct edits**                  | Admins and managers can edit submitted or approved entries directly, without rejecting first. Every change is logged.                                                                                   |
| **Custom fields on time entries** | Capture extra structured data per entry for reporting.                                                                                                                                                  |
| **Calendar in the timesheet**     | Connect your Google or Microsoft Outlook calendar and drag events onto timesheet rows. The connection is per-user and one way (Calendar to Beebole) only.                                               |
| **Timesheet score**               | A per-person compliance score (0–100) based on on-time submissions, late submissions, missed timesheets, and rejections. It appears on team members in the team and approval views.                     |

### Time off

| Topic                      | What's new                                                                                                                                                                  |
| :------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Carry-forward rules**    | Set a maximum balance that rolls over when a [time-off](/help/documentation/timeoff) allowance period ends; any excess expires.                                             |
| **Absence unit**           | Configure each absence type to be requested in days or hours, independently per type.                                                                                       |
| **Public holidays**        | [Public holiday calendars](/help/documentation/public-holidays) populate automatically by country and region, with custom holidays on top — no more manual entry each year. |
| **Accruals (coming soon)** | Configure accrual frequency and quantity per absence, with accrued balances adjusted on the allowance's **Accrued** field. See [Accruals](/help/documentation/accruals).    |

### Approvals

| Topic                    | What's new                                                                                                                       |
| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
| **Multi-stage workflow** | Define as many [approval](/help/documentation/approval) stages as you need (for example, project manager → team leader → admin). |
| **Quorum rules**         | Per stage, require all approvers or any single approver before advancing.                                                        |
| **Approval history**     | Each timesheet keeps a full log of approvals, rejections, and comments, so you always see where it stands.                       |
| **Email actions**        | Approve or reject straight from the notification email.                                                                          |
| **Approval reminders**   | Approvers receive automatic reminders for pending timesheets.                                                                    |
| **Mobile approval**      | Review and act on pending timesheets from a phone.                                                                               |

### Tasks

| Topic                      | What's new                                                                                                         |
| :------------------------- | :----------------------------------------------------------------------------------------------------------------- |
| **Kanban board**           | Manage tasks as cards across configurable status columns on the [Kanban board](/help/documentation/kanban).        |
| **Gantt chart**            | See tasks on a timeline with dependencies and per-person workload on the [Gantt chart](/help/documentation/gantt). |
| **Task dependencies**      | Link tasks so one cannot start before another finishes.                                                            |
| **Effort allocation**      | Assign a percentage of a person's time to a task and spot over- or under-allocation.                               |
| **Timesheet integration**  | Tasks assigned to you can appear in your timesheet, ready to confirm.                                              |
| **Custom fields on tasks** | Add structured information to tasks beyond the description.                                                        |
| **Recurring tasks**        | Set up tasks that repeat on a schedule (e.g., every Friday).                                                       |

<Info>
  Tasks are independent planning items in the new platform — they live on their own **Planning** page and are not sub-elements of projects, although they can be linked to existing projects. See [Task planning](/help/documentation/planning).
</Info>

### Expenses

| Topic                           | What's new                                                                                |
| :------------------------------ | :---------------------------------------------------------------------------------------- |
| **Project expenses**            | Track [expenses](/help/documentation/expenses) on a project and factor them into budgets. |
| **Expense types**               | Define types with currency or quantity units (for example, miles for travel).             |
| **Markup**                      | Set a billing markup on an expense type.                                                  |
| **Budget impact (coming soon)** | Choose whether an expense type counts toward the project budget.                          |

### People and roles

| Topic               | What's new                                                                                                                                    |
| :------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------- |
| **Custom roles**    | The fixed Legacy roles are gone. Use the default [roles](/help/documentation/roles-authorisations) or create as many custom ones as you need. |
| **Bulk operations** | Bulk-archive, bulk-unarchive, and bulk-invite people.                                                                                         |
| **Sign in as**      | Admins can use **Sign in as…** to see exactly what a team member sees, for troubleshooting.                                                   |

### Projects and tags

| Topic                          | What's new                                                                                                                                                                      |
| :----------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Unlimited project levels**   | The fixed three-level structure is gone — nest [projects](/help/documentation/projects) as deep as you need.                                                                    |
| **Multiple timesheet columns** | Add independent project columns to the timesheet.                                                                                                                               |
| **Project availability**       | Make projects visible to everyone by default, or hidden until explicitly assigned.                                                                                              |
| **Tags as configuration**      | [Tags](/help/documentation/tags) carry configuration (rates, schedules, holidays, allowances), and a person or project in several tags receives the combination of all of them. |
| **Multiple tag trees**         | A person can belong to several independent tag trees at once. Tag trees are unlimited in depth and number.                                                                      |

### Billing, costs, and reporting

| Topic                     | What's new                                                                                                                                            |
| :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Daily rates**           | Define [billing](/help/documentation/billing) and [cost](/help/documentation/costs) rates per day, not only per hour.                                 |
| **Fixed recurring fees**  | Apply a fixed rate (such as a salary) for a period, regardless of hours worked.                                                                       |
| **Budgets**               | Set [budgets](/help/documentation/budgets) for billing, cost, and hours, and split them by person or project.                                         |
| **Budget status reports** | Easily check the budget status and planned budget on any project for costs, billing, and time in reports.                                             |
| **Saved reports**         | Create, save, and organize [reports](/help/documentation/reports) into folders, and toggle between table, chart, and matrix views.                    |
| **Spreadsheet add-ins**   | Link a saved report to [Excel](/help/documentation/excel-addin) or [Google Sheets](/help/documentation/gsheets-addon) and refresh the data on demand. |

### Communication and platform

| Topic                      | What's new                                                                                                                                         |
| :------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Journal**                | Every record has a [Journal](/help/documentation/journal) — a threaded feed where you comment, attach files, mention people, and track changes.    |
| **Email reply-to-comment** | Reply to a Journal notification email to post a comment.                                                                                           |
| **Email templates**        | Customize the content of system emails, with dynamic placeholders.                                                                                 |
| **Notifications**          | Choose emails to be sent in a daily or weekly digest.                                                                                              |
| **Passwordless sign-in**   | Sign in with a one-time email code, a passkey, Google, Microsoft, or SSO — no passwords. See [Authentication](/help/documentation/authentication). |
| **Organization branding**  | Upload your organization's logo (it appears in the sidebar and on outgoing emails) and set an accent color for the interface.                      |
| **Undo/redo**              | A global undo/redo across the app.                                                                                                                 |
| **Copy/paste setup**       | Duplicate a project's configuration to reuse as a template, and add people, projects, or tags in bulk by pasting spreadsheet rows.                 |
| **Integrations**           | Native [integrations](/help/integrations/introduction) include Asana, Jira, monday.com, Linear, QuickBooks, Xero, and BambooHR, plus webhooks.     |

## Related content

<CardGroup>
  <Card title="Getting Started" icon="arrow-right" href="/help/documentation/quickstart">
    Take a look at the quickstart guide to set up Beebole in a few steps.
  </Card>

  <Card title="Custom fields" icon="tag" href="/help/documentation/custom-fields">
    See how to set up custom fields on projects, people, tasks, and time records.
  </Card>

  <Card title="Tags" icon="tags" href="/help/documentation/tags">
    Organize people and projects with tags for reporting and availability.
  </Card>

  <Card title="API introduction" icon="code" href="/help/api/introduction">
    Get started with Beebole's GraphQL API for custom integrations.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I have to migrate to the new Beebole platform right away?">
    No. There's no deadline yet, and we'll give you plenty of notice before anything changes. When you are ready, email [support@beebole.com](mailto:support@beebole.com) and our team runs the migration for you — there is no migration tool to find in the app. In the meantime we recommend testing the new platform, and if you'd like to test it with your own data, ask us and we'll add a copy of your Legacy data to your trial account.
  </Accordion>

  <Accordion title="Will I lose my historical data when I migrate?">
    No. Your Legacy account and its data stay safe and untouched, no matter what you do in the new platform. You can also export and save your historical data at any time — and if you're unsure of the best way to do so, just ask us.
  </Accordion>

  <Accordion title="Can I migrate my Legacy data into a new configuration or project hierarchy?">
    No. Data from the Legacy system can only be migrated into the new Beebole as is. You tell support which data to migrate — for example only your people, or only your projects — but not how to reshape it. Migrated projects keep the hierarchy they had in Legacy. If you want a different structure, we recommend exporting and saving your historical data and starting fresh in the new platform.
  </Accordion>

  <Accordion title="Will my pricing change when I switch to the new platform?">
    No. You may see different pricing in the new app, but we'll honor current per-user pricing for all existing customers.
  </Accordion>

  <Accordion title="What should I do if I encounter a bug or if something doesn't work as expected?">
    The new Beebole is in beta, so you may occasionally run into something that doesn't behave as expected. If that happens, let us know. Reach out via the in-app chat or email us at [support@beebole.com](mailto:support@beebole.com). We're actively working through issues as they're reported and releasing fixes regularly.
  </Accordion>

  <Accordion title="Can I use the same email for my trial and my Legacy account?">
    Yes. You can sign up for the new platform  with the same email address. Login for the Legacy system is at [beebole-apps.com/signin](http://beebole-apps.com/signin/). Login for the new system is done at [app.beebole.com](https://app.beebole.com/signin).
  </Accordion>

  <Accordion title="Do my API integrations carry over automatically?">
    No. The new platform uses a GraphQL API, so Legacy integrations need to be updated. Your existing integrations keep working in your Legacy account.
  </Accordion>
</AccordionGroup>


# Project Manager Guide: plan and run projects
Source: https://beebole.com/help/guides/project-manager

A Beebole guide for project managers: set up projects and categories, plan tasks on Gantt and Kanban, set rates and budgets, run reports, and approve time.

As a project manager in Beebole, you set up the work your team tracks against and keep it on budget. This guide covers the core flow — create projects, plan tasks, set rates and budgets, run reports, and approve the time logged on your projects. Each step links to the page with the full detail.

<Info>
  How much you can configure depends on the role your administrator assigned you. The tasks below assume your role grants management rights over your projects.
</Info>

## Set up your projects

Open **Projects** in the sidebar to create the projects your team logs time against. Projects belong to categories — the broadest cut of your work, such as **Clients**, **Internal**, or **Activities** — and can nest into subprojects as deep as you need.

Create a project, place it in a category, and add subprojects to break the work down. See [Projects](/help/documentation/projects) for the full hierarchy and project settings.

## Plan the work as tasks

Open **Planning** in the sidebar to plan the work to be done. A task is a planning item you can schedule, assign to people, and link to a project so it inherits that project's rates and approval rules. The same tasks appear in two views:

* **Gantt** — a timeline view for scheduling tasks, durations, and dependencies.
* **Kanban** — a board view for moving tasks through their status workflow.

Add a task with **Add Task**, then schedule it on the [Gantt](/help/documentation/gantt) chart or track its status on the [Kanban](/help/documentation/kanban) board. The [Tasks overview](/help/documentation/planning) explains how both views share the same underlying tasks.

## Set rates and budgets

To turn hours into money, set billing and cost rates on your projects, and add budgets to cap spend or effort.

* **Rates** — set a billing rate (what you charge) and a cost rate (what the work costs) on a project; Beebole resolves the right rate for each entry. See [Billing](/help/documentation/billing).
* **Budgets** — set a ceiling in billing currency, cost currency, or hours on a project, and split it across people or subprojects. See [Budgets](/help/documentation/budgets).

## Run reports

Use **Reports** in the sidebar to analyze your projects — hours logged, billing, costs, and profitability — grouped by project, person, task, or period. Save a report configuration to reuse and refresh it later.

See [Reports](/help/documentation/reports) for grouping, filtering, and saved reports.

## Approve time on your projects

When approval is configured, the timesheets your team submits enter a workflow where you review the work logged on your projects. Open the approval view, check each submitted period, and click **Approve** to validate it or **Reject** to send it back with a comment.

See [Approval](/help/documentation/approval) for how the stages work.

## Related content

<CardGroup>
  <Card title="Projects" icon="folder" href="/help/documentation/projects">
    Create projects, organize them by category, and nest subprojects.
  </Card>

  <Card title="Tasks overview" icon="list-check" href="/help/documentation/planning">
    See how Gantt and Kanban share the same underlying tasks.
  </Card>

  <Card title="Budgets" icon="coins" href="/help/documentation/budgets">
    Cap spend or effort on a project and split it across the team.
  </Card>

  <Card title="Reports" icon="chart-bar" href="/help/documentation/reports">
    Analyze hours, billing, costs, and profitability across projects.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How do I create a project in Beebole?">
    Open **Projects** in the sidebar, create a project, and place it in a category such as **Clients** or **Internal**. You can add subprojects to break the work down as deep as you need.
  </Accordion>

  <Accordion title="What is the difference between Gantt and Kanban in Beebole?">
    Both views show the same Beebole tasks. **Gantt** is a timeline for scheduling tasks, durations, and dependencies, while **Kanban** is a board for moving tasks through their status workflow.
  </Accordion>

  <Accordion title="How do I set what a project costs and charges?">
    Set a billing rate and a cost rate on the project in Beebole. The billing rate is what you charge the client; the cost rate is what the work costs you. Beebole resolves the right rate for each time entry automatically.
  </Accordion>

  <Accordion title="Can I cap how much a project spends?">
    Yes. Add a budget to the project in Beebole as a ceiling in billing currency, cost currency, or hours, and split it across people or subprojects to track progress against the limit.
  </Accordion>

  <Accordion title="How do I approve the time logged on my projects?">
    When approval is configured, open the approval view in Beebole, review each submitted timesheet, and click **Approve** to validate it or **Reject** to return it with a comment.
  </Accordion>
</AccordionGroup>


# Team Leader Guide: manage and approve your team
Source: https://beebole.com/help/guides/team-leader

A Beebole guide for team leaders: add and invite people, assign roles and work schedules, approve timesheets and time off, and monitor team compliance.

As a team leader in Beebole, you manage the people on your team and keep their time tracking on track. This guide covers the core flow — add and invite people, assign their roles and work schedules, approve the timesheets and time off they submit, and monitor compliance. Each step links to the page with the full detail.

<Info>
  What you can do depends on the role your administrator assigned you. The tasks below assume your role grants management rights over your team's people, schedules, and approvals.
</Info>

## Add and invite people

Open **People** in the sidebar to add the team members who track time. Click the **+** button (**Add person**) and enter their **Name**, **Email**, and **Role**. To add several people at once, copy rows from a spreadsheet — one person per line: name, then **Tab**, then email — click **Paste**, review the entries, and add them all.

Adding a person and inviting them are two separate steps: a profile exists as soon as you save it, but the person cannot sign in until you invite them. Open the person's profile and click **Invite by email** — Beebole emails a secure link, with no password to set.

See [People](/help/documentation/people) for the full add, invite, and offboarding flow.

## Assign roles

Each person has a role that controls what they can see and do in Beebole. You set the role when you add a person, and you can change it at any time from the **Role** field on their profile. Roles are defined under **Settings** > **Person Roles**, where you can create roles and choose the permissions each one grants.

See [Roles & permissions](/help/documentation/roles-authorisations) for what each permission scope covers.

## Assign work schedules

A work schedule defines a person's standard working hours and days, which Beebole uses to measure overtime and undertime when they submit. Open a person's profile, use the **Work schedule** panel, and pick a schedule with the **Select schedule** picker — the assignment saves automatically. A schedule set on a person overrides one inherited from their tags or the organization default.

See [Work schedules](/help/documentation/work-schedule) for creating schedules and assigning them at the organization, tag, and person levels.

## Approve timesheets and time off

When approval is configured, the timesheets your team submits enter a workflow where you review their work. Open the approval view, check each submitted period, and click **Approve** to validate it or **Reject** to return it with a comment. Rejecting requires a reason, and the person resubmits after fixing their entries. Time-off requests follow the same review workflow.

See [Approval](/help/documentation/approval) for how the stages work and how to handle time off.

## Monitor team compliance

Keep your team on track from two places in Beebole:

* **Timesheet score** — a per-person compliance score shown on your team and approval views. It reflects whether each person is **On time**, has **Late submissions**, has **Not submitted**, or has **Rejections** — a quick read on who needs a nudge.
* **Journal** — open **Journal** in the sidebar for your team's activity feed: submissions, approvals, rejections, and messages. You can filter the feed and post messages to follow up with people.

See [Journal](/help/documentation/journal) for the activity feed, filtering, and messages.

## Related content

<CardGroup>
  <Card title="People" icon="users" href="/help/documentation/people">
    Add team members, invite them by email, and offboard people.
  </Card>

  <Card title="Roles & permissions" icon="shield-halved" href="/help/documentation/roles-authorisations">
    Define roles and choose what each person can see and do.
  </Card>

  <Card title="Approval" icon="circle-check" href="/help/documentation/approval">
    Review submitted timesheets and time off, then approve or reject.
  </Card>

  <Card title="Journal" icon="rss" href="/help/documentation/journal">
    Follow your team's activity feed and message people directly.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="How do I invite a team member to Beebole?">
    Add the person first: open **People** in the sidebar, click the **+** button (**Add person**), and enter their **Name**, **Email**, and **Role**. Then open their profile and click **Invite by email**. Beebole sends a secure sign-in link — there is no password to set.
  </Accordion>

  <Accordion title="How do I add several people at once?">
    In the add-person panel in Beebole, copy rows from a spreadsheet — one person per line, with the name and email separated by **Tab** — click **Paste**, review the entries, and add them all in one step.
  </Accordion>

  <Accordion title="How do I change someone's role?">
    Open the person's profile in Beebole and select a new role from the **Role** field. The change applies immediately. Roles themselves are created under **Settings** > **Person Roles**.
  </Accordion>

  <Accordion title="How do I approve my team's timesheets?">
    When approval is configured, open the approval view in Beebole, review each submitted period, and click **Approve** to validate it or **Reject** to return it with a required reason. Time-off requests follow the same workflow.
  </Accordion>

  <Accordion title="How do I see who has not submitted their timesheet?">
    Use the **Timesheet score** on your team and approval views in Beebole. It flags each person as **On time**, **Late submissions**, **Not submitted**, or **Rejections**, so you can spot who needs a reminder at a glance.
  </Accordion>
</AccordionGroup>


# Beebole Documentation
Source: https://beebole.com/help/index

Find everything you need to set up, configure, and use Beebole for project time tracking. Guides for administrators, managers, and employees.

Beebole is a project time tracking application that helps teams record work hours, manage time off, plan projects and tasks, track expenses, and generate reports. This documentation covers everything you need to get started and make the most of your Beebole account.

<Card title="Get started with Beebole" icon="rocket" href="/help/documentation/quickstart">
  New to Beebole? Set up your account in six steps — from your first project to your first report.
</Card>

## Browse by topic

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Record work hours, submit timesheets, and configure time entry settings.
  </Card>

  <Card title="Projects" icon="folder-open" href="/help/documentation/projects">
    Create projects, organize them into categories, and configure rates and budgets.
  </Card>

  <Card title="People" icon="users" href="/help/documentation/people">
    Add, invite, and configure the users in your account.
  </Card>

  <Card title="Time off" icon="calendar-xmark" href="/help/documentation/timeoff">
    Set up leave types, manage requests, and configure accrual rules.
  </Card>

  <Card title="Planning" icon="calendar-days" href="/help/documentation/planning">
    Organize work into tasks and track them on Gantt and Kanban views.
  </Card>

  <Card title="Reports" icon="chart-column" href="/help/documentation/reports">
    Generate reports, export data, and connect to Excel or Google Sheets.
  </Card>

  <Card title="Billing and costs" icon="money-bill" href="/help/documentation/billing">
    Configure billing rates at every level and see billed amounts in your reports.
  </Card>

  <Card title="Configuration" icon="gear" href="/help/documentation/roles-authorisations">
    Set up roles and permissions to control what each person can see and do.
  </Card>

  <Card title="Mobile app" icon="mobile-screen" href="/help/documentation/mobile">
    Track time, submit timesheets, and request time off from your phone.
  </Card>
</CardGroup>

## Guides by role

<CardGroup>
  <Card title="For employees" icon="user" href="/help/guides/employee">
    Learn how to record time, submit timesheets, and request time off.
  </Card>

  <Card title="For project managers" icon="user-tie" href="/help/guides/project-manager">
    Track project progress, review team hours, and run project reports.
  </Card>

  <Card title="For team leaders" icon="user-shield" href="/help/guides/team-leader">
    Approve timesheets, manage your team, and monitor workloads.
  </Card>
</CardGroup>

## Go further

<CardGroup>
  <Card title="Integrations" icon="puzzle-piece" href="/help/integrations/introduction">
    Connect Beebole with Jira, Asana, Linear, QuickBooks, and more.
  </Card>

  <Card title="Developers" icon="code" href="/help/api/introduction">
    Build on the Beebole GraphQL API, connect AI assistants via MCP, and push events with webhooks.
  </Card>

  <Card title="News" icon="newspaper" href="/help/news/releases">
    Stay up to date with the latest Beebole features and improvements.
  </Card>
</CardGroup>

## Need help?

<CardGroup>
  <Card title="Troubleshooting" icon="wrench" href="/help/documentation/troubleshooting">
    Beebole won't load or feels slow? Understand the connection indicators and run the built-in diagnostics page.
  </Card>

  <Card title="FAQ" icon="circle-question" href="/help/guides/faq">
    Quick answers to the most common questions about Beebole.
  </Card>
</CardGroup>

Can't find what you're looking for? Contact us at [support@beebole.com](mailto:support@beebole.com).


# Asana integration: import projects and tasks
Source: https://beebole.com/help/integrations/asana

Import Asana projects, tasks, and sub-tasks into Beebole for time tracking. Automatic webhook-based sync keeps your Asana workspace and Beebole account in sync.

Beebole's Asana integration imports your Asana projects, tasks, and sub-tasks into Beebole so your team can track time against their Asana work. The integration keeps your Asana workspace and Beebole account in sync automatically — when a project or task is created or renamed in Asana, the change is reflected in Beebole.

You can import your Asana structure into Beebole's **Projects and activities** for time tracking with costs, billing, and expenses, or into **Planning and tasks** for resource assignment.

| Asana    | Projects and activities | Planning and tasks |
| -------- | ----------------------- | ------------------ |
| Project  | Project                 | Task               |
| Task     | Subproject              | Sub-task           |
| Sub-task | Sub-subproject          | Sub-sub-task       |

***

## Before you start

<Info>
  You need administrative privileges in both Asana and Beebole to set up the integration.
</Info>

| What syncs from Asana                                                | What stays in Beebole                                            |
| -------------------------------------------------------------------- | ---------------------------------------------------------------- |
| **Projects:** Imported as Beebole projects or tasks.                 | **Approval workflows:** Beebole handles the timesheet lifecycle. |
| **Tasks:** Imported as Beebole subprojects or sub-tasks.             | **Billing rates:** Managed exclusively in Beebole.               |
| **Sub-tasks:** Imported as Beebole sub-subprojects or sub-sub-tasks. | **Budgets:** Set within Beebole's billing and budget settings.   |
| **Users:** Asana active users are mapped as Beebole people.          |                                                                  |

***

## What's included

<AccordionGroup>
  <Accordion title="Asana projects, tasks, and sub-tasks">
    Active projects, tasks, and sub-tasks at the time of enabling the integration are created in Beebole. Any name change to those items is reflected in Beebole while the integration is active. New projects and tasks created in Asana are also automatically added to Beebole.
  </Accordion>

  <Accordion title="Asana users">
    All active users in your Asana workspace are automatically created as people in Beebole when you first enable the integration. You choose a default role for these imported employees during setup.
  </Accordion>

  <Accordion title="Items managed in Beebole">
    Timesheet entries, approval workflows, billing rates, budgets, and expenses remain in Beebole and are not affected by the integration.
  </Accordion>

  <Accordion title="Deletions and moves">
    Deleting an Asana project or task that already has time logged against it in Beebole archives the Beebole record instead of removing it, so the tracked history is preserved. Tasks moved between projects in Asana keep syncing to their new parent.
  </Accordion>
</AccordionGroup>

Beebole recognizes repeated or retried deliveries from Asana and processes each change once, so a retry never creates duplicate projects or tasks. When Asana rate-limits a request, Beebole backs off and retries rather than failing the sync, and any error Asana returns is reported with its actual reason instead of a generic failure.

***

## Step-by-step configuration

<Steps>
  <Step title="Connect to Asana">
    Go to **Settings** > **Integrations** > **Asana**. Click **Connect to Asana**.

    <Frame>
      <img alt="Beebole Asana integration connect button" />
    </Frame>

    Follow the instructions in the popup to authorize Beebole to access your Asana workspace. The popup closes automatically when the connection is complete.
  </Step>

  <Step title="Configure integration parameters">
    Once connected, configure the following options:

    * **Asana workspace** — If your Asana account is linked to more than one workspace, select the one you want to sync with Beebole.
    * **Default role for imported employees** — Select the role to assign to Asana users when they are imported into Beebole.
    * **Where to import your tasks** — Choose between **Projects and activities** (for project time tracking with rates and billing) or **Planning and tasks** (for resource planning and assignment).

    <Frame>
      <img alt="Beebole Asana integration parameters" />
    </Frame>

    <Tip>
      You can review and manage existing roles in **Settings** > **Person Roles**.
    </Tip>
  </Step>

  <Step title="Enable the integration">
    Click the toggle to **Enable integration**. Beebole imports all your active Asana projects, tasks, and sub-tasks.

    <Frame>
      <img alt="Beebole Asana integration updating" />
    </Frame>

    <Info>
      The initial import may take a few moments depending on the size of your Asana workspace. You can continue using Beebole while the import runs in the background.
    </Info>

    Once complete, the integration is active. All future changes in Asana are automatically reflected in Beebole.
  </Step>

  <Step title="Validate the integration">
    Click **Projects** in the sidebar to open the Projects page. Expand the categories — you should see a new category called **Asana** containing all your imported projects and tasks. You can rename this category if needed.

    <Frame>
      <img alt="Beebole projects page showing imported Asana category" />
    </Frame>
  </Step>

  <Step title="Configure the timesheet">
    If you want the new Asana category to appear in the timesheet, go to **Settings** > **Account Settings** > **Timesheet settings** > **Categories** and select the Asana category.
  </Step>
</Steps>

***

## Disabling the integration

<Warning>
  If you disable the integration, any future changes made in Asana will no longer sync to Beebole. Previously imported data remains in Beebole as local records.
</Warning>

To disable the integration, go to **Settings** > **Integrations** > **Asana** and toggle the integration off. You can re-enable it at any time to resume syncing. If the change can't be applied, the toggle reverts to its previous state and Beebole reports the error — it never stays stuck mid-update.

To disconnect your Asana account entirely, click **Reset connection**.

***

## Related content

<CardGroup>
  <Card title="Projects and activities" icon="folder" href="/help/documentation/projects">
    Manage your projects, subprojects, and billing rates in Beebole.
  </Card>

  <Card title="Planning and tasks" icon="calendar-check" href="/help/documentation/planning">
    Create, organize, and assign tasks, and track time against them.
  </Card>

  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations using the Beebole GraphQL API.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between Projects and activities and Planning and tasks?">
    Beebole's time management has two structures. **Projects and activities** can be configured with billing rates, costs, budgets, and expenses. **Planning and tasks** is a list of tasks you can assign in resource planning charts. Both can be used in the timesheet to track time. Choose the option that best fits how your organization manages work.
  </Accordion>

  <Accordion title="How often does Beebole sync with Asana?">
    Changes made in Asana (new projects, tasks, or name updates) are reflected in Beebole automatically via webhooks. In most cases this happens within minutes. If a change is not reflected within 24 hours, contact [support@beebole.com](mailto:support@beebole.com).
  </Accordion>

  <Accordion title="Can I choose which Asana projects to import?">
    The integration imports all active projects and tasks from your Asana workspace. You cannot selectively import individual projects. However, you can organize and filter imported items within Beebole after the import.
  </Accordion>

  <Accordion title="What happens to imported data if I disable the integration?">
    All previously imported projects, tasks, and people remain in Beebole as local records. They are not deleted. Only future changes from Asana will stop syncing until you re-enable the integration.
  </Accordion>

  <Accordion title="Do I need admin access in both Asana and Beebole?">
    Yes. You need administrative privileges in both your Asana workspace and your Beebole account to set up and configure the integration.
  </Accordion>
</AccordionGroup>


# BambooHR Approved Time-Off Sync Integration
Source: https://beebole.com/help/integrations/bamboohr

Sync BambooHR time-off requests to Beebole absences. Connect your BambooHR account to automatically import approved leave into Beebole.

Beebole's BambooHR integration connects your BambooHR account to Beebole so that approved time-off requests are automatically reflected as absence records. When you enable the integration, Beebole imports your BambooHR employees and maps your BambooHR time-off types to Beebole absence types, then syncs approved requests every 24 hours.

***

## What syncs and what stays in Beebole

<Info>
  You need administrative privileges in both BambooHR and Beebole to set up the integration.
</Info>

| What syncs from BambooHR                                            | What stays in Beebole                                                            |
| ------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| **Employees:** Imported as Beebole people.                          | **Timesheet entries:** Managed exclusively in Beebole.                           |
| **Time-off types:** Mapped to Beebole absence types.                | **Approval workflows:** Beebole handles its own timesheet lifecycle.             |
| **Approved time-off requests:** Created as Beebole absence records. | **Billing rates and budgets:** Set within Beebole's billing and budget settings. |

***

## What's included

<AccordionGroup>
  <Accordion title="Employee import">
    BambooHR employees with a work email address are created as people in Beebole during the initial setup. If an employee's email already exists in Beebole, the integration links to the existing person instead of creating a duplicate.
  </Accordion>

  <Accordion title="Absence type mapping">
    BambooHR time-off types are matched to Beebole absence types by name (case-insensitive). If a matching absence type exists in Beebole, the integration links to it. If no match is found, a new absence type is created automatically. Time-off types measured in hours are configured with an hourly unit in Beebole.

    <Warning>
      BambooHR's paid/unpaid setting is not carried over. Every imported absence type counts toward people costs in Beebole, even if the time-off type is unpaid in BambooHR — see [Time off in people costs](/help/documentation/costs#time-off-in-people-costs).
    </Warning>
  </Accordion>

  <Accordion title="Time-off request sync">
    Approved time-off requests from the start of the current year through one year from today are imported as Beebole absence records. Each request is processed per calendar day. If a request changes after import (dates, amount, or notes), Beebole updates the corresponding absence record on the next sync.

    Records removed from BambooHR within the sync window are also removed from Beebole.
  </Accordion>

  <Accordion title="Schedule-aware duration calculation">
    When a time-off request is measured in days, Beebole calculates the absence duration using the employee's assigned work schedule. If the employee has no schedule assigned, Beebole defaults to an 8-hour workday.
  </Accordion>
</AccordionGroup>

***

## Step-by-step configuration

<Steps>
  <Step title="Enter your BambooHR company subdomain">
    Go to **Settings** > **Integrations** > **BambooHR**. In the **Company subdomain** field, enter your BambooHR subdomain (for example, enter `acme` if your BambooHR URL is `acme.bamboohr.com`).
  </Step>

  <Step title="Connect to BambooHR">
    Click **Connect to BambooHR**. A popup opens to authorize Beebole to access your BambooHR account. Complete the authorization flow. The popup closes automatically when the connection is established and your **BambooHR domain** is displayed as confirmed.
  </Step>

  <Step title="Set the default role for imported employees">
    Select the **Default role for imported employees**. This role is assigned to any BambooHR employee who is created as a new person in Beebole during import.

    <Tip>
      You can review and manage existing roles in **Settings** > **Person Roles**.
    </Tip>
  </Step>

  <Step title="Enable the integration">
    Click the toggle to **Enable integration**. Beebole immediately:

    1. Imports all BambooHR employees (creating new Beebole people where needed).
    2. Maps BambooHR time-off types to Beebole absence types.
    3. Imports approved time-off requests for the current year through one year from today.

    <Info>
      The initial import may take a few moments. A summary shows how many entries were successfully imported and lists any entries that could not be processed.
    </Info>
  </Step>

  <Step title="Validate and manually sync">
    Once enabled, verify that imported records appear correctly: the absences show as **Time off** on the affected people's timesheets, and you can run a report in **Reports** to review them across your team. The integration syncs automatically every 24 hours.

    To trigger an immediate sync at any time, go to **Settings** > **Integrations** > **BambooHR** and click **Manual sync** under **Manually sync last changes from BambooHR**.
  </Step>
</Steps>

***

## Disabling the integration

<Warning>
  If you disable the integration, automatic syncing stops. Previously imported absence records remain in Beebole as local records and are not deleted.
</Warning>

To disable the integration, go to **Settings** > **Integrations** > **BambooHR** and toggle the integration off. You can re-enable it at any time to resume automatic syncing.

To disconnect your BambooHR account entirely, click **Reset connection**. This removes the OAuth connection and clears all integration mappings.

***

## Related content

<CardGroup>
  <Card title="Time off and absences" icon="calendar-xmark" href="/help/documentation/timeoff">
    Manage absence types, quotas, and time-off requests in Beebole.
  </Card>

  <Card title="People management" icon="users" href="/help/documentation/people">
    Add and manage employees, roles, and schedules in your Beebole account.
  </Card>

  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations using the Beebole GraphQL API.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What date range does Beebole sync from BambooHR?">
    The integration syncs approved time-off requests from January 1st of the current year through one year from today. Requests outside this window are not imported. You can trigger a manual sync at any time from the integration settings page.
  </Accordion>

  <Accordion title="What happens if a BambooHR time-off type has no matching absence type in Beebole?">
    If no Beebole absence type matches the BambooHR time-off type name exactly (case-insensitive), the integration creates a new absence type automatically. You can rename or reconfigure the created absence type in **Settings** > **Time Off**.
  </Accordion>

  <Accordion title="Can I map BambooHR employees to existing Beebole people?">
    Yes. The integration automatically links a BambooHR employee to an existing Beebole person if their work email addresses match. If no match is found, a new person is created with the default role you selected during setup.
  </Accordion>

  <Accordion title="How is the duration calculated for day-based time-off requests?">
    For requests measured in days, Beebole multiplies the day amount by the employee's scheduled working hours for that day (based on their assigned work schedule). If the employee has no schedule, Beebole uses 8 hours per day as the default. Requests measured in hours use the exact hourly amount from BambooHR.
  </Accordion>

  <Accordion title="Are unpaid BambooHR time-off types imported as unpaid in Beebole?">
    No. BambooHR's paid/unpaid distinction isn't carried over, and Beebole treats every time off type the same way in cost calculations — imported leave counts toward people costs like any other absence.
  </Accordion>

  <Accordion title="What happens if a time-off request is canceled or modified in BambooHR?">
    On the next sync, Beebole updates or removes the corresponding absence record to match the current state of approved requests in BambooHR. Records that no longer appear in the BambooHR response within the sync window are deleted from Beebole. You can also trigger a manual sync immediately from the integration settings page.
  </Accordion>
</AccordionGroup>


# Custom Integrations via GraphQL API
Source: https://beebole.com/help/integrations/custom-integrations

Build custom integrations with Beebole using the GraphQL API. Read and write your account data programmatically to connect Beebole to any tool.

Beebole's GraphQL API lets you build custom integrations that connect Beebole to any tool or internal system your organization uses. When the built-in integrations don't cover your needs, the API gives you full programmatic access to read and write your Beebole account data.

This page is a starting point. For endpoints, authentication details, queries, and mutations, see the [API introduction](/help/api/introduction).

## What you can build

Beebole's GraphQL API supports both queries (reading data) and mutations (creating or updating data). Common custom integrations include:

| Use case                   | What it does                                                                      |
| -------------------------- | --------------------------------------------------------------------------------- |
| **HR system sync**         | Create and update people in Beebole when employees change in your HR platform.    |
| **Custom reporting**       | Pull time records, project data, and financial summaries into your own dashboard. |
| **Automated time entries** | Create time entries programmatically from data in other systems.                  |
| **Project provisioning**   | Create projects and subprojects in Beebole from your internal tools.              |
| **Payroll export**         | Extract approved time data in the format your payroll provider requires.          |

## Getting your API key

<Steps>
  <Step title="Access the API documentation">
    Review the full API reference in the [API documentation](/help/api/introduction) tab. It covers authentication, the schema explorer, available queries, and mutations.
  </Step>

  <Step title="Generate an API token">
    Go to **Settings** > **API** in your Beebole account to generate an API token. This token authenticates your requests.

    <Warning>
      Keep your API token secure. Do not share it in client-side code or public repositories.
    </Warning>
  </Step>

  <Step title="Explore the schema">
    Use the [schema explorer](/help/api/schema-explorer) to browse all available types, queries, and mutations. This helps you understand the data model before writing your integration.
  </Step>

  <Step title="Build and test your integration">
    Start with simple queries to read data, then move to mutations when you are ready to create or update records. Test thoroughly in a development environment before deploying to production.
  </Step>
</Steps>

Every person in Beebole has a personal **API Key** that authenticates their API requests. The key is created automatically and does not expire.

<Steps>
  <Step title="Open your API key">
    Click the button with your initials at the bottom of the sidebar, then choose **API Key**.
  </Step>

  <Step title="Copy the key">
    Click **Copy** to copy your **API Key** to the clipboard.
  </Step>

  <Step title="Authenticate your requests">
    Include the key in your API requests as described in the [API introduction](/help/api/introduction).
  </Step>
</Steps>

<Warning>
  Keep your API key secure. Don't include it in client-side code or commit it to public repositories — store it in an environment variable or a secrets manager. If a key is compromised, click **Reset** to revoke it and generate a new one.
</Warning>

## Best practices

<Tip>
  Start with a read-only integration (queries only) to validate your data mapping before writing data back to Beebole.
</Tip>

* **Use clear names** for projects and people created through the API so they are easy to recognize in Beebole.
* **Handle errors gracefully.** The API returns descriptive error messages — log and handle them in your code.
* **Keep your key secure.** Store it in an environment variable or a secrets manager, not in source code.

## Related content

<CardGroup>
  <Card title="API introduction" icon="book" href="/help/api/introduction">
    Authenticate with the Beebole GraphQL API and send your first request.
  </Card>

  <Card title="Webhooks" icon="webhook" href="/help/integrations/webhooks">
    Send real-time Beebole event notifications to your own services.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Browse the built-in Beebole integrations.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Where do I find my API key in Beebole?">
    Click the button with your initials at the bottom of the sidebar, then choose **API Key**. Your key is shown there with **Copy** and **Reset** actions. Beebole creates one key per person automatically, and it does not expire.
  </Accordion>

  <Accordion title="What programming languages can I use?">
    Any language with an HTTP client. The Beebole API uses standard GraphQL over HTTPS, so Python, JavaScript, Ruby, Go, Java, and others all work.
  </Accordion>

  <Accordion title="Can I create time entries through the API?">
    Yes. The Beebole API supports mutations for creating and updating time entries, projects, people, and other records. See the [API introduction](/help/api/introduction) for details.
  </Accordion>

  <Accordion title="What happens if I reset my API key?">
    Resetting revokes your current key and generates a new one. Any integration using the old key stops working until you update it with the new key, so reset only when you need to rotate a compromised key.
  </Accordion>
</AccordionGroup>


# Sign in to Beebole with Google — SSO and Domain Links
Source: https://beebole.com/help/integrations/google

Sign in to Beebole with a Google account, link your Google Workspace domains, auto-provision people, and require Google sign-in across your organization.

Google sign-in lets anyone in your organization sign in to Beebole with their existing Google account, which is convenient for teams already on Google Workspace. It is a built-in sign-in option — no administrator setup is required to use it. Linking your Google domains adds organization-level controls: automatic provisioning and the option to require Google sign-in for everyone.

<Info>
  This page covers the Google-specific controls. For the full picture of how sign-in and single sign-on work in Beebole — email codes, passkeys, and the **Single Sign-On** panel — see [Sign-in, passkeys, SSO, and API keys](/help/documentation/authentication).
</Info>

## Sign in with Google

Google sign-in is always available on the Beebole sign-in screen. Under **Or Sign in with**, click the **Google** button, then authenticate with your Google account. Beebole matches the Google account's email address to your Beebole profile, so both must use the same email address.

Because Google sign-in is built in, you do not need to turn anything on for your team to use it. Linking domains, described below, is optional and unlocks the organization-level controls.

## Link your Google domains

Linking a domain ties your Google Workspace organization to your Beebole account and enables the controls that follow. You configure this on the **Single Sign-On** panel of **Account Settings**, on the **Google** tab.

<Steps>
  <Step title="Open the Google tab">
    Go to **Settings** > **Account Settings**, open the **Single Sign-On** panel, and select the **Google** tab.
  </Step>

  <Step title="Add a domain">
    Type your organization's email domain in the **Linked domains** field and click **Add**. To unlink a domain, click **Remove** next to it. Changes save automatically.
  </Step>

  <Step title="Finish in Google Marketplace">
    Once a domain is linked, Beebole shows a **Go to Google Marketplace** link. Follow it to complete the setup in the Google Workspace Marketplace.
  </Step>
</Steps>

## Provision new people automatically

On the **Google** tab, turn on **Automatically create new users on first SSO login** to create a Beebole person automatically the first time someone with a matching linked domain signs in. With this setting off, a matching person must already exist in your Beebole account before they can sign in with Google. The setting saves automatically.

## Require Google sign-in

<Steps>
  <Step title="Open integration settings">
    Open **Settings** > **Single Sign-On** in your Beebole account, then switch to the **Google** tab.
  </Step>

  <Step title="Enable Google SSO">
    Locate the **Google** card and click **Connect**. Follow the OAuth prompts to authorize Beebole to verify your identity through Google.
  </Step>

  <Step title="Verify the connection">
    Once connected, the Google integration shows as active in your integration settings. Users in your account can now sign in using the **Sign in with Google** button on the login page.
  </Step>
</Steps>

To make Google the only way your team can sign in, turn on **Disable interactive sign-in. Only Google sign-in allowed.** on the **Google** tab. This blocks the email-code method for your organization, so everyone authenticates through Google.

<Warning>
  Before turning on **Disable interactive sign-in. Only Google sign-in allowed.**, confirm Google sign-in works for a test user. If Google sign-in becomes unavailable while enforcement is on, your team is locked out until you turn the toggle back off.
</Warning>

## Related content

<CardGroup>
  <Card title="Sign-in, passkeys, and SSO" icon="key" href="/help/documentation/authentication">
    How every sign-in method works in Beebole, including the Single Sign-On panel and Custom OpenID.
  </Card>

  <Card title="Microsoft sign-in" icon="microsoft" href="/help/integrations/microsoft">
    Sign in to Beebole with a Microsoft account and require Microsoft sign-in.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I need to set anything up to sign in with Google?">
    No. Google sign-in is a built-in option on the Beebole sign-in screen — click the **Google** button under **Or Sign in with**. Linking your Google domains is optional and only adds organization-level controls such as automatic provisioning and Google-only sign-in.
  </Accordion>

  <Accordion title="Does Google sign-in create Beebole people automatically?">
    Only if you turn on **Automatically create new users on first SSO login** on the **Google** tab of the **Single Sign-On** panel. With that setting off, a person with a matching email must already exist in your Beebole account before they can sign in with Google.
  </Accordion>

  <Accordion title="What if my Google email is different from my Beebole email?">
    Beebole matches accounts by email address. If your Google email does not match the email on your Beebole profile, Google sign-in will not find your account. Make the two email addresses match, or contact [support@beebole.com](mailto:support@beebole.com).
  </Accordion>

  <Accordion title="Can I make Google the only way my team signs in?">
    Yes. On the **Google** tab of the **Single Sign-On** panel, turn on **Disable interactive sign-in. Only Google sign-in allowed.** This blocks the email-code method so everyone authenticates through Google. Confirm Google sign-in works for a test user first.
  </Accordion>

  <Accordion title="Where do I find the Google settings in Beebole?">
    Go to **Settings** > **Account Settings**, open the **Single Sign-On** panel, and select the **Google** tab. SSO is configured on the organization itself, not as a separate menu item, and all settings save automatically.
  </Accordion>
</AccordionGroup>


# Google Calendar Time Tracking Integration
Source: https://beebole.com/help/integrations/google-calendar

Connect Google Calendar to your Beebole timesheet to see your events for the week and turn them into time entries with a click or a drag.

<Steps>
  <Step title="Open your timesheet">
    Navigate to your **Timesheet** page in Beebole.
  </Step>

  <Step title="Open the calendar panel">
    Click the **Calendar** icon in the timesheet toolbar to open the calendar events panel.
  </Step>

  <Step title="Connect to Google Calendar">
    Click **Connect to Google Calendar**. A popup appears asking you to sign in to your Google account and authorize Beebole to read your calendar events.
  </Step>

  <Step title="Authorize access">
    Follow the Google OAuth prompts to grant Beebole read-only access to your calendar. The popup closes automatically when the connection is complete.
  </Step>

  <Step title="View your events">
    Your Google Calendar events for the current timesheet period now appear in the calendar panel. You can drag and drop them onto timesheet rows to log time.
  </Step>
</Steps>

Beebole's Google Calendar connection lets you view your Google Calendar events next to your timesheet and turn them into time entries. It works per user and is read-only — Beebole reads your events for the displayed period and never writes anything back to Google. Use it to log meetings and appointments you already have on your calendar without retyping them.

<Info>
  This connection lives in the timesheet, not under **Settings** > **Integrations**. Each person connects their own calendar, and the connection stays in your browser.
</Info>

## Connect your Google Calendar

Open the calendar pane from your timesheet, then sign in with Google.

<Steps>
  <Step title="Open the calendar pane">
    Open your timesheet and click the calendar icon in the header (tooltip: **Import your calendar events**). The calendar pane opens beside your timesheet.
  </Step>

  <Step title="Sign in with Google">
    Click the Google icon (**Sign in with Google**). A Google window opens at accounts.google.com asking you to choose your account and allow read-only access to your calendar.
  </Step>

  <Step title="Review your events">
    Once connected, Beebole loads your Google Calendar events for the period your timesheet is showing, grouped by day. Changing the timesheet period reloads the matching events.
  </Step>
</Steps>

## Log an event as a time entry

The calendar pane shows your events for the displayed week. Assign them to your timesheet by clicking or by dragging.

<Tabs>
  <Tab title="Click to assign">
    Click one or more events to select them — the pane shows the count and the prompt **Click a timesheet row to assign**. Then click the timesheet row you want. Beebole creates a time entry from each selected event. Click **Cancel** to clear the selection.
  </Tab>

  <Tab title="Drag to assign">
    Drag an event from the pane onto a timesheet row. Rows that can accept the event highlight as you hover. Drop it to create the time entry.
  </Tab>
</Tabs>

Events you have already logged show a green **Tracked** badge and are dimmed, so you can tell at a glance what is left to record.

## Disconnect your Google Calendar

In the calendar pane footer, click **Sign out / reset connection**. This clears the stored connection from your browser and removes the events from the pane. Your time entries and your Google Calendar are not affected.

## Related content

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Record, submit, and manage your time entries in Beebole.
  </Card>

  <Card title="Microsoft Calendar" icon="calendar" href="/help/integrations/microsoft-calendar">
    Connect Microsoft Calendar to your timesheet the same way.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Does Beebole change my Google Calendar?">
    No. Beebole's Google Calendar connection is read-only. It reads your events for the displayed timesheet period to show them in the calendar pane, and never creates, edits, or deletes anything in Google Calendar.
  </Accordion>

  <Accordion title="Where do I connect my Google Calendar in Beebole?">
    You connect it from the timesheet, not from **Settings** > **Integrations**. Open the calendar pane with the calendar icon in the timesheet header (**Import your calendar events**), then click **Sign in with Google**.
  </Accordion>

  <Accordion title="Is the connection shared with my team?">
    No. The Google Calendar connection is per user and stays in your own browser. Each person who wants to import calendar events connects their own account.
  </Accordion>

  <Accordion title="What does the Tracked badge mean?">
    The **Tracked** badge marks events you have already logged as time entries for that period. Tracked events are dimmed in the calendar pane so you can focus on the events still to record.
  </Accordion>

  <Accordion title="Which events does Beebole show?">
    Beebole shows your Google Calendar events for the period your timesheet is currently displaying, grouped by day. When you move to a different week, the pane reloads the events for that period.
  </Accordion>
</AccordionGroup>


# Integrations: Connect Your Tools
Source: https://beebole.com/help/integrations/introduction

Connect Beebole with Asana, Jira, Linear, monday.com, BambooHR, QuickBooks, Xero, and webhooks to keep projects, people, and time data in sync.

Beebole integrations connect your time tracking account to the project, accounting, and HR tools your team already uses. Import projects and work items from your project management tools, export time and expense data to your accounting software, sync people from your HR system, and push real-time events to your own services with webhooks.

Integrations are managed from **Settings** > **Integrations** in your Beebole account, opened from the button with your initials at the bottom of the sidebar. Each integration is configured independently.

<Info>
  You need a role with administrative permissions to set up the integrations under **Settings** > **Integrations**.
</Info>

## Project management

Import your projects and work items from project management tools into Beebole, then track time against them without duplicating data.

<CardGroup>
  <Card title="Asana" icon="list-check" href="/help/integrations/asana">
    Import Asana projects and work items into Beebole and keep them in sync.
  </Card>

  <Card title="Jira" icon="diagram-project" href="/help/integrations/jira">
    Import Jira projects and issues into Beebole for time tracking and planning.
  </Card>

  <Card title="Linear" icon="bolt" href="/help/integrations/linear">
    Import Linear projects and issues into Beebole and reflect changes automatically.
  </Card>

  <Card title="monday.com" icon="table-columns" href="/help/integrations/monday">
    Import boards and items from monday.com into Beebole to track time against them.
  </Card>
</CardGroup>

## Accounting

Export your Beebole time and expense data to accounting tools to streamline invoicing and reporting.

<CardGroup>
  <Card title="QuickBooks Online" icon="file-invoice-dollar" href="/help/integrations/quickbooks">
    Export time and expense data from Beebole to QuickBooks Online.
  </Card>

  <Card title="Xero" icon="file-invoice" href="/help/integrations/xero">
    Export time and expense data from Beebole to Xero.
  </Card>
</CardGroup>

## HR

Sync people between Beebole and your HR system so your team list stays current.

<CardGroup>
  <Card title="BambooHR" icon="users" href="/help/integrations/bamboohr">
    Sync people from BambooHR into Beebole to keep your team list up to date.
  </Card>
</CardGroup>

## AI assistants and developer connections

Connect the AI assistant you already use, or build your own connections to Beebole — these pages live in the **Developers** tab alongside the API reference.

<CardGroup>
  <Card title="MCP server" icon="plug" href="/help/integrations/mcp-server">
    Connect Claude, ChatGPT, and other AI assistants to your Beebole data with your permissions.
  </Card>

  <Card title="Webhooks" icon="webhook" href="/help/integrations/webhooks">
    Send real-time Beebole event notifications to your own services.
  </Card>

  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations with the Beebole GraphQL API.
  </Card>
</CardGroup>

## Sign-in and calendar

Two connections live outside **Settings** > **Integrations**. You can sign in to Beebole with your Google or Microsoft account, and each person can connect their own calendar to bring meetings into their timesheet.

<Info>
  The calendar connection is per-person and lives in the timesheet's external-calendar pane, not under **Settings** > **Integrations**. It is read-only: you click or drag calendar events onto your timesheet rows.
</Info>

<CardGroup>
  <Card title="Google sign-in" icon="google" href="/help/integrations/google">
    Sign in to Beebole with your Google account.
  </Card>

  <Card title="Microsoft sign-in" icon="microsoft" href="/help/integrations/microsoft">
    Sign in to Beebole with your Microsoft account.
  </Card>

  <Card title="Google Calendar" icon="calendar" href="/help/integrations/google-calendar">
    Bring Google Calendar events into your timesheet.
  </Card>

  <Card title="Microsoft Calendar" icon="calendar-days" href="/help/integrations/microsoft-calendar">
    Bring Microsoft Calendar events into your timesheet.
  </Card>
</CardGroup>

## Related content

<CardGroup>
  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations with the Beebole GraphQL API.
  </Card>

  <Card title="API introduction" icon="book" href="/help/api/introduction">
    Authenticate with the Beebole GraphQL API and send your first request.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Where do I find integrations in Beebole?">
    Most Beebole integrations are managed from **Settings** > **Integrations**, opened from the button with your initials at the bottom of the sidebar. You need a role with administrative permissions to configure them. The calendar connection is the exception — it lives in each person's timesheet rather than under Settings.
  </Accordion>

  <Accordion title="Can I use several integrations at the same time?">
    Yes. You can configure multiple Beebole integrations at once. For example, you can import projects from Asana, sync people from BambooHR, and export time data to QuickBooks Online together.
  </Accordion>

  <Accordion title="What happens to my data if I disconnect an integration?">
    Disconnecting an integration stops future syncing, but the records already brought into Beebole stay in your account. You can reconnect the integration later to resume syncing.
  </Accordion>

  <Accordion title="How is calendar different from the other integrations?">
    The calendar connection is per-person and read-only. Each person connects their own calendar from the timesheet's external-calendar pane and clicks or drags events onto their timesheet rows. It is not set up under **Settings** > **Integrations** like the project, accounting, and HR integrations.
  </Accordion>

  <Accordion title="Can I build my own integration with Beebole?">
    Yes. Beebole provides a [GraphQL API](/help/integrations/custom-integrations) you can use to build custom integrations with any tool or internal system, and [webhooks](/help/integrations/webhooks) to receive real-time event notifications.
  </Accordion>
</AccordionGroup>


# Jira integration: import projects and issues
Source: https://beebole.com/help/integrations/jira

Connect Jira Cloud to Beebole to import projects and issues for time tracking. Automatic sync keeps your Jira Cloud site aligned with Beebole.

Beebole's Jira integration imports your Jira projects and issues into Beebole so your team can track time against their Jira work. The integration keeps your Jira Cloud site and Beebole account in sync automatically — when a project or issue is created or updated in Jira, the change is reflected in Beebole.

You can import your Jira structure into Beebole's **Projects and activities** for time tracking with costs, billing, and expenses, or into **Planning and tasks** for resource assignment.

| Jira    | Projects and activities | Planning and tasks |
| ------- | ----------------------- | ------------------ |
| Project | Project                 | Task               |
| Issue   | Subproject              | Sub-task           |

***

## Before you start

<Info>
  You need administrative privileges in both Jira and Beebole to set up the integration.
</Info>

| What syncs from Jira                                      | What stays in Beebole                                            |
| --------------------------------------------------------- | ---------------------------------------------------------------- |
| **Projects:** Imported as Beebole projects or tasks.      | **Approval workflows:** Beebole handles the timesheet lifecycle. |
| **Issues:** Imported as Beebole subprojects or sub-tasks. | **Billing rates:** Managed exclusively in Beebole.               |
| **Users:** Jira users are mapped as Beebole people.       | **Budgets:** Set within Beebole's billing and budget settings.   |

***

## What's included

<AccordionGroup>
  <Accordion title="Jira projects and issues">
    Active projects and issues at the time of enabling the integration are created in Beebole. Any name change to those items is reflected in Beebole while the integration is active. New projects and issues created in Jira are also automatically added to Beebole.
  </Accordion>

  <Accordion title="Jira users">
    All active users in your Jira site are automatically created as people in Beebole when you first enable the integration. You choose a default role for these imported employees during setup.
  </Accordion>

  <Accordion title="Items managed in Beebole">
    Timesheet entries, approval workflows, billing rates, budgets, and expenses remain in Beebole and are not affected by the integration.
  </Accordion>
</AccordionGroup>

***

## Step-by-step configuration

<Steps>
  <Step title="Connect to Jira">
    Go to **Settings** > **Integrations** > **Jira**. Click **Connect to Jira**.

    Follow the instructions in the popup to enter your Jira Cloud URL and authorize Beebole to access your Jira site. The popup closes automatically when the connection is complete.
  </Step>

  <Step title="Configure integration parameters">
    Once connected, configure the following options:

    * **Where to import your tasks** — Choose between **Projects and activities** (for project time tracking with rates and billing) or **Planning and tasks** (for resource planning and assignment).
    * **Default role for imported employees** — Select the role to assign to Jira users when they are imported into Beebole.

    <Tip>
      You can review and manage existing roles in **Settings** > **Person Roles**.
    </Tip>
  </Step>

  <Step title="Enable the integration">
    Click the toggle to **Enable integration**. Beebole imports all your active Jira projects and issues.

    <Info>
      The initial import may take a few moments depending on the size of your Jira site. You can continue using Beebole while the import runs in the background.
    </Info>

    Once complete, the integration is active. All future changes in Jira are automatically reflected in Beebole.
  </Step>

  <Step title="Validate the integration">
    Click **Projects** in the sidebar to open the Projects page. Expand the categories — you should see a new category called **Jira** containing all your imported projects and issues. You can rename this category if needed.
  </Step>

  <Step title="Configure the timesheet">
    If you want the new Jira category to appear in the timesheet, go to **Settings** > **Account Settings** > **Timesheet settings** > **Categories** and select the Jira category.
  </Step>
</Steps>

***

## Privacy: people removed in Jira

Beebole periodically checks the Jira accounts it imported. When a person's Jira account is closed, Beebole anonymizes the matching imported person automatically — their name and email are scrubbed — while their time records stay intact for reporting. This keeps the account aligned with Atlassian's privacy requirements without any manual cleanup.

## Disabling the integration

<Warning>
  If you disable the integration, any future changes made in Jira will no longer sync to Beebole. Previously imported data remains in Beebole as local records.
</Warning>

To disable the integration, go to **Settings** > **Integrations** > **Jira** and toggle the integration off. You can re-enable it at any time to resume syncing.

To disconnect your Jira account entirely, click **Reset connection**.

***

## Related content

<CardGroup>
  <Card title="Projects and activities" icon="folder" href="/help/documentation/projects">
    Manage your projects, subprojects, and billing rates in Beebole.
  </Card>

  <Card title="Planning and tasks" icon="calendar-check" href="/help/documentation/planning">
    Create, organize, and assign tasks, and track time against them.
  </Card>

  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations using the Beebole GraphQL API.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between Projects and activities and Planning and tasks?">
    Beebole's time management has two structures. **Projects and activities** can be configured with billing rates, costs, budgets, and expenses. **Planning and tasks** is a list of tasks you can assign in resource planning charts. Both can be used in the timesheet to track time. Choose the option that best fits how your organization manages work.
  </Accordion>

  <Accordion title="How often does Beebole sync with Jira?">
    Changes made in Jira (new projects, issues, or name updates) are reflected in Beebole automatically. In most cases this happens within minutes. If a change is not reflected within 24 hours, contact [support@beebole.com](mailto:support@beebole.com).
  </Accordion>

  <Accordion title="Can I choose which Jira projects to import?">
    The integration imports all active projects and issues from your Jira site. You cannot selectively import individual projects. However, you can organize and filter imported items within Beebole after the import.
  </Accordion>

  <Accordion title="Does the integration work with Jira Server or Data Center?">
    The Beebole integration is designed for Jira Cloud. If you use Jira Server or Data Center, contact [support@beebole.com](mailto:support@beebole.com) to discuss options.
  </Accordion>

  <Accordion title="What happens to imported data if I disable the integration?">
    All previously imported projects, issues, and people remain in Beebole as local records. They are not deleted. Only future changes from Jira will stop syncing until you re-enable the integration.
  </Accordion>
</AccordionGroup>


# Linear integration: import projects and issues
Source: https://beebole.com/help/integrations/linear

Connect Linear to Beebole to import projects and issues for time tracking. Automatic sync keeps your Linear workspace aligned with Beebole in real time.

Beebole's Linear integration imports your Linear projects, issues, and team members into Beebole so your employees can track time against their Linear work. The integration keeps your Linear workspace and Beebole account in sync automatically — when a project or issue is created or renamed in Linear, the change is reflected in Beebole.

You can import your Linear structure into Beebole's **Projects and activities** for time tracking with costs, billing, and expenses, or into **Planning and tasks** for resource assignment.

| Linear  | Projects and activities | Planning and tasks |
| ------- | ----------------------- | ------------------ |
| Project | Project                 | Task               |
| Issue   | Subproject              | Sub-task           |

***

## Before you start

<Info>
  You need administrative privileges in both Linear and Beebole to set up the integration.
</Info>

| What syncs from Linear                                           | What stays in Beebole                                            |
| ---------------------------------------------------------------- | ---------------------------------------------------------------- |
| **Projects:** Imported as Beebole projects or tasks.             | **Approval workflows:** Beebole handles the timesheet lifecycle. |
| **Issues:** Imported as Beebole subprojects or sub-tasks.        | **Billing rates:** Managed exclusively in Beebole.               |
| **Members:** Linear active members are mapped as Beebole people. | **Budgets:** Set within Beebole's billing and budget settings.   |

***

## What's included

<AccordionGroup>
  <Accordion title="Linear projects and issues">
    Active projects and issues at the time of enabling the integration are created in Beebole. Any name change to those items is reflected in Beebole while the integration is active. New projects and issues created in Linear are also automatically added to Beebole.
  </Accordion>

  <Accordion title="Linear members">
    All active members in your Linear workspace are automatically created as people in Beebole when you first enable the integration. You choose a default role for these imported employees during setup.
  </Accordion>

  <Accordion title="Items managed in Beebole">
    Timesheet entries, approval workflows, billing rates, budgets, and expenses remain in Beebole and are not affected by the integration.
  </Accordion>
</AccordionGroup>

***

## Step-by-step configuration

<Steps>
  <Step title="Connect to Linear">
    Go to **Settings** > **Integrations** > **Linear**. Click **Connect to Linear**.

    Follow the instructions in the popup to authorize Beebole to access your Linear workspace. The popup closes automatically when the connection is complete.
  </Step>

  <Step title="Configure integration parameters">
    Once connected, configure the following options:

    * **Where to import your tasks** — Choose between **Projects and activities** (for project time tracking with rates and billing) or **Planning and tasks** (for resource planning and assignment).
    * **Default role for imported employees** — Select the role to assign to Linear members when they are imported into Beebole.

    <Tip>
      You can review and manage existing roles in **Settings** > **Person Roles**.
    </Tip>
  </Step>

  <Step title="Enable the integration">
    Click the toggle to **Enable integration**. Beebole imports all your active Linear projects and issues.

    <Info>
      The initial import may take a few moments depending on the size of your Linear workspace. You can continue using Beebole while the import runs in the background.
    </Info>

    Once complete, the integration is active. All future changes in Linear are automatically reflected in Beebole.
  </Step>

  <Step title="Validate the integration">
    Click **Projects** in the sidebar to open the Projects page. Expand the categories — you should see a new category called **Linear** containing all your imported projects and issues. You can rename this category if needed.
  </Step>

  <Step title="Configure the timesheet">
    If you want the new Linear category to appear in the timesheet, go to **Settings** > **Account Settings** > **Timesheet settings** > **Categories** and select the Linear category.
  </Step>
</Steps>

***

## Disabling the integration

<Warning>
  If you disable the integration, any future changes made in Linear will no longer sync to Beebole. Previously imported data remains in Beebole as local records.
</Warning>

To disable the integration, go to **Settings** > **Integrations** > **Linear** and toggle the integration off. You can re-enable it at any time to resume syncing.

To disconnect your Linear account entirely, click **Reset connection**.

***

## Related content

<CardGroup>
  <Card title="Projects and activities" icon="folder" href="/help/documentation/projects">
    Manage your projects, subprojects, and billing rates in Beebole.
  </Card>

  <Card title="Planning and tasks" icon="calendar-check" href="/help/documentation/planning">
    Create, organize, and assign tasks, and track time against them.
  </Card>

  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations using the Beebole GraphQL API.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between Projects and activities and Planning and tasks?">
    Beebole's time management has two structures. **Projects and activities** can be configured with billing rates, costs, budgets, and expenses. **Planning and tasks** is a list of tasks you can assign in resource planning charts. Both can be used in the timesheet to track time. Choose the option that best fits how your organization manages work.
  </Accordion>

  <Accordion title="How often does Beebole sync with Linear?">
    Changes made in Linear (new projects, issues, or name updates) are reflected in Beebole automatically. In most cases this happens within minutes. If a change is not reflected within 24 hours, contact [support@beebole.com](mailto:support@beebole.com).
  </Accordion>

  <Accordion title="Can I choose which Linear projects to import?">
    The integration imports all active projects and issues from your Linear workspace. You cannot selectively import individual projects. However, you can organize and filter imported items within Beebole after the import.
  </Accordion>

  <Accordion title="What happens to imported data if I disable the integration?">
    All previously imported projects, issues, and people remain in Beebole as local records. They are not deleted. Only future changes from Linear will stop syncing until you re-enable the integration.
  </Accordion>

  <Accordion title="Do I need admin access in both Linear and Beebole?">
    Yes. You need administrative privileges in both your Linear workspace and your Beebole account to set up and configure the integration.
  </Accordion>
</AccordionGroup>


# MCP server: connect Claude, ChatGPT, and more
Source: https://beebole.com/help/integrations/mcp-server

Connect AI assistants like Claude and ChatGPT to Beebole through its MCP server — log time, read timesheets, and list projects with your permissions.

Beebole exposes an MCP server so your own AI assistant can log time, read timesheets, and list projects — with exactly your permissions. Connect hosted assistants such as Claude and ChatGPT in a couple of clicks, or point developer tools like Claude Code and Cursor at the same server with your API key. Every connection is listed under **Connected apps**, where you can disconnect it anytime.

<Info>
  An assistant connected to Beebole acts as you: it sees only the data your role allows, and its actions are recorded like your own. This page is about connecting external assistants to your data — Beebole's built-in AI features are covered in [Beebole AI](/help/documentation/ai).
</Info>

***

## What a connected assistant can do

The server exposes a set of tools grouped around the things people actually do in Beebole, always bounded by your permissions. The list below covers the main ones rather than every tool:

| What you want to do                     | Tools the assistant uses                                                                                                                                                                                                                                                                                                                                |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Understand your account first           | `get_context` — who you are, how your organization names its structure (category names and the name of each level, custom fields and the entities they live on), and how its timesheet works: periodicity and current period, the project levels an entry needs, which plannings accept time, the lock date, the entry rules, and the approval workflow |
| Look things up                          | `list` (projects, tasks, tags, people, roles, time off types, expense types, work schedules, custom fields, categories), `list_sub_projects`, `get_attributes` and `export` for an entity's settings — including each inherited value and where it comes from                                                                                           |
| Track time                              | `record_time` (one entry or many), `update_time_record`, `copy_time_records` for "same as last week", `delete_time_records`, plus `get_time_records` and `get_timesheet_days` for what is logged and what is missing day by day                                                                                                                         |
| Check time off                          | `get_absence_balance` — the balance per quota, including carry-forward, and the time off types you may book                                                                                                                                                                                                                                             |
| Submit and approve                      | `get_timesheet_status`, `submit_timesheet`, `get_team_timesheets` and `send_timesheet_reminder` for the people you review, `list_pending_approvals`, `get_approval_digest`, `approve_timesheet`, `reject_timesheet`, `get_approval_history`                                                                                                             |
| Propose entries instead of writing them | `push_suggestions`, `get_suggestions`, `accept_suggestions`, `dismiss_suggestions` — drafts you confirm yourself in the app, like Beebole's own [suggested entries](/help/documentation/ai#suggested-time-entries)                                                                                                                                      |
| Handle expenses                         | `get_expense_records`, `record_expense`, `update_expense_record`, `delete_expense_records`                                                                                                                                                                                                                                                              |
| Get figures out                         | `get_reports` and `run_report` — a saved report, an exact report configuration, or a plain-language question — and `get_budget_status` for budget consumption, with the same per-person and per-project splits as the [Budget Status report](/help/documentation/reports#budget-status)                                                                 |
| Work with planning                      | `get_tasks` and `update_tasks` — what is planned, and changing dates, planned time, owner, or status                                                                                                                                                                                                                                                    |
| Set things up                           | `add`, `update_attributes`, `set_custom_field_value`, `assign` and `unassign` for links between entities (project access, managers, tags, schedules, task owners), `get_rates`, `set_rate` and `delete_rate` for the dated billing and cost rate history, `archive`, `unarchive`, `delete`, `invite_persons`                                            |
| See who changed what                    | `get_audit_trail`, when your subscription includes the [audit trail](/help/documentation/audit-trail)                                                                                                                                                                                                                                                   |

So you can ask your assistant things like "log 2 hours on Website Redesign for today", "what did I track this week?", "how much of the Acme budget is left?", or — if you're an approver — "approve the timesheets waiting on me".

Each tool tells your assistant whether it only reads data or changes it, and which changes are destructive, so a well-behaved assistant asks before deleting anything. Everything runs through the same rules as the app: the lock date, entry restrictions, approval status, and your role all apply, and a refusal comes back to the assistant as the reason Beebole gives.

***

## Find your server URL and API key

Everything you need is on the **Assistant** page — click **Assistant** in the sidebar:

* **Server URL** — the address of your Beebole MCP server, with a **Copy** button.
* **API key** — click **Show my API key** to reveal it, then **Copy**. Only needed for developer tools; hosted connectors sign in instead.

***

## Connect a hosted assistant (claude.ai, ChatGPT)

<Steps>
  <Step title="Copy the server URL">
    On the **Assistant** page, copy the **Server URL**.
  </Step>

  <Step title="Add it as a custom connector">
    In claude.ai or ChatGPT, add the URL as a custom connector.
  </Step>

  <Step title="Sign in and authorize">
    You are asked to sign in to Beebole and authorize the access — no API key needed. This is a standard OAuth 2.1 sign-in, so the assistant never sees your credentials and receives an access token it has to refresh. Once authorized, the assistant appears under **Connected apps**.
  </Step>
</Steps>

***

## Connect a developer tool

<Tabs>
  <Tab title="Claude Code">
    Run this command, replacing `YOUR_API_KEY` with your API key and the URL with your **Server URL**:

    ```bash theme={null}
    claude mcp add --transport http beebole https://your-server/mcp --header "apikey: YOUR_API_KEY"
    ```
  </Tab>

  <Tab title="Cursor / Claude Desktop">
    Add this block to the tool's MCP configuration (JSON), replacing the URL and key with yours:

    ```json theme={null}
    {
      "mcpServers": {
        "beebole": {
          "url": "https://your-server/mcp",
          "headers": { "apikey": "YOUR_API_KEY" }
        }
      }
    }
    ```
  </Tab>
</Tabs>

<Warning>
  Your API key gives full access to your Beebole account with your permissions. Keep it out of shared configuration and repositories. If a key leaks, click **Reset** on the **Assistant** page — the old key stops working immediately.
</Warning>

***

## Review and disconnect connections

Assistants you authorized through sign-in appear on the **Assistant** page under **Connected apps**, with the app's name and when it was connected. Click **Disconnect** to revoke a connection — the assistant loses access immediately and must be authorized again to reconnect.

Tools connected with your API key are not listed there; they stop working when you **Reset** the key.

***

## Related content

<CardGroup>
  <Card title="Beebole AI" icon="sparkles" href="/help/documentation/ai">
    Beebole's built-in AI: suggested entries, report builder, and approval review.
  </Card>

  <Card title="Beebole API" icon="code" href="/help/api/introduction">
    Query and mutate your Beebole data programmatically with GraphQL.
  </Card>

  <Card title="Roles & permissions" icon="lock" href="/help/documentation/roles-authorisations">
    What your role allows — and therefore what a connected assistant can do as you.
  </Card>

  <Card title="Webhooks" icon="bolt" href="/help/integrations/webhooks">
    Push Beebole events to external systems in real time.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Which AI assistants work with Beebole?">
    Any assistant that supports the MCP standard. Hosted assistants like claude.ai and ChatGPT connect through a custom connector with a sign-in flow, while developer tools like Claude Code, Claude Desktop, and Cursor connect with your Beebole API key.
  </Accordion>

  <Accordion title="What data can a connected assistant access?">
    Exactly what you can. The connection carries your permissions, so the assistant sees the projects, tasks, and timesheets your role allows — nothing more. It records time on your own timesheet by default, and on someone else's only where your role already lets you do that; it can act on approvals only if you are an approver. There is no separate permission layer for the assistant: Beebole refuses whatever you could not do yourself, and the assistant gets the refusal.
  </Accordion>

  <Accordion title="How do I revoke an assistant's access to Beebole?">
    For hosted assistants, click **Disconnect** next to the app under **Connected apps** on the **Assistant** page. For tools connected with your API key, click **Reset** next to the key — every tool using the old key loses access immediately.
  </Accordion>

  <Accordion title="Do I need an API key to connect claude.ai or ChatGPT?">
    No. Hosted connectors use a sign-in flow: add Beebole's server URL as a custom connector, sign in, and authorize the access. The API key is only for developer tools that can't open a sign-in window.
  </Accordion>
</AccordionGroup>


# Sign in to Beebole with Microsoft — SSO and Sign-In
Source: https://beebole.com/help/integrations/microsoft

Sign in to Beebole with a Microsoft account and require Microsoft sign-in across your organization from the Single Sign-On panel of Account Settings.

Microsoft sign-in lets anyone in your organization sign in to Beebole with their existing Microsoft account, which is convenient for teams already on Microsoft 365. It is a built-in sign-in option — no administrator setup is required to use it. An administrator can also require Microsoft sign-in for the whole organization from the **Single Sign-On** panel.

<Info>
  This page covers the Microsoft-specific controls. For the full picture of how sign-in and single sign-on work in Beebole — email codes, passkeys, and the **Single Sign-On** panel — see [Sign-in, passkeys, SSO, and API keys](/help/documentation/authentication).
</Info>

## Sign in with Microsoft

Microsoft sign-in is always available on the Beebole sign-in screen. Under **Or Sign in with**, click the **Microsoft** button, then authenticate with your Microsoft account. Beebole matches the Microsoft account's email address to your Beebole profile, so both must use the same email address.

Because Microsoft sign-in is built in, you do not need to turn anything on for your team to use it. A person with a matching email address must already exist in your Beebole account before they can sign in with Microsoft.

## Require Microsoft sign-in

<Steps>
  <Step title="Open integration settings">
    Open **Settings** > **Single Sign-On** in your Beebole account, then switch to the **Microsoft** tab.
  </Step>

  <Step title="Enable Microsoft SSO">
    Locate the **Microsoft** card and click **Connect**. Follow the OAuth prompts to authorize Beebole to verify your identity through Microsoft.
  </Step>

  <Step title="Verify the connection">
    Once connected, the Microsoft integration shows as active in your integration settings. Users in your account can now sign in using the **Sign in with Microsoft** button on the login page.
  </Step>
</Steps>

To make Microsoft the only way your team can sign in, go to **Settings** > **Account Settings**, open the **Single Sign-On** panel, and select the **Microsoft** tab. Turn on **Disable interactive sign-in. Only Microsoft sign-in allowed.** to block the email-code method for your organization, so everyone authenticates through Microsoft. The setting saves automatically.

<Warning>
  Before turning on **Disable interactive sign-in. Only Microsoft sign-in allowed.**, confirm Microsoft sign-in works for a test user. If Microsoft sign-in becomes unavailable while enforcement is on, your team is locked out until you turn the toggle back off.
</Warning>

## Related content

<CardGroup>
  <Card title="Sign-in, passkeys, and SSO" icon="key" href="/help/documentation/authentication">
    How every sign-in method works in Beebole, including the Single Sign-On panel and Custom OpenID.
  </Card>

  <Card title="Google sign-in" icon="google" href="/help/integrations/google">
    Sign in to Beebole with a Google account, link your domains, and auto-provision people.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Do I need to set anything up to sign in with Microsoft?">
    No. Microsoft sign-in is a built-in option on the Beebole sign-in screen — click the **Microsoft** button under **Or Sign in with**. No administrator configuration is needed for your team to use it.
  </Accordion>

  <Accordion title="Does Microsoft sign-in create Beebole people automatically?">
    No. A person with a matching email address must already exist in your Beebole account before they can sign in with Microsoft. Microsoft sign-in authenticates existing people; it does not provision new ones.
  </Accordion>

  <Accordion title="What if my Microsoft email is different from my Beebole email?">
    Beebole matches accounts by email address. If your Microsoft email does not match the email on your Beebole profile, Microsoft sign-in will not find your account. Make the two email addresses match, or contact [support@beebole.com](mailto:support@beebole.com).
  </Accordion>

  <Accordion title="Can I make Microsoft the only way my team signs in?">
    Yes. On the **Microsoft** tab of the **Single Sign-On** panel, turn on **Disable interactive sign-in. Only Microsoft sign-in allowed.** This blocks the email-code method so everyone authenticates through Microsoft. Confirm Microsoft sign-in works for a test user first.
  </Accordion>

  <Accordion title="Where do I find the Microsoft settings in Beebole?">
    Go to **Settings** > **Account Settings**, open the **Single Sign-On** panel, and select the **Microsoft** tab. SSO is configured on the organization itself, not as a separate menu item, and the setting saves automatically.
  </Accordion>
</AccordionGroup>


# Microsoft Outlook Calendar Time Tracking
Source: https://beebole.com/help/integrations/microsoft-calendar

Connect Microsoft Calendar to your Beebole timesheet to see your Outlook events for the week and turn them into time entries with a click or a drag.

<Steps>
  <Step title="Open your timesheet">
    Navigate to your **Timesheet** page in Beebole.
  </Step>

  <Step title="Open the calendar panel">
    Click the **Calendar** icon in the timesheet toolbar to open the calendar events panel.
  </Step>

  <Step title="Connect to Microsoft Calendar">
    Click **Connect to Microsoft Calendar**. A popup appears asking you to sign in to your Microsoft account and authorize Beebole to read your calendar events.
  </Step>

  <Step title="Authorize access">
    Follow the Microsoft OAuth prompts to grant Beebole read-only access to your calendar. The popup closes automatically when the connection is complete.
  </Step>

  <Step title="View your events">
    Your Outlook calendar events for the current timesheet period now appear in the calendar panel. You can drag and drop them onto timesheet rows to log time.
  </Step>
</Steps>

Beebole's Microsoft Calendar connection lets you view your Outlook calendar events next to your timesheet and turn them into time entries. It works per user and is read-only — Beebole reads your events for the displayed period and never writes anything back to Microsoft. Use it to log meetings and appointments you already have on your calendar without retyping them.

<Info>
  This connection lives in the timesheet, not under **Settings** > **Integrations**. Each person connects their own calendar, and the connection stays in your browser.
</Info>

## Connect your Microsoft Calendar

Open the calendar pane from your timesheet, then sign in with Microsoft.

<Steps>
  <Step title="Open the calendar pane">
    Open your timesheet and click the calendar icon in the header (tooltip: **Import your calendar events**). The calendar pane opens beside your timesheet.
  </Step>

  <Step title="Sign in with Microsoft">
    Click the Microsoft icon (**Sign in with Microsoft**). A Microsoft window opens at login.microsoftonline.com asking you to choose your account and allow read access to your calendar.
  </Step>

  <Step title="Review your events">
    Once connected, Beebole loads your Outlook calendar events for the period your timesheet is showing, grouped by day. Changing the timesheet period reloads the matching events.
  </Step>
</Steps>

## Log an event as a time entry

The calendar pane shows your events for the displayed week. Assign them to your timesheet by clicking or by dragging.

<Tabs>
  <Tab title="Click to assign">
    Click one or more events to select them — the pane shows the count and the prompt **Click a timesheet row to assign**. Then click the timesheet row you want. Beebole creates a time entry from each selected event. Click **Cancel** to clear the selection.
  </Tab>

  <Tab title="Drag to assign">
    Drag an event from the pane onto a timesheet row. Rows that can accept the event highlight as you hover. Drop it to create the time entry.
  </Tab>
</Tabs>

Events you have already logged show a green **Tracked** badge and are dimmed, so you can tell at a glance what is left to record.

## Disconnect your Microsoft Calendar

In the calendar pane footer, click **Sign out / reset connection**. This clears the stored connection from your browser and removes the events from the pane. Your time entries and your Outlook calendar are not affected.

## Related content

<CardGroup>
  <Card title="Timesheets" icon="clock" href="/help/documentation/timesheets">
    Record, submit, and manage your time entries in Beebole.
  </Card>

  <Card title="Google Calendar" icon="calendar" href="/help/integrations/google-calendar">
    Connect Google Calendar to your timesheet the same way.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Does Beebole change my Outlook calendar?">
    No. Beebole's Microsoft Calendar connection is read-only. It reads your events for the displayed timesheet period to show them in the calendar pane, and never creates, edits, or deletes anything in your Outlook calendar.
  </Accordion>

  <Accordion title="Where do I connect my Microsoft Calendar in Beebole?">
    You connect it from the timesheet, not from **Settings** > **Integrations**. Open the calendar pane with the calendar icon in the timesheet header (**Import your calendar events**), then click **Sign in with Microsoft**.
  </Accordion>

  <Accordion title="Is the connection shared with my team?">
    No. The Microsoft Calendar connection is per user and stays in your own browser. Each person who wants to import calendar events connects their own account.
  </Accordion>

  <Accordion title="What does the Tracked badge mean?">
    The **Tracked** badge marks events you have already logged as time entries for that period. Tracked events are dimmed in the calendar pane so you can focus on the events still to record.
  </Accordion>

  <Accordion title="Which events does Beebole show?">
    Beebole shows your Outlook calendar events for the period your timesheet is currently displaying, grouped by day. When you move to a different week, the pane reloads the events for that period.
  </Accordion>
</AccordionGroup>


# Monday.com integration: import boards and items
Source: https://beebole.com/help/integrations/monday

Connect monday.com to Beebole to import boards and items for time tracking. Automatic sync keeps your monday.com workspace aligned with Beebole projects.

Beebole's monday.com integration imports your monday.com boards, items, and team members into Beebole so your team can track time against their monday.com work. The integration keeps your monday.com workspace and Beebole account in sync automatically — when a board or item is created or renamed in monday.com, the change is reflected in Beebole.

You can import your monday.com structure into Beebole's **Projects and activities** for time tracking with costs, billing, and expenses, or into **Planning and tasks** for resource assignment.

| [monday.com](http://Monday.com) | Projects and activities | Planning and tasks |
| ------------------------------- | ----------------------- | ------------------ |
| Board                           | Project                 | Task               |
| Item                            | Subproject              | Sub-task           |
| Sub-item                        | Sub-subproject          | Sub-sub-task       |

***

## Before you start

<Info>
  You need administrative privileges in both monday.com and Beebole to set up the integration.
</Info>

| What syncs from [monday.com](http://Monday.com)                        | What stays in Beebole                                            |
| ---------------------------------------------------------------------- | ---------------------------------------------------------------- |
| **Boards:** Imported as Beebole projects or tasks.                     | **Approval workflows:** Beebole handles the timesheet lifecycle. |
| **Items and sub-items:** Imported as Beebole subprojects or sub-tasks. | **Billing rates:** Managed exclusively in Beebole.               |
| **Users:** monday.com users are mapped as Beebole people.              | **Budgets:** Set within Beebole's billing and budget settings.   |

***

## What's included

<AccordionGroup>
  <Accordion title="Monday.com boards and items">
    Active boards and items at the time of enabling the integration are created in Beebole. Any name change to those items is reflected in Beebole while the integration is active. New boards and items created in Monday.com are also automatically added to Beebole.

    Sub-items are supported where the board allows them and are imported as a third level beneath items.
  </Accordion>

  <Accordion title="Monday.com users">
    All active non-guest users in your Monday.com workspace are automatically created as people in Beebole when you first enable the integration. You choose a default role for these imported employees during setup.
  </Accordion>

  <Accordion title="Items managed in Beebole">
    Timesheet entries, approval workflows, billing rates, budgets, and expenses remain in Beebole and are not affected by the integration.
  </Accordion>
</AccordionGroup>

***

## Step-by-step configuration

<Steps>
  <Step title="Connect to monday.com">
    Go to **Settings** > **Integrations** > **monday.com**. Click **Connect to monday.com**.

    A popup opens to authorize Beebole to access your monday.com account. Complete the authorization flow. The popup closes automatically when the connection is established.
  </Step>

  <Step title="Configure integration parameters">
    Once connected, configure the following options:

    * **Monday.com workspace** — If your account has multiple workspaces, select the one you want to import.
    * **Where to import your boards** — Choose between **Projects and activities** (for project time tracking with rates and billing) or **Planning and tasks** (for resource planning and assignment).
    * **Default role for imported employees** — Select the role to assign to monday.com users when they are imported into Beebole.

    <Tip>
      You can review and manage existing roles in **Settings** > **Person Roles**.
    </Tip>
  </Step>

  <Step title="Enable the integration">
    Click the toggle to **Enable integration**. Beebole imports all your active monday.com boards, items, and users.

    <Info>
      The initial import may take a few moments depending on the size of your monday.com workspace. You can continue using Beebole while the import runs in the background.
    </Info>

    Once complete, the integration is active. All future name changes and new boards or items in monday.com are automatically reflected in Beebole.
  </Step>

  <Step title="Validate the integration">
    Click **Projects** in the sidebar (or **Tasks**, depending on your import mode). You should see a new category called **Monday** containing all your imported boards and items. You can rename this category if needed.
  </Step>

  <Step title="Configure the timesheet">
    If you want the new Monday category to appear in the timesheet, go to **Settings** > **Account Settings** > **Timesheet settings** > **Categories** and select the Monday category.
  </Step>
</Steps>

***

## Disabling the integration

<Warning>
  If you disable the integration, any future changes made in monday.com will no longer sync to Beebole. Previously imported data remains in Beebole as local records.
</Warning>

To disable the integration, go to **Settings** > **Integrations** > **monday.com** and toggle the integration off. You can re-enable it at any time to resume syncing.

To disconnect your monday.com account entirely, click **Reset connection**.

***

## Related content

<CardGroup>
  <Card title="Projects and activities" icon="folder" href="/help/documentation/projects">
    Manage your projects, subprojects, and billing rates in Beebole.
  </Card>

  <Card title="Planning and tasks" icon="calendar-check" href="/help/documentation/planning">
    Create, organize, and assign tasks, and track time against them.
  </Card>

  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations using the Beebole GraphQL API.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is the difference between Projects and activities and Planning and tasks?">
    Beebole's time management has two structures. **Projects and activities** can be configured with billing rates, costs, budgets, and expenses. **Planning and tasks** is a list of tasks you can assign in resource planning charts. Both can be used in the timesheet to track time. Choose the option that best fits how your organization manages work.
  </Accordion>

  <Accordion title="How often does Beebole sync with monday.com?">
    Changes made in monday.com (new boards, items, or name updates) are reflected in Beebole automatically via webhooks. In most cases, this happens within minutes. If a change is not reflected within 24 hours, contact [support@beebole.com](mailto:support@beebole.com).
  </Accordion>

  <Accordion title="Can I choose which monday.com boards to import?">
    The integration imports all active public boards from the selected workspace. You cannot selectively import individual boards. However, you can organize and filter imported items within Beebole after the import.
  </Accordion>

  <Accordion title="My monday.com account has multiple workspaces. Which one gets imported?">
    During setup, Beebole shows a **monday.com workspace** selector when your account has more than one workspace. Select the workspace you want to import before enabling the integration. Only one workspace can be connected per Beebole account.
  </Accordion>

  <Accordion title="What happens to imported data if I disable the integration?">
    All previously imported boards, items, and people remain in Beebole as local records. They are not deleted. Only future changes from monday.com will stop syncing until you re-enable the integration.
  </Accordion>
</AccordionGroup>


# QuickBooks Online Time Tracking Integration
Source: https://beebole.com/help/integrations/quickbooks

Connect Beebole to QuickBooks Online: import customers, items, and employees into Beebole, then export time entries as QuickBooks time activities in one click.

Beebole's QuickBooks Online integration works in two directions. When you connect it, Beebole imports your QuickBooks structure — customers, items, and employees — so both systems share the same customers, items, and employees. From then on, you can export time entries to QuickBooks as time activities in one click. This simplifies invoicing, payroll, and financial reporting for your organization.

***

## How it works

When you enable the integration, Beebole imports your existing QuickBooks Online data: **Customers** and **Items** are created as projects in Beebole, and QuickBooks **employees** are created as Beebole people — assigned the default role you select during setup, as with the other integrations.

To export, you simply select a period: Beebole takes all time entries for that period and automatically creates the corresponding **time activities** in QuickBooks. After each export, Beebole shows an **Entries successfully exported** count, plus an expandable **Entries not exported** list if any entry failed — you can also verify the created time activities in QuickBooks.

<Info>
  Only time entries are exported to QuickBooks. Expenses are not synced — they are handled in Beebole only.
</Info>

***

## Setting up the QuickBooks integration

<Steps>
  <Step title="Open integration settings">
    Go to **Settings** > **Integrations** in your Beebole account, then select **QuickBooks** from the list.
  </Step>

  <Step title="Connect to QuickBooks">
    Click **Connect to QuickBooks**. A popup appears asking you to sign in to your QuickBooks Online account; follow the Intuit prompts to authorize Beebole. The popup closes automatically when the connection is complete.
  </Step>

  <Step title="Choose the default role">
    Select the **Default role for imported employees** to assign to the people imported from QuickBooks, as with the other integrations.
  </Step>

  <Step title="Enable integration">
    Toggle **Enable integration** on. This triggers the import: Beebole brings in your QuickBooks customers, items, and employees. The toggle is what starts the sync — the connection alone does not import anything.
  </Step>

  <Step title="Verify the connection">
    Once enabled, the QuickBooks integration shows as active in your integration settings, and the imported customers, items, and employees appear in Beebole. You can now export time entries to QuickBooks.
  </Step>
</Steps>

***

## Exporting data to QuickBooks

<Steps>
  <Step title="Open the QuickBooks integration">
    Go to **Settings** > **Integrations** and select **QuickBooks** from the list.
  </Step>

  <Step title="Select a period and export">
    Under **Select period to export**, choose the period you want to export and click **Export** — that's the only input needed. Beebole fetches the time entries for that period and automatically creates the corresponding time activities in QuickBooks.
  </Step>

  <Step title="Check the result">
    Beebole shows an **Entries successfully exported** count, and an expandable **Entries not exported** list if any entry failed. To confirm the export, you can also open QuickBooks and verify the time activities were created.
  </Step>
</Steps>

<Tip>
  Export after the approval cycle is complete for a given period, so the hours sent to QuickBooks are final.
</Tip>

***

## What data is synced

| Direction                        | Data                        | Result                                                                                                                                                      |
| -------------------------------- | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| QuickBooks → Beebole (at setup)  | **Customers** and **Items** | Created as projects in Beebole                                                                                                                              |
| QuickBooks → Beebole (at setup)  | **Employees**               | Created as Beebole people with the default role you select                                                                                                  |
| Beebole → QuickBooks (on export) | **Time entries**            | Created as time activities in QuickBooks, carrying the entry's billing rate, billable or non-billable status, and its comment as the activity's description |

<Info>
  Because Beebole imports the QuickBooks customers, items, and employees at setup, exported time activities stay linked to the right customers, items, and employees automatically — even when the matching customer or item sits at a different level of your Beebole project hierarchy. Expenses are not synced in either direction — they are handled in Beebole only.
</Info>

***

## Keeping customers and items in sync

While the integration is enabled, customers and items created or renamed in QuickBooks are reflected in Beebole automatically. To pull the latest changes on demand, go to **Settings** > **Integrations** > **QuickBooks** and click **Manual sync** under **Manually sync QuickBooks customers and items**.

***

## Disconnecting QuickBooks

To disconnect the QuickBooks integration, go to **Settings** > **Integrations** > **QuickBooks**, toggle **Enable integration** off, then click **Reset connection**. The **Reset connection** button is disabled while the integration is enabled, so you must turn the toggle off first. Previously exported data remains in QuickBooks — disconnecting only removes the ability to send new exports.

Disconnecting from the QuickBooks side works too: if you remove Beebole from your apps in QuickBooks, Beebole is notified and closes the connection cleanly — the integration shows as disconnected the next time you look at it in Beebole.

***

## Related content

<CardGroup>
  <Card title="Costs and billing rates" icon="dollar-sign" href="/help/documentation/costs">
    Configure billing rates and track costs across your projects.
  </Card>

  <Card title="Projects and activities" icon="folder" href="/help/documentation/projects">
    Manage your projects, subprojects, and billing rates in Beebole.
  </Card>

  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build your own integrations using the Beebole GraphQL API.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Is the QuickBooks integration real-time?">
    Customers and services are synced automatically and kept up to date in real time. Time activities are exported manually — you choose the period and trigger the export when ready, giving you full control over what gets sent to QuickBooks.
  </Accordion>

  <Accordion title="Can I export the same date range twice?">
    No. Beebole blocks any export that starts on or before the last day you already exported, so you cannot resend an overlapping period. If you try, Beebole shows the error "You can only export entries from the last day of the period already exported." This prevents duplicate time activities in QuickBooks.
  </Accordion>

  <Accordion title="Does the integration work with QuickBooks Desktop?">
    No. Beebole integrates with QuickBooks Online only. QuickBooks Desktop is not supported.
  </Accordion>

  <Accordion title="How do I know if an export succeeded?">
    After an export, Beebole shows an **Entries successfully exported** count. If any entry failed, an **Entries not exported** list appears that you can expand to see the details. You can also open QuickBooks to verify the time activities were created.
  </Accordion>

  <Accordion title="Are expenses exported to QuickBooks?">
    No. Only time entries are exported, as time activities. Expenses are handled in Beebole only and are not synced to QuickBooks.
  </Accordion>

  <Accordion title="Do I need admin access in both Beebole and QuickBooks?">
    Yes. You need administrative privileges in Beebole to configure the integration, and sufficient permissions in QuickBooks to authorize the connection and receive data.
  </Accordion>
</AccordionGroup>


# Outgoing Webhooks for Real-Time Notifications
Source: https://beebole.com/help/integrations/webhooks

Configure outgoing webhooks in Beebole to receive real-time notifications when data changes. Signed POST requests with HMAC-SHA256 and automatic retry.

Beebole's outgoing webhooks let you subscribe to real-time notifications whenever data changes in your organization. Each webhook delivers a signed POST request to a URL you control, allowing external systems, automations, and integrations to react instantly to changes in Beebole.

You can configure multiple webhooks, each with its own URL, name, secret, and event filter. Beebole signs every payload with HMAC-SHA256 so your endpoint can verify that requests are authentic.

***

## Setting up a webhook

<Steps>
  <Step title="Open the webhook settings">
    Go to **Settings** > **Integrations** > **Webhooks**. Click **Add webhook** to create a new webhook subscription.
  </Step>

  <Step title="Configure the webhook">
    Fill in the following fields for your new webhook:

    * **Name** — A label to identify this webhook (for example, "Slack notifications" or "ERP sync").
    * **URL** — The HTTPS endpoint that will receive POST requests from Beebole.
    * **Secret** — A secret key used to sign the payload. Beebole generates one automatically. You can regenerate it at any time by clicking **Regenerate**.
    * **Enabled** — Toggle whether this webhook is active.
    * **Events** — Choose **All events** to receive every event type, or select individual events from the list.
  </Step>

  <Step title="Save and test">
    Changes are saved automatically as you edit each field. Once the webhook is enabled and your endpoint is ready, trigger an event in Beebole (for example, update a project) and verify that your endpoint receives the request.

    <Tip>
      Use a service like [webhook.site](https://webhook.site) to inspect incoming payloads during development.
    </Tip>
  </Step>
</Steps>

***

## Payload format

Beebole sends a JSON POST request to your endpoint for each matching event. The payload structure is:

```json theme={null}
{
  "event": "projectUpdate",
  "entityIds": ["64a1b2c3d4e5f6a7b8c9d0e1"],
  "deleteIds": [],
  "additionalInfo": null,
  "timestamp": 1712345678,
  "organisationId": "63f9a1b2c3d4e5f6a7b8c9d0"
}
```

| Field            | Description                                                                                   |
| ---------------- | --------------------------------------------------------------------------------------------- |
| `event`          | The name of the event that triggered the webhook (see [Available events](#available-events)). |
| `entityIds`      | Array of entity IDs that were created or updated.                                             |
| `deleteIds`      | Array of entity IDs that were deleted.                                                        |
| `additionalInfo` | Optional extra context provided by some events. `null` when not applicable.                   |
| `timestamp`      | Unix timestamp (seconds) of when the event was emitted.                                       |
| `organisationId` | The Beebole organization ID that the event belongs to.                                        |

***

## Available events

The following event names can be subscribed to individually or via **All events**:

| Event                    | Triggered when                                             |
| ------------------------ | ---------------------------------------------------------- |
| `absenceQuotaUpdate`     | An absence quota is created, updated, or deleted.          |
| `absenceTypeUpdate`      | An absence type is created, updated, or deleted.           |
| `approvalEventUpdate`    | A timesheet approval action occurs.                        |
| `billingUpdate`          | A billing rate is created, updated, or deleted.            |
| `budgetUpdate`           | A budget is created, updated, or deleted.                  |
| `categoryUpdate`         | A category is created, updated, or deleted.                |
| `customFieldUpdate`      | A custom field definition is created, updated, or deleted. |
| `customFieldValueUpdate` | A custom field value is created, updated, or deleted.      |
| `expenseRecordUpdate`    | An expense record is created, updated, or deleted.         |
| `expenseTypeUpdate`      | An expense type is created, updated, or deleted.           |
| `organisationUpdate`     | Organization settings are changed.                         |
| `personUpdate`           | A person is created, updated, or deleted.                  |
| `planningUpdate`         | A planning record is created, updated, or deleted.         |
| `projectCategoryUpdate`  | A project category is created, updated, or deleted.        |
| `projectUpdate`          | A project or subproject is created, updated, or deleted.   |
| `roleUpdate`             | A role is created, updated, or deleted.                    |
| `scheduleTypeUpdate`     | A schedule type is created, updated, or deleted.           |
| `tagCategoryUpdate`      | A tag category is created, updated, or deleted.            |
| `tagUpdate`              | A tag is created, updated, or deleted.                     |
| `taskCategoryUpdate`     | A task category is created, updated, or deleted.           |
| `taskSettingsUpdate`     | Task settings are changed.                                 |
| `taskUpdate`             | A task is created, updated, or deleted.                    |
| `timeRecordUpdate`       | A time record is created, updated, or deleted.             |

***

## Verifying the signature

Every request from Beebole includes an `X-Beebole-Signature` header containing a hex-encoded HMAC-SHA256 signature of the raw request body, prefixed with `sha256=`. Use your webhook's **Secret** to verify this signature before processing the payload.

**Example verification in Node.js:**

```javascript theme={null}
const crypto = require('crypto')

function verifySignature(secret, rawBody, signatureHeader) {
  const expected = 'sha256=' + crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex')
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signatureHeader)
  )
}
```

<Warning>
  Always verify the signature before acting on a webhook payload. Reject any request where the signature does not match.
</Warning>

The request also includes an `X-Beebole-Event` header containing the event name, which is identical to the `event` field in the JSON body.

***

## Retry behavior

If your endpoint returns a non-2xx HTTP status code, or if the connection times out (requests time out after 10 seconds), Beebole automatically retries delivery with the following delays:

| Attempt   | Delay      |
| --------- | ---------- |
| 1st retry | 5 seconds  |
| 2nd retry | 10 seconds |
| 3rd retry | 15 seconds |
| 4th retry | 25 seconds |
| 5th retry | 40 seconds |

After 5 failed attempts, Beebole stops retrying and abandons the delivery. There is no user-visible delivery log in Beebole — failures are recorded only in Beebole's internal server logs. Make sure your endpoint responds within 10 seconds — offload any slow processing to a background queue and return a `200 OK` immediately.

***

## Managing webhooks

* To **edit** a webhook, click to expand its card in the list and update the fields. Changes save automatically.
* To **disable** a webhook temporarily without deleting it, toggle the **Enabled** switch off.
* To **regenerate** the secret (for example, if it has been compromised), click **Regenerate** in the **Secret** field. Update your endpoint with the new secret before re-enabling the webhook.
* To **delete** a webhook, click **Remove** from the webhook card.

***

## Related content

<CardGroup>
  <Card title="Custom integrations" icon="code" href="/help/integrations/custom-integrations">
    Build custom integrations using the Beebole GraphQL API.
  </Card>

  <Card title="API introduction" icon="book" href="/help/api/introduction">
    Explore the full Beebole GraphQL API reference and schema.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

***

## Frequently asked questions

<AccordionGroup>
  <Accordion title="Can I configure multiple webhooks for the same URL?">
    Yes. You can create multiple webhook subscriptions pointing to the same URL, for example to separate event subscriptions with different secrets or names. Each webhook is independent.
  </Accordion>

  <Accordion title="What HTTP method does Beebole use to deliver webhooks?">
    Beebole sends all webhook payloads as HTTP POST requests with a `Content-Type: application/json` header.
  </Accordion>

  <Accordion title="How do I know which entities changed when I receive an event?">
    The `entityIds` array in the payload contains the IDs of entities that were created or updated. The `deleteIds` array contains the IDs of entities that were deleted. Use these IDs to query the Beebole API for the current state of the affected records.
  </Accordion>

  <Accordion title="What happens if my endpoint is down for an extended period?">
    Beebole retries failed deliveries up to 5 times over approximately 95 seconds. If all retries fail, the delivery is abandoned. Events are not queued indefinitely. To avoid missing events during downtime, ensure your endpoint is highly available or implement a polling strategy with the Beebole API as a fallback.
  </Accordion>

  <Accordion title="Can I use webhooks to react to changes made by integrations like Jira or monday.com?">
    Yes. Events triggered by any source — including integrations, the Beebole web app, and the API — will fire webhooks if a matching subscription is active. For example, a `projectUpdate` event fires whether a project is renamed directly in Beebole or via a Monday.com sync.
  </Accordion>
</AccordionGroup>


# Xero Accounting and Invoicing Integration
Source: https://beebole.com/help/integrations/xero

Connect Beebole to Xero to import your Xero contacts and items as projects, keep them in sync, and export tracked time and expenses as Xero invoices.

Beebole's Xero integration brings your Xero accounting structure into Beebole and sends tracked work back as invoices. When you connect it, Beebole imports your Xero contacts and items as projects so both systems share the same structure. From then on, you can resync that structure and export time entries and expenses for a period as a Xero invoice. This streamlines billing for your organization.

<Info>The Xero integration lives under **Settings** > **Integrations**. You connect one Xero account and organization for your Beebole account.</Info>

## How it works

Enabling the Xero integration imports your existing **Xero contacts** and **items** into Beebole as projects. While the integration is active, contacts and items you create or rename in Xero are updated in Beebole automatically.

To bill, you choose a client and a period, and Beebole exports the time entries and expenses for that period as a Xero invoice — time and expenses appear as separate line items. Beebole reports how many lines were created and lists any entries it could not export.

<Info>For people to track time on the imported projects, add the Xero categories in your timesheet settings — Beebole shows this as the next step once the integration is active.</Info>

## Set up the Xero integration

<Steps>
  <Step title="Open integration settings">
    Go to **Settings** > **Integrations** and open the **Xero** integration.
  </Step>

  <Step title="Connect to Xero">
    Click **Connect to Xero**. A popup opens for you to sign in to Xero and authorize Beebole. You need an active Xero account.
  </Step>

  <Step title="Select your organization">
    If your Xero login has more than one organization, Beebole asks you to **Select your Xero organization**. The connected account and organization then appear in the integration panel.
  </Step>

  <Step title="Enable the integration">
    Turn on the **Enable integration** toggle. Beebole imports your Xero contacts and items as projects and keeps them updated from Xero while the integration stays active.
  </Step>
</Steps>

## Sync your Xero structure

Beebole keeps contacts and items in sync automatically once the integration is active. To pull changes on demand, open the **Xero** integration and click **Manual sync** under **Manually sync Xero contacts and items**.

After a sync, Beebole reports the counts for **Created**, **Archived**, **Unarchived**, **Deleted**, and **Renamed**, and lists any entries it could not sync.

## Export an invoice to Xero

<Steps>
  <Step title="Open the Xero integration">
    Go to **Settings** > **Integrations** and open the **Xero** integration. The export options appear once the integration is enabled.
  </Step>

  <Step title="Select the client">
    Under **Export time entries and expenses as a Xero Invoice**, use **Select client** to choose a Xero client.
  </Step>

  <Step title="Select the period and export">
    Choose the period under **Select period to export**, then click **Create invoice**. Beebole sends the time entries and expenses for that period to Xero as a single invoice.
  </Step>

  <Step title="Check the result">
    Beebole reports the number of **Time line items** and **Expense line items** created. If any entries could not be exported, it lists them under **Entries not exported** so you can correct and re-export them.
  </Step>
</Steps>

<Tip>Export after the approval cycle for the period is complete, so the hours and expenses sent to Xero are final.</Tip>

## What data is synced

| Direction                             | Data                       | Result                                          |
| ------------------------------------- | -------------------------- | ----------------------------------------------- |
| Xero → Beebole (at setup and on sync) | **Contacts** and **items** | Imported as projects in Beebole                 |
| Beebole → Xero (on export)            | **Time entries**           | Created as time line items on a Xero invoice    |
| Beebole → Xero (on export)            | **Expenses**               | Created as expense line items on a Xero invoice |

## Disconnect Xero

To disconnect, open the **Xero** integration under **Settings** > **Integrations** and click **Reset connection**. This removes the Xero account connection from Beebole. Invoices already created in Xero are not affected.

## Related content

<CardGroup>
  <Card title="Costs and billing rates" icon="dollar-sign" href="/help/documentation/costs">
    Configure billing rates and track costs across your projects.
  </Card>

  <Card title="Projects and activities" icon="folder" href="/help/documentation/projects">
    Manage your projects, subprojects, and billing rates in Beebole.
  </Card>

  <Card title="QuickBooks Online" icon="book" href="/help/integrations/quickbooks">
    Compare Beebole's other accounting integration.
  </Card>

  <Card title="All integrations" icon="plug" href="/help/integrations/introduction">
    Explore all available Beebole integrations.
  </Card>
</CardGroup>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What does Beebole import from Xero?">
    When you enable the Beebole Xero integration, Beebole imports your Xero contacts and items as projects. While the integration is active, contacts and items created or renamed in Xero are updated in Beebole automatically.
  </Accordion>

  <Accordion title="Is the Xero export real-time?">
    No. Exporting to Xero is a manual step. You choose a client and a period, then click **Create invoice** to send the time entries and expenses for that period to Xero as an invoice.
  </Accordion>

  <Accordion title="Are expenses included in the Xero invoice?">
    Yes. Beebole's Xero export sends both time entries and expenses for the selected period. They appear as separate **Time line items** and **Expense line items** on the Xero invoice.
  </Accordion>

  <Accordion title="How do I resync my Xero contacts and items?">
    Beebole keeps your contacts and items in sync automatically while the integration is active. To refresh on demand, open the **Xero** integration and click **Manual sync**. Beebole then reports what was created, archived, unarchived, deleted, and renamed.
  </Accordion>

  <Accordion title="How do I know if the export succeeded?">
    After an export, Beebole shows the number of time and expense line items it created on the Xero invoice. Any entries it could not export are listed under **Entries not exported** so you can fix and re-export them.
  </Accordion>

  <Accordion title="Why can't my team track time on the imported projects yet?">
    The imported Xero projects belong to Xero categories. For people to track time on them, add those categories in your timesheet settings — Beebole shows this as the next step once the Xero integration is active.
  </Accordion>
</AccordionGroup>


# Product updates: new features and improvements
Source: https://beebole.com/help/news/releases

Stay up to date with new features, improvements, and changes to Beebole. Monthly updates on integrations, reports, workflows, and more.

<Update label="September 2026">
  September adds a **List** view for tasks, lets you run several timers at once, approves a timesheet from a plain email reply, and opens the **Master data review** screen to every administrator.

  ### Planning & staffing

  * New **List** view on the [Planning](/help/documentation/planning) page: a sortable, spreadsheet-like table with the same rows, columns, and grouping as the Gantt. Click a header to sort (row numbers return to the manual order), drag to reorder and resize columns, and edit owner, status, dates, **Planned**, occupation, tags, and project levels in place. Select several rows with ⌘/Ctrl+click or Shift+click and one change applies to all of them as a single undo step.
  * The [Gantt](/help/documentation/gantt) gains the same powers: every cell is editable in place, every column can be sorted and resized, sorting and grouping work together, and ⌘/Shift-click selects rows for mass edits. When a bar is off-screen, an arrow next to its dates jumps straight to it.
  * Draw a dependency by dragging the link handle on a task bar onto another task — hold ⌘ on the drop to chain several links. Dependency lines now route around bars and group headers instead of crossing them.
  * Moving a task that has dependants reschedules them against their owners' real working calendars, and dragging a task keeps its **Planned** hours intact — if the owner's calendar can't absorb the move, the task stays put instead of jumping to a far-off date.
  * Month boundaries are marked with a line and a label across the Gantt and Staffing timelines, and clicking a timeline header cell zooms one level into that period.
  * On [Staffing](/help/documentation/staffing), a booking that covers part of a day is dragged on that day's clock: the hours follow the pointer, snap to the quarter hour, and step over breaks. Once the pointer leaves the cell, the booking moves by whole days.

  ### Timesheets

  * Run several timers at once: ⌘/Ctrl-click any play button to start a timer without stopping the ones already running. The floating timer is now a shelf with one line per activity, a live counter for running ones, a play button to resume paused ones, and a pause-all action. The browser tab shows the elapsed time, or the number of timers when several run.
  * In the [calendar view](/help/documentation/timesheets), clicking an empty slot prefills exactly the time still missing from the day's schedule, holding ⌘ while dragging an entry's edge snaps to whole hours, and an untimed entry dropped on the calendar lands at the time you release it.
  * [Suggestions](/help/documentation/ai) for tasks you're not allowed to book time on are no longer hidden: they appear with the planned task for context, and accepting one asks you to pick the project to record against — the link to the planned task is kept for Planned vs. Real. **Accept all** skips these so you can handle them individually.
  * Time can no longer be logged on a project that has subprojects: parent projects aggregate their children and only the lowest level accepts entries, the same rule that already applied to parent tasks.
  * A period whose last day falls on or before the [lock date](/help/documentation/timesheetSettings) can no longer be submitted for approval, with a clear "This period is locked" message.
  * Automatic submission now submits only the single period whose deadline has passed, and never an empty one — so approvers stop receiving blank weeks.

  ### Approvals & notifications

  * Approve or reject a timesheet by replying to the [approval](/help/documentation/approval) email: reply "approve", or "reject" followed by a reason. Beebole checks that the reply came from you, applies the decision, and emails back a confirmation. The **Approve** and **Reject** buttons in emails now drop you straight onto the timesheet they acted on.
  * In the **Team** pane, **Approve**, **Reject**, and **Remind** on a mixed selection act only on the people they apply to, and strictly on the period on screen.
  * Alerts that fire in bulk — a mass timesheet submit, an import, an automated catch-up — now arrive as a single summary email instead of one message per event. Summary emails list the first few items per category and close with a count of the rest.
  * Changing your approval periodicity no longer re-opens periods that were already approved, so completed timesheets stay approved.

  ### Reports & budgets

  * The **Budget Status** report now filters, sorts, and toggles archived items instantly, project and tag filters apply to the whole hierarchy, the sort you choose applies at every level, split-by-project lines show real actuals for each subproject, and a [budget](/help/documentation/budgets) consumed exactly to 100% counts as on budget.
  * The [AI report builder](/help/documentation/ai) speaks your organization's vocabulary: ask for hours "by client" or "per cost center" and it groups on exactly that level of your project or task hierarchy. Custom field values work as a grouping too, and a request it can't map — such as grouping by a tag-based structure — comes back as a question instead of a wrong report.
  * Project filters (by project, project tag, or project category) now include time logged on tasks linked to those projects, so a project-scoped report no longer misses task time.
  * [Exports](/help/documentation/data-exports) are more robust: PDFs render accented, Cyrillic, Greek, and currency characters correctly, wide tables split across pages with the first column repeated, and Excel column widths fit every row.

  ### Settings & administration

  * The **Master data review** screen is now available to every administrator from the Settings menu: pick people, projects, tasks, tags, or any other configuration entity, build columns by walking into its fields and relations — custom field values included — filter, download, and describe bulk changes in plain language with a before/after preview and undo. Updates can now also add text around existing values ("prefix their external ID with ext-").
  * [Custom fields](/help/documentation/custom-fields) can now be assigned to time-off types, so a time-off entry only asks for the fields that belong to it.
  * Connected [AI assistants](/help/integrations/mcp-server) can do far more: read and set rates and custom field values, manage assignments, record expenses, review the team's timesheets and send reminders, approve or reject submissions, update planning tasks, check budget status, and read the audit trail — always with exactly your permissions.
  * The legacy [migration](/help/guides/migration) tool has left the Settings menu; migrations are now handled by Beebole support on request, and imported history arrives approved and locked at the cut-over date so nothing shows up as pending work.
</Update>

<Update label="August 2026">
  August adds three new reports — **Revenue at Risk**, **Utilization**, and **Timesheet Compliance** — teaches your timesheet to assemble and submit itself from suggestions, makes report folders personal and shareable, gives tasks real start and end times, and turns the calendar into the default timesheet view with a timer you can start from any entry.

  ### Reports

  * New **Revenue at Risk** report: for hourly and daily-billed projects with an end date, see how many budgeted hours will still be unconsumed by that date — converted into a revenue amount, with totals for the amount at risk and the projects behind it. See [Reports](/help/documentation/reports).
  * New **Utilization** report: billable hours as a share of each person's scheduled capacity per month, with capacity net of time off and a projection for next month based on planned bookings.
  * New **Timesheet Compliance** report: a person-by-period grid showing who submitted on time, late, or not at all, with a per-person score, hover details, filtering, and export. Access is a dedicated permission — managers see the people they manage.
  * [Report folders](/help/documentation/reports) are now personal: you see your own folders plus any shared with you, and you can **Share** a folder with specific people or with everyone under a tag. Shared folders are view-only for recipients — the owner keeps full control. A folder also carries its own filters, period, and working-time/time-off scope, applied to every report inside it.
  * The [Planned vs. Real](/help/documentation/reports) report grows up: read it in hours, days, billing, cost, or margin; chart several plans at once; flip between cumulative and remaining (burndown) views with an ideal-burn line and a **Behind / On track / Ahead** pace headline; and a new chart shows time over or under plan per person.
  * Planned vs. Real is now a browsable list: pick a person or project level as the axis, step through people or projects with the arrows or keyboard, and filter with chips that stay in the URL so a filtered view can be shared — the time window and granularity are worked out automatically.
  * The **Budget Status** report reads in the unit its budgets were stated in — hours or days — and its **Billing** and **Costs** views appear only for people allowed to see those amounts, on screen and in exports. **Revenue at Risk** now requires both budget and billing rights.
  * The [AI report builder](/help/documentation/ai) now remembers the conversation — follow-up requests refine the report you just built — and understands chart requests: "show it as a pie", "make it bars", or "hide the graph" restyle the chart without touching the data.

  ### Budgets

  * [Budgets](/help/documentation/budgets) now carry a start date, so a project can hold several budgets over time — each applies from its own date onward. Clear the date and the budget counts from the very beginning of the project, shown as **From the start**.
  * A budget's quantity can be stated in **days** instead of hours, measured against each person's schedule, and can be switched between hours and days after it was created. Every budget can hold a free-text note (purchase order, customer agreement, …) shown on its card.

  ### Planning & staffing

  * Gantt, Kanban, and Staffing views gain a **Filters** button — filter by task, status, owner, assigned person, project, or tags.
  * New capacity finder on the people view: search who's available over a chosen period — including forward-looking ranges like "By year end" — with over-booking flagged directly on the [Staffing](/help/documentation/staffing) timeline.
  * The booking editor now takes allocation as a percent, hours per working day, or total hours, and a booking can be marked **Tentative** — it reserves capacity but stays out of reports until confirmed. Split a booking in two or duplicate it in one click.
  * Dependency links now work fully in Staffing: links are drawn between bars, linked bookings follow the drag live, and you can drag and resize dependent bookings directly.
  * Multi-select on the [Gantt](/help/documentation/gantt) and Staffing timelines: drag several bars together, hold ⌘/Alt to drop dated copies, resize the whole selection at once, or press Delete to remove every selected booking — all undoable in a single step.
  * Lock the Gantt or Staffing view to a fixed window — **Week**, **2 weeks**, **3 weeks**, **4 weeks**, or **6 weeks**, alongside the endless **Infinite by day** and **Infinite by week** — and page through it one period at a time, swiping or scrolling sideways to snap onto the next. **Copy the previous period** now looks back to the last period that actually holds bookings and fills every empty period in between, so a run of unstaffed weeks is filled in one action.
  * Move a booking between rows by dragging it vertically — onto another person to reassign it, onto another project, or onto the unassigned row to clear the owner.
  * Unassigned work is now visible and actionable: an unassigned row in Staffing holds it, and everyone involved gets an email before an unassigned task starts.
  * Tasks can now carry start and end hours, not just dates: uncheck **All day** in a task's date panel to set the exact times, pre-filled from the owner's working hours. Dragging, resizing, splitting, and copying keep the hours, and typing a figure in **Planned in hours** reflows the task to the exact minute the owner's calendar can hold — skipping breaks, days off, and time off, and rolling to the next working day only when the current one runs out.
  * Times that fall outside the owner's working hours are highlighted in the date panel with the reason — the schedule starts later, ends earlier, pauses for a break, or has no hours that day. On [Staffing](/help/documentation/staffing), bars for timed tasks are drawn at their real position inside the day, with non-working stretches hatched behind them, so a booking placed outside working hours is obvious at a glance.
  * A task no longer gets an arbitrary color of its own: it takes the color of its project, owner, or parent task, and shows that same color everywhere — badges, dots, timesheet headers, timers, and mentions.
  * Tasks you own with dates are no longer added to your timesheet as rows automatically. They reach you as suggestion cards instead, and stay listed first when you add a task by hand.
  * New **Plan on non-working days** option in a task's date panel: weekends and holidays count as working days for that task, so it keeps the exact dates you give it — planned hours, the Gantt bar, dependency shifts, and the workload heatmap all follow the task's own calendar.
  * Tags can now be assigned to tasks, and absence types, expense types, and custom fields can be assigned to tags.

  ### Timesheets

  * New Favorites bar on the [calendar view](/help/documentation/timesheets): pin your usual projects, tasks, and time-off types and drop them straight onto the grid. Clicking one creates the entry immediately, using the start time and duration you usually log.
  * New **Auto Timesheet from Planning** settings, and Kanban card moves now fill a day properly — splitting it between tasks finished the same day, with manual entries always winning.
  * The [desktop app's](/help/documentation/desktop-app) activity tracking is now opt-in: nothing is observed until you explicitly turn it on, a plain-language card explains exactly what is read and what stays on your machine, and you can pause or stop tracking anytime from the menu bar icon.
  * Work on several calendar entries as a group: shift-click a range or ⌘-click entries, then move, duplicate, resize, or delete them all in one undoable step.
  * Each time entry now holds exactly one activity — a task, an absence, or projects — so switching an entry's activity replaces the previous one and nothing counts twice in reports.
  * [Suggested time entries](/help/documentation/ai) now come from five sources — browser activity, desktop tracking, tasks planned for you, your recurring habits, and Kanban — with overlapping suggestions merged into a single card and reduced by what you already logged. The Kanban auto-timesheet always proposes suggestions now, never writing entries directly.
  * Every suggestion explains itself: **Why?** shows the planned task's dates and share of your time, how often a habit was seen in recent weeks, or the sites and apps behind a tracked suggestion.
  * Auto-submit now converts pending suggestions into real entries at the deadline and submits them through the normal approval flow — and timesheet reminders announce the deadline in advance ("without action, this timesheet will be submitted automatically in N days").
  * Once a period is fully approved it stays approved: changing the approval workflow, managers, or tags no longer silently reopens it.
  * The [calendar view](/help/documentation/timesheets) now works when start/end times are turned off — entries stack by duration — and your choice of calendar or grid view is remembered on your account.
  * The favorites bar lets you remove any chip — and removals stick. Projects and tasks you used in the previous period carry forward as ready-to-fill rows.
  * The [calendar view](/help/documentation/timesheets) is now the default timesheet view for everyone, with a taller day grid so short entries stay readable and a day that fills its column exactly to the end of your schedule.
  * Start and pause a timer without leaving what you're doing: hover an entry on today's calendar for a play/pause button, or use the one on any favorite chip. A pulsing red dot marks the entry being recorded and its duration ticks up live in place.
  * A play button on today's [suggestions](/help/documentation/ai) — in the side pane, on the calendar ghosts, and in the suggestion popup — accepts the suggestion and keeps the clock running on it in a single, undoable gesture.
  * What you're planned to work on now shows up on future days as read-only forecast cards — a muted, dashed preview that becomes fully actionable once the day arrives. Reopening a past week that's still draft or rejected regenerates its planned suggestions, so staffing added after the fact still appears.
  * Suggestion cards now show the project or task they're about, with its picture and color instead of a generic icon, and calendar entries carry a small ring comparing time logged on a task against its planned hours. Drop a favorite straight onto a suggestion to retarget it to that project or task and accept it in one move.
  * Accepting, editing, or dismissing a suggestion can now be undone — undoing an accept also removes the entries it created.
  * Picking a parent item in a project, task, or tag selector no longer needs ⌘+click: a plain click selects it, and once selected its whole branch is hidden from the list so you can't pick overlapping entries.

  ### Time off

  * Every [time-off allowance](/help/documentation/timeoff) field — available, accrued, carry-forward limit, and consumed — now states its own unit, days or hours, in the input and in the card summary, so hour-based and day-based allowances can no longer be confused. **Available**, **Consumed**, and **Accrued** sit at the top of the card, right after the time-off type.

  ### Integrations & apps

  * The [AI page](/help/documentation/ai) now walks you through connecting an assistant step by step — hosted assistants (claude.ai, ChatGPT) sign in directly with no API key; local ones (Claude Code, Claude Desktop, Cursor) use your API key — and lists everything a connected assistant can do. Assistants can also look up your organization's own category names, so they speak your vocabulary.
  * Signing in to the [desktop app](/help/documentation/desktop-app) now hands off to your browser and comes back signed in, so passkey and SSO logins work there.
  * [Asana](/help/integrations/asana) sync is steadier: deleting a project or task that already has time logged archives it instead of failing, repeated deliveries no longer create duplicate projects and tasks, tasks moved between projects keep syncing, rate limits are retried rather than breaking the sync, and turning the integration on or off no longer leaves the switch stuck on "updating".

  ### Settings & permissions

  * Role targets are reorganized: the old "my" scope is split into what you *manage* versus your *colleagues*, and task access separates tasks you own from tasks you manage. Existing roles migrate automatically. See [Roles](/help/documentation/roles-authorisations).
  * Timesheet settings are now **Timesheet and Planning Settings**, and task categories are called **Plannings** throughout the app.
  * A new [time restriction](/help/documentation/timesheetSettings) keeps start and end times inside the day's scheduled hours — as a warning or a hard block.
  * New timesheet rule: **Only an admin can edit someone else's timesheet**.
  * Managers and approvers can now open and edit a team member's timesheet directly from the **Approval** and **Team** panes — the edit pencil is no longer admin-only. Who may edit at each approval stage still applies: a timesheet locks once approved, and the rule above still wins when it is switched on.
  * A [public holiday](/help/documentation/public-holidays) calendar's country can now be changed freely — it is no longer locked once loaded.
</Update>

<Update label="July 2026">
  July brings three new ways to plan and track your time: a drag-and-drop **Calendar view** for your timesheet, time entries suggested automatically from your activity, and a new **Staffing** view for resource planning. You can now also connect AI assistants like Claude and ChatGPT to your Beebole data.

  ### Planning

  * New [Staffing view](/help/documentation/staffing) for tasks, alongside the Gantt and Kanban: drag on a long-horizon timeline to book people onto projects, set each booking's allocation percentage, and see everyone's workload and remaining capacity at a glance — grouped by people or by project, filterable by tag.
  * A booking no longer needs a name: assign a person to a project for a date range, and Beebole names it automatically from the two.
  * Gantt and Staffing timelines can now scroll into the past, switch **Planned** figures between hours and days, and auto-scroll when you drag a bar to the edge of the screen.

  ### Timesheets

  * New [Calendar view](/help/documentation/timesheets) for your timesheet: a day-by-hour grid where you drag and resize entries to set start and end times. Hold ⌘ while dragging to duplicate an entry, or hover over one to delete it.
  * Beebole now [suggests time entries automatically](/help/documentation/ai) — from your computer activity (via the new [desktop app](/help/documentation/desktop-app) and [browser extension](/help/documentation/browser-extension)), from Kanban cards moved to a done column, and from recurring patterns. Accept, edit, or dismiss each suggestion from a tray.
  * Each timesheet section now has its own **Clear rows** button that removes just that section's rows for the current period — and you can undo it with Ctrl+Z.
  * Public holidays no longer count toward required hours, so timesheets aren't flagged as under-time for them.
  * New [time restriction](/help/documentation/timesheetSettings) for admins: only allow time entries within the working hours defined in the schedule.

  ### Reports & budgets

  * [Build a report from a plain-language question](/help/documentation/ai) — describe what you want and get the report back.
  * A redesigned [reports experience on mobile](/help/documentation/mobile): pick a folder, change the period, and read each report from your phone.
  * New drill-down detail sheets on the **Budget Status** and **Absence Quotas** reports — tap into a single project or person for the breakdown.
  * Budget alerts gained a burn-rate forecast that warns when current spending is on track to exceed a budget. The alert settings are not available in the app, so [Budget Status](/help/documentation/reports#budget-status) remains the place where budget trouble surfaces.
  * Reports and report folders with no saved period now default to the current month instead of pulling in every record ever logged.

  ### Integrations & apps

  * Connect AI assistants such as **Claude and ChatGPT** to your Beebole data through the new [MCP server](/help/integrations/mcp-server), and review or disconnect them anytime from the **Connected apps** list.
  * Download the [desktop app](/help/documentation/desktop-app) (macOS, Windows, Linux) and [browser extension](/help/documentation/browser-extension) (Chrome/Edge, Firefox) directly from **Connected apps**, with step-by-step install instructions.
  * The [monday.com integration](/help/integrations/monday) is now available to everyone.
  * The [import from a legacy Beebole account](/help/documentation/legacy-migration) is now granular: choose exactly which data to bring over — people, projects, tags, schedules, budgets, time records, and more — with live counts shown before you start.

  ### Notifications

  * Approvers now receive an approval digest summarizing timesheets awaiting their review, including a flag for days with significant after-hours time.
  * Timesheet summary emails now show the full project and task path, making entries easier to identify.
  * Notifications are only sent to people who actually belong to your organization — archived people and expired invitations no longer receive them.
</Update>

<Update label="June 2026">
  Beebole is now available in ten languages, admins get precise control over how time is logged, and unused time off can carry forward into the next period.

  ### Now in ten languages

  * The app is fully available in nine more languages alongside English: Czech, German, Spanish, French, Hungarian, Italian, Dutch, Polish, and Portuguese.

  ### Timesheets & approvals

  * New organization-wide [time restrictions](/help/documentation/timesheetSettings) let admins govern how time is logged: keep entries within a project's or person's validity dates, block future-dated entries, require a comment on submission, cap or require hours against the schedule, allow time only on working days, limit time off to the available quota, and keep absences to a single day.
  * Time records can now be locked by approval state and role — for example, preventing edits once a timesheet has been submitted or approved.
  * New **Lock date** that freezes all time records on or before a chosen day — no one can create, edit, move, or delete them, admins included. Set it organization-wide or per person, team, or project.
  * [Approval](/help/documentation/approval) improvements for managers: a sticky action bar with always-visible **Approve** and **Reject** buttons, accurate per-person and per-period totals, and drill-down into project and task breakdowns.

  ### Time off

  * Unused absence allowance now carries forward into the next period, limited by a cap you choose, and each allowance shows how much has been consumed — accurately, even when allowances overlap. See [Time off](/help/documentation/timeoff).
  * Time off type pickers now show only the types each person is actually allowed to use — including when a manager logs time off on someone's behalf.
  * [Public holiday](/help/documentation/public-holidays) calendars now cover past years as well as upcoming ones, can be loaded for a specific year, and keep your custom changes when reloading.

  ### Reports

  * Report columns can now be reordered, marked as subtotals, and hidden when empty — and subtotals stay correctly scoped within their group. See [Custom reports](/help/documentation/custom-reports).
  * New columns and filters: hourly and daily billing and cost rates, markup percentage, time-entry comments as a column, and filtering by project or task category (including "is not" exclusions). Matrix reports can swap rows and columns.
  * New [Excel add-in](/help/documentation/excel-addin): open Beebole reports directly in Excel and refresh the data with one click. Both the Excel and [Google Sheets](/help/documentation/gsheets-addon) add-ins now offer many more report columns and let you pick your data region (Europe or America).
  * Report folders gain an "Absence / working time" scope that switches every report in the folder between working time and time off in one place.

  ### Access & security

  * You can now [sign in with a passkey](/help/documentation/authentication).
  * [Authorizations](/help/documentation/roles-authorisations) now support separate view and edit permissions with a search box, plus new granular permissions controlling who can assign managers, tasks, schedules, time off, expenses, custom fields, and tags.
  * The "People manager" role has been renamed to **Team lead**.

  ### Other improvements

  * Projects and people can now have a validity period (start and end dates).
  * [Inviting people](/help/documentation/people) now sends invitations in bulk, with a clear summary of how many were sent, already in the organization, or missing an email address.
  * The [QuickBooks export](/help/integrations/quickbooks) now sends each entry's billing rate and billable status, includes the comment as the description, and matches customers and items correctly at any level of the project hierarchy.
</Update>

<Update label="June 2026">
  ## Welcome to the new Beebole

  After many months — really, years — of work, the new Beebole is here. We rebuilt the app from the ground up: faster, more flexible, and shaped around how teams track time today. This first note is a heartfelt thank-you to everyone who helped us get here, and a quick look at what's waiting for you.

  **If you've been with us a while:** your existing account keeps running exactly as it is — nothing disappears, and there's no deadline to move. When you're ready, your data comes across in one guided step. The full story, feature by feature, lives in the [Migration guide](/help/guides/migration).

  **New to Beebole?** The [Quickstart](/help/documentation/quickstart) takes you from sign-up to your first report in six steps.

  ### A few things we're proud of

  * **Time tracking that bends to your rhythm** — configurable timesheet periods, entry in hours, days, or percent, work-from-home and non-billable flags, and your calendar dragged straight onto the timesheet.
  * **Planning that's actually planning** — tasks are first-class now, with a Kanban board, a Gantt timeline, dependencies, and workload at a glance.
  * **Approvals, your way** — multi-stage workflows, approve or reject right from an email or your phone, and a full history on every timesheet.
  * **Sharper insight** — custom fields across projects, people, tasks, and time; project expenses; and richer reports.
  * **Connected** — Jira, Asana, and Linear integrations, Google and Microsoft calendars, and a modern [GraphQL API](/help/api/introduction).

  This is just the beginning — we'll keep shipping, and this is where you'll hear about it first. Thank you for being part of the journey, and tell us what you think at [support@beebole.com](mailto:support@beebole.com).
</Update>