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

# Firmwater LMS API

Jentic publishes the only available OpenAPI specification for Firmwater LMS API, keeping it validated and agent-ready. Firmwater LMS is a multi-tenant learning management system aimed at training providers and reseller channels. The 80-endpoint v2 API gives full programmatic control over courses, learning paths, departments, job titles, locations, orders, products, roles, sites, users, and webhooks. Endpoints are scoped per client via a path-level {clientId} placeholder, making it suitable for white-label training portals and channel-partner enablement workflows.

## For AI agents

Manage courses, learners, learning paths, orders, and webhooks on a Firmwater LMS tenant - 80 endpoints scoped per client for white-label training operations.

## Scope

Does not handle content authoring, SCORM packaging, or live virtual classrooms - use for course catalogue, learner, learning path, and order management only.

## Capabilities

- List, create, and update courses and course types within a client tenant
- Build and assign learning paths combining multiple courses for role-specific training
- Manage user records, departments, job titles, and locations across the org structure
- Place and inspect orders for training products and seat allocations via /orders.json
- Register and manage webhooks at /webhooks.json for real-time notifications on enrolment and completion events
- Manage child sites and roles for resold training portals under a parent client

## Use cases

### White-Label Training Portal

Operate a multi-tenant training portal where each reseller has its own client/site under a parent. Manage sites via /sites.json, scope roles, and provision users at the right level. The path-level {clientId} keeps tenant isolation explicit, well-suited to channel-partner enablement.

Example prompt: POST /sites.json to create a new reseller site, then create roles via /roles.json and provision the reseller admin user via /users.json

### Automated Onboarding Paths

Build role-based learning paths via /learning-paths.json, attach the relevant courses, and assign them to new hires automatically when they appear in /users.json. Webhooks at /webhooks.json fire on completion events so HR systems can update employee records without polling.

Example prompt: Create a learning path via POST /learning-paths.json with the three onboarding courses, then assign it to every user where job_title='Account Executive'

### Compliance Reporting

Pull participant lists per course via /courses/participants.json, count progress, and generate compliance reports per department or job title. Useful for regulated industries that need audit-ready training records. The count endpoints (e.g. /courses/count.json) make pagination predictable.

Example prompt: GET /courses/participants.json filtered by course_id=88231, then summarise completion rate by department

### AI Agent Training Operations

Use Firmwater through Jentic so an enablement agent can enrol learners, build paths, or pull progress without learning the 80-endpoint surface. Jentic exposes the operations as discoverable tools, with the API key in the vault. Get started with Jentic One, the self-hosted execution layer

Example prompt: Through Jentic, search 'enrol a user in a course', load the relevant Firmwater schema, and execute with userId and courseId

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | /courses.json | List courses |
| GET | /courses/participants.json | List course participants |
| POST | /learning-paths.json | Create a learning path |
| PUT | /learning-paths/{id}.json | Update a learning path |
| POST | /departments.json | Create a department |
| POST | /job-titles.json | Create a job title |
| POST | /webhooks.json | Register a webhook subscription |

## Key resources

- **Courses** — Course catalogue, types, tags, and participants
- **Learning Paths** — Sequenced course bundles for role or job-title-based training
- **Users** — Learners and admins, scoped to client and site
- **Departments** — Departmental structure for grouping learners
- **Job Titles** — Roles that drive default learning paths
- **Orders** — Training product orders and seat allocations
- **Sites** — Tenant sites for white-label resold training
- **Webhooks** — Event subscriptions for enrolment and completion

## Why Jentic

- **Setup:** Wiring the Firmwater LMS API by hand means setting its Authorization header, threading the tenant clientId into the base path, and spreading calls across 80 course, learner, and order endpoints with your own retries. Through Jentic you install once, import Firmwater from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Firmwater keys the tenant through the clientId in the base path and otherwise carries targets in request bodies, so limit the agent to the operations it needs, such as enrolling a learner or creating a learning path, and leave the rest out of the allowed set. You choose which of the 80 operations it may call.
- **Credential handling:** Your Firmwater key is stored once, encrypted, by your own Jentic One instance and injected into the Authorization header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'enrol a user' or 'create a learning path', and Jentic returns the matching Firmwater operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Fireflies.ai GraphQL API** — Generates training material from sales-call transcripts to feed into Firmwater courses
- **Firebase Auth REST API** — Authenticates learners in a custom front-end that delegates training to Firmwater
- **Fitbit Web API** — Different domain - health and activity tracking rather than training

## FAQ

### Why is there no official OpenAPI spec for Firmwater LMS API?

Firmwater publishes reference documentation but no OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Firmwater LMS 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 Firmwater LMS API use?

The API uses an API key passed in the `Authorization` header on every request, scoped per client via the {clientId} path prefix. Through Jentic, the key is stored encrypted and injected at execution time.

### Can I create learning paths with the Firmwater LMS API?

Yes. POST /learning-paths.json creates a learning path; PUT /learning-paths/{id}.json updates it. Each path bundles courses for role- or job-title-based assignment.

### What are the rate limits for the Firmwater LMS API?

Firmwater applies per-client rate limits and returns standard 429 responses when exceeded. Specific quotas depend on your contract; Jentic surfaces 429s to the agent for back-off handling.

### How do I enrol a user through Jentic?

Search Jentic for 'enrol a user in a course', load the matching Firmwater schema, and execute with the user and course identifiers. The structured response confirms enrolment and includes the participant record.

### Does the Firmwater LMS API support webhooks?

Yes. POST /webhooks.json registers a webhook subscription, and the API delivers enrolment and completion events to your endpoint, removing the need to poll /courses/participants.json.

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

Yes. Because you run Jentic One yourself, your own rules decide which of the 80 Firmwater operations the agent may call and which credentials it may use. You can allow just the operations it needs, such as enrolling a learner or creating a learning path via POST /learning-paths.json, and leave the rest out of the allowed set. Since Firmwater keys the tenant through the clientId in the base path and carries targets in request bodies, scoping the operation list is how you control what the agent can reach.