canonical: https://jentic.com/apis/beebole.com/beebole

# Beebole API

Jentic publishes the only available OpenAPI specification for Beebole API, keeping it validated and agent-ready. Beebole is a project time tracking platform used by services firms, agencies, and consultancies to log billable hours, manage projects and subprojects, track absences, and run timesheet approval workflows. The API exposes 57 POST operations grouped by domain (time entries, projects, people, companies, tasks, absences, groups), each endpoint following a verb path like `/time_entry/create` or `/project/list`, secured by HTTP Basic auth using the account's API token as the username.

## For AI agents

Log billable time, manage projects and subprojects, track absences, and run timesheet submit-approve-lock workflows through Beebole's 57 time-tracking endpoints.

## Scope

Does not handle invoicing, payroll disbursement, or expense receipts - use for project time tracking, timesheet approval, project and people management, and absences only.

## Capabilities

- Log a time entry against a person, project, subproject, and task with hours and a date
- Submit a person's timesheet for approval, then approve, reject, or lock it
- Create projects and subprojects with billable status, currency, and budget settings
- Maintain the people roster with activate and deactivate operations rather than hard delete
- Record absences such as vacation or sick leave against approved policies
- Build group hierarchies and read group trees for org-wide reporting
- Export time entries for billing reconciliation or BI ingest

## Use cases

### Weekly timesheet submission and approval

Services firms run a weekly cycle where staff log hours, submit for approval, and managers approve or reject before the timesheet is locked for billing. Beebole exposes `/time_entry/create` for logging, `/time_entry/submit`, `/time_entry/approve`, `/time_entry/reject`, and `/time_entry/lock` to drive the cycle programmatically. Approved and locked entries can then be pulled via `/time_entry/export` for invoicing.

Example prompt: Submit person 1124's timesheet for week ending 2026-06-08 and then approve all pending entries on projects flagged client_billable

### Project and budget setup at kickoff

Agencies and consultancies create a project record at kickoff with billable rate, currency, budget, and team assignment so time logged against it can be reported against scope. The API's `/project/create`, `/subproject/create`, `/task/create`, and /group operations let an integration provision the project tree from a CRM-won deal in one batch, ready for staff to log hours.

Example prompt: Create a project Q3 Migration billed in EUR with a 200-hour budget, three subprojects Discovery, Build, and Cutover, and the engineering group assigned

### Absence and capacity tracking

HR and operations track vacation, sick, and other absence types alongside billable time so capacity planning reflects who is actually available. `/absence/create` logs an absence against a person and date range, `/absence/list` reports across the team, and the activate and deactivate flags let admins retire policies without losing historical records.

Example prompt: Record a vacation absence for person 5512 from 2026-07-14 to 2026-07-18 and confirm it does not overlap an existing absence

### AI agent integration for time-tracking workflows

Operations leads use AI agents through Jentic to handle nudge-and-approve workflows: remind staff to submit timesheets, auto-approve recurring entries, and pull weekly reports for billing. The agent searches Jentic for the right Beebole operation, loads the schema, and executes with the API token held in your Jentic One instance, so the token never enters the agent transcript.

Example prompt: Through Jentic, find Beebole's time entry list operation and return all unsubmitted entries from last week so the agent can nudge each person to submit

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/time_entry/create` | Log a time entry |
| POST | `/time_entry/submit` | Submit a person's timesheet |
| POST | `/time_entry/approve` | Approve submitted time entries |
| POST | `/time_entry/lock` | Lock approved time entries for billing |
| POST | `/time_entry/export` | Export time entries for invoicing |
| POST | `/project/create` | Create a project |
| POST | `/person/create` | Create a person |
| POST | `/absence/create` | Record an absence |

## Key resources

- **Time Entry** — Create, submit, approve, reject, lock, unlock, and export logged hours
- **Project** — Create, update, list, activate, and deactivate billable and internal projects
- **Subproject** — Subdivide projects for finer reporting and budget control
- **Task** — Tasks logged-against within a project or subproject
- **Person** — Staff and contractor records with activate and deactivate flags
- **Company** — Client company records linked to billable projects
- **Absence** — Vacation, sick, and other absences with approval state
- **Group** — Hierarchical team groupings used for filtering and reporting

## Why Jentic

- **Setup:** Wiring the Beebole API by hand means building the HTTP Basic header with your token as the username and x as the password, and posting to each RPC-style time_entry, project, and person endpoint yourself. Through Jentic you install once, import the Beebole API from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** Beebole uses RPC-style endpoints that take their targets in the request body rather than as a resource in the URL path, so scope the agent to the operations it needs, such as creating or submitting a time entry. You choose that operation set, so approving, locking, or exporting time entries are not included unless you add them.
- **Credential handling:** Your Beebole API token is stored once, encrypted, by your own Jentic One instance and used to build the Basic Authorization header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'log a time entry' or 'submit my timesheet', and Jentic returns the matching Beebole operation with its input schema so the agent calls `/time_entry/create` or `/time_entry/submit` without browsing the reference docs.

## Related APIs

- **Toggl** — Time tracking with a lighter solo and small-team footprint than Beebole's approval-and-lock workflow.
- **Clockify** — Time tracking platform with a free tier and broader integrations than Beebole.
- **ClickUp** — Project and task management often paired with a dedicated time-tracker for billable hours.

## FAQ

### Why is there no official OpenAPI spec for Beebole API?

Beebole does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Beebole API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Beebole API use?

Beebole uses HTTP Basic authentication where the API token is sent as the username and the literal string x as the password. Jentic stores the token in its vault and constructs the Authorization header at execution time so the token never appears in agent context.

### Can I run a timesheet approval workflow with the Beebole API?

Yes. The /time_entry resource exposes submit, approve, reject, lock, and unlock operations alongside create. A typical flow is `/time_entry/create` over the week, `/time_entry/submit` on Friday, `/time_entry/approve` by the manager, then `/time_entry/lock` once payroll has been run.

### How do I export approved time entries for billing through Jentic?

Search Jentic for export Beebole time entries to find POST `/time_entry/export.` Load the schema and execute with a date range, person or project filters, and the desired export format. The response can be piped into the agent's invoice generator or a BI ingest job.

### Does the Beebole API support absence and vacation tracking?

Yes. POST `/absence/create` records an absence against a person and date range. The `/absence/list`, `/absence/activate`, and `/absence/deactivate` operations let an integration manage absence policies and read aggregate availability without hard-deleting historical records.

### Why does the Beebole API use POST for read operations like list?

Beebole's API design uses POST with a JSON body for every operation, including reads. Filters and pagination parameters are sent in the request body rather than the query string, which keeps complex filter shapes typed but means tools that expect GET-for-read need adapter logic. Jentic's schema-driven execution handles this transparently.

### What are the rate limits for the Beebole API?

Beebole does not publish explicit rate limits in the spec. Production integrations should back off on HTTP 429 responses with exponential delay and contact Beebole support to confirm headroom for high-volume export or sync jobs.

### Can I limit what my agent is allowed to do with the Beebole API?

Yes. Because you run Jentic One yourself, you decide which Beebole operations your agent may call, and Beebole's RPC-style endpoints take their targets in the request body, so you scope by the specific operations you grant. For example, you can allow only creating and submitting a time entry with `/time_entry/create` and `/time_entry/submit`, so approving, locking, or exporting entries stay out of reach unless you add `/time_entry/approve`, `/time_entry/lock`, or `/time_entry/export.` Your stored API token is attached at execution time under your own rules, so the agent can only exercise the operations you have permitted.