canonical: https://jentic.com/apis/featurewatch.readme.io/featurewatch

# Featurewatch Readme Feature Watch API

Jentic publishes the only available OpenAPI specification for Feature Watch API, keeping it validated and agent-ready. Feature Watch is a feedback and feature-tracking tool that organises product ideas into boards, attaches comments and likes, and pushes status updates via webhooks. The API exposes 17 endpoints covering authentication, board and feature CRUD, comments, likes, and webhook management so a product team can mirror its feedback workflow into other systems or have agents file feedback automatically.

## For AI agents

Authenticate, manage boards and features, and read comments and likes from a Feature Watch workspace.

## Scope

Does not handle billing, customer support tickets, or roadmap planning views - use for Feature Watch board, feature, and webhook operations only.

## Capabilities

- Authenticate via /login and inspect the current user via /me
- List boards and the features attached to a specific board
- Create and retrieve features programmatically
- Pull comments, likes, and current state metadata for triage
- Manage webhooks that broadcast feature activity to other systems

## Use cases

### Centralised Feedback Triage

Product managers use Feature Watch to centralise feature requests submitted by support, sales, and customers. Calling GET /boards and GET `/board/{id}/features` lets a triage tool surface this week's new requests grouped by board, while GET /comments and GET /likes expose qualitative and quantitative signal so the PM can prioritise without clicking through the UI.

Example prompt: List boards via GET /boards, then for each board call GET `/board/{id}/features` and aggregate counts of likes and comments for the week.

### Agent-Filed Feature Requests

Customer-facing agents pick up feature requests in chat and need to file them in Feature Watch without leaving context. POST /features (or POST /add_feature) accepts a title and description so the agent can record the request and respond to the customer with a tracking link.

Example prompt: Call POST /features with the feature title, description, and board ID drawn from the customer conversation context.

### Webhook-Driven Roadmap Notifications

When a feature changes state, downstream systems need to know. Feature Watch's webhooks endpoints let a workflow register a URL that fires on activity, so a release-notes service or Slack notifier can react to status changes without polling.

Example prompt: Register a webhook against the Feature Watch board so the release-notes service receives updates when features move to 'shipped'.

### Agent-Driven Feedback Sync

An AI agent watching support tickets, tweets, and Slack mentions can use Jentic to discover Feature Watch's authentication, features, and webhooks operations, login once, file consolidated requests, and register a webhook back to a notification service - keeping the bearer token inside your Jentic One instance.

Example prompt: Use Jentic to search 'create a feature watch feature' and execute POST /features with the consolidated request body.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/login` | Authenticate and receive a bearer token |
| GET | `/boards` | List all boards |
| GET | `/board/{id}/features` | List features on a board |
| POST | `/features` | Create a new feature |
| GET | `/feature/{id}` | Retrieve a specific feature |
| GET | `/comments` | Retrieve feature comments |

## Key resources

- **Authentication** — Login and inspect the authenticated user
- **Boards** — List boards and read their attached features
- **Features** — Create, list, and retrieve feature records
- **Activity** — Read comments, likes, and current state values
- **Webhooks** — Register URLs that receive Feature Watch events

## Why Jentic

- **Setup:** Wiring the Feature Watch API by hand means logging in for a bearer token, or setting the X-API-Key header, and threading the board id through nested feature paths yourself. Through Jentic you install once, import Feature Watch from the API Directory, store the token and key once, and your agent calls it.
- **Permission scoping:** Feature Watch puts the board and feature id in the URL path (`/board/{id}/features` and `/feature/{id}`), so a rule can pin your agent to one board. You choose the operations it may call, so creating a feature is included only when you add it, while board, feature, and comment reads can stay read-only.
- **Credential handling:** Your Feature Watch bearer token and API key are stored once, encrypted, by your own Jentic One instance and injected into the Authorization or X-API-Key header at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'create a Feature Watch feature', and Jentic returns the matching operation with its input schema so the agent calls the right endpoint without browsing the 17-path surface.

## Related APIs

- **Canny** — Mature feedback and roadmap platform with deeper analytics
- **Featurebase** — Feedback and roadmap tool with a Zapier-style API surface
- **Aha!** — Strategic roadmap tool that pairs with Feature Watch's customer-facing collection

## FAQ

### Why is there no official OpenAPI spec for Feature Watch API?

Feature Watch does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Feature Watch 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 Feature Watch API use?

The API supports a bearer token obtained via POST /login and an X-API-Key header. Through Jentic the credential is stored in the vault and injected at call time so the raw token never enters agent context.

### Can I create features programmatically with the Feature Watch API?

Yes. POST /features accepts a title, description, and board association, and POST /add_feature provides an alternative add operation for legacy clients.

### What are the rate limits for the Feature Watch API?

Feature Watch does not publish numeric rate limits in the spec. Apply exponential backoff on 429 responses and cache list results between polls to reduce request volume.

### How do I list features on a board through Jentic?

Run pip install jentic, search 'list feature watch board features', load GET `/board/{id}/features`, and execute it with the target board ID to receive the feature list.

### Does the Feature Watch API support webhooks?

Yes. The Webhooks tag exposes endpoints for registering callback URLs that receive feature activity events, removing the need to poll for changes.

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

Yes. Because you run Jentic One yourself, your own rules decide which Feature Watch operations and credentials the agent may use. Since Feature Watch puts the board and feature id in the URL path, such as `/board/{id}/features` and `/feature/{id}`, you can pin the agent to a single board and keep board, feature, and comment reads read-only. Write operations like POST /features are available only when you explicitly add them, so the agent files new features only if you allow it.
