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

# Keltehue

Keltehue is an organisational information system that keeps teams informed from operational tasks up through strategic notes. The public REST API exposes six endpoints across authentication, profile, notes, and tasks. After exchanging credentials at `/Auth/Login` for a bearer token, clients can read and create tasks, retrieve a single task by ID, list notes, and read the current user's profile. The surface is small and oriented toward task and note synchronisation rather than full project planning.

## For AI agents

Authenticate against Keltehue, then read and create tasks, list notes, and fetch the current user's profile through six bearer-authenticated REST endpoints.

## Scope

Does not handle projects, dependencies, time tracking, or note creation - use for Keltehue task list, single-task reads, and note listing only.

## Capabilities

- Exchange username and password at `/Auth/Login` for a bearer token
- List the tasks visible to the authenticated Keltehue user
- Create a new task in Keltehue with the POST `/api/task` endpoint
- Fetch a single task by ID for downstream display or processing
- List the notes the authenticated user has access to
- Read the current user's profile to confirm identity and scope

## Use cases

### Task Synchronisation with External Tools

Keep tasks consistent between Keltehue and a primary task tracker such as Asana or ClickUp by listing Keltehue tasks on a schedule and writing matching items into the external tool. The `/api/task` endpoints support both list and create flows, and `/api/task/{id}` provides a single-record read for delta checks. A daily cron-driven sync ships in well under a day.

Example prompt: GET `/api/task` to list Keltehue tasks, then POST each new task into the external task tracker using its task-create endpoint

### Note Aggregation Dashboard

Aggregate notes from Keltehue into a knowledge dashboard or search index by listing notes through GET `/api/note.` Notes can then be indexed alongside content from other sources to produce a unified search experience. The bearer token issued at `/Auth/Login` is valid for the duration of the session and is reused across both note and task reads.

Example prompt: POST `/Auth/Login` to obtain a bearer, then GET `/api/note` and write the response into a search index

### AI Agent Task Capture

An AI agent that captures action items during meetings calls Keltehue's task-create endpoint via Jentic to push each action item into the user's Keltehue task list. The agent searches Jentic by intent ('create a task in keltehue'), loads the schema, and submits the task title and metadata in a single execute call. The bearer token is held in Jentic's vault and refreshed on the agent's behalf.

Example prompt: Use Jentic to execute POST `/api/task` with a title extracted from the meeting transcript and the user's bearer token injected automatically

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/Auth/Login` | Exchange credentials for a bearer token |
| GET | `/api/me` | Read the current user's profile |
| GET | `/api/task` | List tasks visible to the user |
| POST | `/api/task` | Create a new task |
| GET | `/api/task/{id}` | Read a single task by ID |
| GET | `/api/note` | List notes the user can access |

## Key resources

- **Authentication** — Exchange username and password for a bearer token at `/Auth/Login`
- **Tasks** — List, create, and read individual Keltehue tasks
- **Notes** — List notes accessible to the authenticated user
- **Profile** — Read the authenticated user's profile via `/api/me`

## Why Jentic

- **Setup:** Wiring Keltehue by hand means posting credentials to `/Auth/Login`, holding the returned bearer across calls to www.api.keltehue.com, and mapping task and note reads to their shapes yourself. Through Jentic you install once, import Keltehue from the API Directory, store the login credential once, and your agent calls it.
- **Permission scoping:** Keltehue exposes a small set of task and note operations, so scope the agent by the ones it needs, such as listing tasks and reading a single task. You pick that set, so task creation is not included unless you add it.
- **Credential handling:** Your Keltehue username and password are stored once, encrypted, by your own Jentic One instance and injected at execution time. Jentic exchanges them at login and reuses the bearer, so neither the password nor the token ever enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list my Keltehue tasks' or 'create a task', and Jentic returns the matching Keltehue operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **Asana** — Asana is a full project and task management platform with significantly broader capabilities than Keltehue's six-endpoint surface.
- **ClickUp** — ClickUp is a task and document platform with a broad public API covering tasks, lists, docs, and goals.
- **HubSpot** — HubSpot can hold the customer or deal records that Keltehue tasks are attached to.

## FAQ

### What authentication does the Keltehue API use?

POST username and password to `/Auth/Login` to exchange credentials for a bearer token, then send the token in the Authorization header on every subsequent request. Through Jentic, the username and password are held in the encrypted vault and the bearer token is minted and refreshed for the agent automatically.

### Can I create a task with the Keltehue API?

Yes. POST `/api/task` with the task title and any required metadata creates a new task in the authenticated user's Keltehue account. After creation, GET `/api/task/{id}` returns the full record so you can confirm the create succeeded.

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

The OpenAPI spec does not declare numeric rate limits. With only six endpoints the surface is small, so most callers stay well within whatever limits Keltehue applies at the platform level. If you receive HTTP 429, back off and retry.

### How do I list my Keltehue tasks through Jentic?

Search Jentic for 'list tasks in keltehue' to find GET `/api/task`, load its schema, and execute it. Jentic injects the bearer token automatically. The standard flow is pip install jentic, then client.search, client.load, and client.execute.

### Does the Keltehue API expose notes?

Yes, but only as a list read. GET `/api/note` returns the notes the authenticated user can see; the public spec does not expose a note-create or note-update endpoint, so writes must happen through the Keltehue UI.

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

Yes. Because Jentic One is self-hosted, you set the rules that decide which Keltehue operations your agent can call and which credentials it uses. You can grant only the reads it needs, such as GET `/api/task` to list tasks and GET `/api/task/{id}` to fetch one, and leave out POST `/api/task` so the agent cannot create tasks. Your Keltehue login is stored and injected at execution time, so the agent only exercises the operations you allow.
