canonical: https://jentic.com/apis/knips.app/knips

# Knips App Knips API

Jentic publishes the only available OpenAPI specification for Knips API, keeping it validated and agent-ready. Knips is a product feed and content distribution platform that helps brands push product, post, and contact data to retail and partner channels. The public API exposes feeds, the products and collections inside them, contacts attached to a feed, posts, and post requests, plus an authorization endpoint for issuing keys. It is well suited for retail teams syncing catalogues into Knips and for partner integrations that need to read or write feed-level content programmatically.

## For AI agents

Manage Knips product feeds, post their products and collections, attach contacts, and push or read posts and post requests.

## Scope

Does not handle storefront checkout, ad placement, or social network publishing - use for managing Knips feeds, products, contacts, posts, and post requests only.

## Capabilities

- List and create Knips feeds for organising product distribution
- Read products and collections inside a specific Knips feed
- Manage contacts attached to a Knips feed
- Publish a post into a feed and read existing feed posts
- Submit a post request when a partner needs new content
- Authorize against the Knips API to obtain credentials

## Use cases

### Catalogue Sync into Knips

Push a brand's product catalogue into Knips so it can be redistributed to retail partners. The `/v1/feeds` and `/v1/feeds/{feedId}/products` endpoints let an integrator create a feed and populate it with products, replacing CSV uploads with a real API. Best for brands with multiple sales channels who want one source of truth in their PIM and Knips as the distribution layer.

Example prompt: List products from the PIM, then for each call POST `/v1/feeds/{feedId}/products` on Knips feed 42 to upsert the product.

### Partner Post Distribution

Distribute marketing posts to retail partners through Knips feeds. The `/v1/feeds/{feedId}/posts` endpoint publishes a post into a feed that subscribed partners can pull or be notified of, and `/v1/feeds/{feedId}/post-requests` captures partner asks for fresh content. Useful for brand teams who run frequent campaigns and need to keep partners equipped with current creatives.

Example prompt: POST a new post into Knips feed 42 with the provided creative URL and copy, and confirm it returns 201.

### Contact Roster on Feeds

Manage the contacts attached to a Knips feed so the right people on the partner side receive updates. `/v1/feeds/{feedId}/contacts` lists and manages contacts at the feed level. Useful when an account changes hands at the partner and the brand team needs to update notification recipients without rebuilding the feed.

Example prompt: Add contact buyer@partner.com to Knips feed 42 and confirm it appears in the list response.

### Agent-Driven Feed Operations via Jentic

Let an AI agent answer brand-team questions like 'how many products are in feed 42 today' or 'publish this campaign post to all active feeds' by calling Knips through Jentic. The agent searches Jentic for the matching operation, loads the schema, and executes with the API key drawn from your Jentic One instance. Faster than wiring a Knips client into an internal tool.

Example prompt: Through Jentic, search for 'list Knips feeds', load `/v1/feeds`, and report the count of feeds returned.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/v1/feeds` | List feeds |
| GET | `/v1/feeds/{feedId}/products` | List products in a feed |
| GET | `/v1/feeds/{feedId}/collections` | List collections in a feed |
| GET | `/v1/feeds/{feedId}/contacts` | List contacts on a feed |
| GET | `/v1/feeds/{feedId}/posts` | List posts in a feed |
| POST | `/v1/feeds/{feedId}/post-requests` | Create a post request |
| POST | `/v1/authorization` | Authorise an integration |

## Key resources

- **Authorization** — Authorise an integration and obtain credentials
- **Feeds** — Create, list, and manage product or content feeds
- **Feed Products** — List products inside a feed
- **Feed Collections** — Read collections inside a feed
- **Feed Contacts** — Manage contacts attached to a feed
- **Posts** — Publish and read posts inside feeds
- **Post Requests** — Capture partner-driven requests for new posts

## Why Jentic

- **Setup:** Wiring Knips by hand means learning its x-api-key header or basic auth and handling the api.knips.app host and its errors yourself. Through Jentic you install once, import Knips from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** Knips puts the feed id in the URL path (`/v1/feeds/{feedId}/products`), so a rule can pin your agent to one feed: it can read that feed's products, collections, contacts, and posts and nothing else. You choose the operations it may call, so posting a post request is not included unless you add it.
- **Credential handling:** Your Knips credential is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list products in a Knips feed' or 'read a feed's posts', and Jentic returns the matching Knips operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Airtable API** — Common back-of-house store for product and post data syncing into Knips feeds
- **Stripe API** — Handles payment for partner subscriptions or orders driven from Knips feeds
- **Mailchimp API** — Pairs with Knips contacts to email partners when feeds gain new content

## FAQ

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

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

The Knips API supports HTTP Basic auth and an API key sent in the x-api-key header. Through Jentic, both forms of credential are stored in your Jentic One instance and injected at execution time so the agent never holds the raw values.

### Can I push products into a Knips feed via the API?

Yes. `/v1/feeds/{feedId}/products` exposes the products inside a feed and supports the writes needed to add or update products. Use it instead of CSV uploads when integrating from a PIM or e-commerce backend.

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

Knips does not publish a public rate limit and the spec does not declare one. Treat per-feed write endpoints as moderately throttled and avoid tight loops; cache feed and product reads where possible.

### How do I publish a post to a Knips feed from an AI agent through Jentic?

Search Jentic for 'publish a Knips post', load `/v1/feeds/{feedId}/posts`, and execute with the feed id and post payload. Jentic injects the x-api-key header from the vault so the agent only deals with the post content.

### Does the Knips API support partner-driven post requests?

Yes. POST `/v1/feeds/{feedId}/post-requests` captures a partner's request for new content against a specific feed, which the brand team can then fulfil with `/v1/feeds/{feedId}/posts.`

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

Yes. Because you run Jentic One yourself, your own rules decide which Knips operations and credentials the agent may use. Since Knips puts the feed id in the URL path, such as `/v1/feeds/{feedId}/products`, a rule can pin the agent to a single feed and let it read only that feed's products, collections, contacts, and posts. You choose the operations it may call, so a write like POST `/v1/feeds/{feedId}/post-requests` stays off limits unless you explicitly allow it.
