# Brand Source: https://docs.trychannel3.com/api-reference/brand-model A **brand** is the company or label behind a product — for example Nike or Sony. Filter search results with `brand_ids`, or resolve IDs via [`GET /v1/brands/search`](/api-reference/v1/search-brands). Brands are not the same as [websites](/api-reference/website-model) (retailers). A brand makes or labels a product; a website is the online store where you can buy it. One brand's products may appear on many websites. # Category Source: https://docs.trychannel3.com/api-reference/category-model # Websites Source: https://docs.trychannel3.com/api-reference/channel3-api/websites get /v0/websites Resolve a website URL to its ID and best_commission_rate. Tip: website_ids filters accept domains directly, so this lookup is most useful for retrieving commission rates. # Get Price History Source: https://docs.trychannel3.com/api-reference/price-tracking/get-price-history get /v0/price-tracking/history/{canonical_product_id} Get price history for a canonical product. # List Subscriptions Source: https://docs.trychannel3.com/api-reference/price-tracking/list-subscriptions get /v0/price-tracking/subscriptions List your active price tracking subscriptions. # Start Tracking Source: https://docs.trychannel3.com/api-reference/price-tracking/start-tracking post /v0/price-tracking/start Start tracking prices for a canonical product. # Stop Tracking Source: https://docs.trychannel3.com/api-reference/price-tracking/stop-tracking post /v0/price-tracking/stop Stop tracking prices for a canonical product. # Brand Detail Source: https://docs.trychannel3.com/api-reference/v1/brand-detail get /v1/brands/{brand_id} Get detailed information about a specific brand by its ID. # Browse Source: https://docs.trychannel3.com/api-reference/v1/browse post /v1/browse Access to this endpoint is restricted. If you think your use case requires it, contact us at support@trychannel3.com to get access. List and page through products for a set of filters — useful for a static, grid view of products for a brand, website, or category. At least one of `filters.brand_ids`, `filters.category_ids`, or `filters.website_ids` must be provided. # Category Detail Source: https://docs.trychannel3.com/api-reference/v1/category-detail get /v1/categories/{slug} Look up a category by slug. # Image Search Source: https://docs.trychannel3.com/api-reference/v1/image-search post /v1/image-search Search the catalog by image (URL or base64), with pagination support. Provide exactly one of ``image_url`` or ``base64_image``. For text or text+image search, use ``POST /v1/search``. # List Brands Source: https://docs.trychannel3.com/api-reference/v1/list-brands get /v1/brands Paginated list of brands, capped at the top 5,000. # List Categories Source: https://docs.trychannel3.com/api-reference/v1/list-categories get /v1/categories Paginated list of all categories. # Lookup Product Source: https://docs.trychannel3.com/api-reference/v1/lookup-product post /v1/lookup Retrieve product information for any supported product URL. Returns the same Product model as GET /v1/products/{product_id}. The product_id in the response can be used with the Product Detail endpoint. # Product Detail Source: https://docs.trychannel3.com/api-reference/v1/product-detail get /v1/products/{product_id} Get detailed information about a specific product by its ID. # Search Source: https://docs.trychannel3.com/api-reference/v1/search post /v1/search Search for products with pagination support. At least one of `query`, `image_url`, `base64_image`, or `page_token` must be provided; requests with none of these will return 422. # Search Brands Source: https://docs.trychannel3.com/api-reference/v1/search-brands get /v1/brands/search Search brands by free-text query. # Search Categories Source: https://docs.trychannel3.com/api-reference/v1/search-categories get /v1/categories/search Search categories by free-text query. # Similar Products Source: https://docs.trychannel3.com/api-reference/v1/similar-products post /v1/similar Find products similar to a given product. Consider setting ``filters`` to narrow results to the same gender, brand, category, price range, etc. when you only want similar items within a specific slice of the catalog. # Website Source: https://docs.trychannel3.com/api-reference/website-model A **website** is an online retailer or merchant that sells products — for example `nike.com` or `bestbuy.com`. Filter search results with `website_ids`, or browse the full list via [`GET /v0/websites`](/api-reference/channel3-api/websites). Websites are not the same as [brands](/api-reference/brand-model). A brand (Nike, Sony) is the company behind a product; a website is the store listing it. One brand's products often appear on many websites, and one website sells products from many brands. # Category Explorer Source: https://docs.trychannel3.com/categories Browse the Channel3 category tree Every Channel3 category has a stable URL-friendly **slug** (for example `sofas`, `running-shoes`). Pass a slug to filter or look up categories anywhere a category identifier is accepted. Search the full tree below, or hit `GET /v1/categories/search` to do the same from your code. # Announcing the /v1 Search API & SDK 3.0.0 Source: https://docs.trychannel3.com/changelog/announcements/update-1-v1-search-api Our new v1 Product Search API, with pagination, offers, collaborations, and smart images *March 12, 2026 · API Update #1* Hello Developer! Today, we're excited to announce Channel3's V1 Product Search API. We've learned a lot about how users and agents want to interact with product data in the last year of building a universal product catalog. We believe this new endpoint is a cleaner design that will help you curate a richer shopping experience and better empower agents to find the perfect product. Our **new Search API endpoint lives at `/v1/search`**. Check out [the docs here](https://docs.trychannel3.com/api-reference/v1/search) and **upgrade to SDK version 3.0.0** to try it out today! Scroll to the bottom for migration instructions to handle the breaking changes that come with this major version bump. We'll keep `/v0/search` and `/v0/products` around for a few more weeks, but on Monday, April 13th they'll be officially removed. ## What we added **Search pagination** We updated search to return a richer `SearchResponse`, and we now return a `paging_token`. You can page search results up to 500 products, allowing you to build infinite scroll. **Product offers** Many products are sold by multiple retailers. We now show "offers" for every product, so you can decide where to send your users — the lowest-price, the highest commission, or the best-known retailer. **Collaborations** With our improved `brands` field, our products can now represent collaborations and multiple brands, like "MLB" and "Yankees." **Smart images** We look at every image with AI to give you more control over the product you display. Building a scrollable grid? Display `hero` images. Want a cozier, mood board feel? Try showing `lifestyle` images. Hate those annoying sizing charts that ruin the aesthetic of your image carousel? Filter out `size_chart`. Experimenting with virtual try-on? We built `on_model` exactly for this. ## What we removed (breaking changes) + migration instructions Spring is here in NYC, and we've done some spring cleaning on our API. On the `SearchRequest`, we've pared down our `SearchConfig` and `SearchFilters`. These fields had been deprecated and had no impact on search results. If you have any dangling references to deprecated fields, you'll have to remove them when you upgrade to 3.0.0. We've upgraded our search response from a `list[Product]` to a more expressive `SearchResponse`, which includes the `list[Product]` and a `paging_token`. We also cleaned up deprecated fields off of `Product`, so you have more control over the price, availability, brand, image, and product listings you display. **2-step migration instructions** (alternatively, paste this entire update into Claude Code / Cursor and let it cook): 1. Upgrade your Channel3 [Python or TypeScript SDK](https://docs.trychannel3.com/sdk) to version 3.0.0. * If you are using our API directly, point your new search to `/v1/search` and load product details from `/v1/products/`. 2. Audit any usages of the [`/search`](https://docs.trychannel3.com/api-reference/v1/search) endpoint and `Product` models in your app. * Update usages of `/search` to expect a `SearchResponse`. * Ensure you do not use any deprecated `/search` `SearchRequest` or `Product` response fields: * **Request:** `SearchFilters.exclude_product_ids`, `SearchConfig.redirect_mode` * **Response:** `Product.url`, `Product.price`, `Product.availability` (we now return *all* offers for this product, deduplicated across merchants — you or your users can choose the best price, whether that's the cheapest offer or the one that earns you the highest commission); `Product.image_url`, `Product.image_urls` (we use multimodal AI to understand every product image, so you can better curate your shopping experience); `Product.brand_id`, `Product.brand_name` (replaced with `Product.brands`, to support collaborations). 3. That's it! Ship it! Want to build something, but we don't support your use-case? Hit reply and let us know. And, as always, we love to hear what you're building! George # Internationalization Source: https://docs.trychannel3.com/changelog/announcements/update-2-internationalization Filter by country, language, and currency — plus a new Discord and more free credits *May 1, 2026 · API Update #2* Hey Developer, Channel3's API has officially gone global. Now, **you can filter by [country](https://docs.trychannel3.com/api-reference/v1/search), [language](https://docs.trychannel3.com/api-reference/v1/search), and [currency](https://docs.trychannel3.com/api-reference/v1/search) on your search requests** to only view products that fit your target audience. Many of these products are still monetizable with affiliate, and our team is hard at work partnering with more brands to get you higher commissions. (If there are any brands you'd like to see commissions for, let us know!) Upgrade to SDK version 3.2.0 to try it out now! Also, we're launching a [**Channel3 Discord**](https://discord.gg/6J6MjctXrH), a one-stop shop for all things Channel3 and agentic commerce: request features, report bugs, show off what you've built, or just chat with like-minded builders. Lastly, we've updated our pricing. Now, **every developer gets 1,000 free credits *every month***, resetting on the 1st of every month. Nothing else has changed, just more free credits for everyone. [Full pricing info is available on our docs](https://docs.trychannel3.com/pricing). ## Internationalization FAQ **Are these products monetizable?** Yes, many of these products will be monetizable and tracked with monetizable links. We've made deals with thousands of brands over the last few months, and we're adding new brands every day. **Which locales are available?** We're starting with the markets where we've seen the highest demand from developers: Europe, the UK, Canada, and Australia. You can view a full list of our [supported locales in our docs](https://docs.trychannel3.com/api-reference/v1/search). If you want us to expand to a market where we haven't yet, ask in the Discord (or reply to this email)! **Do you have every product from every locale now?** Not yet, but we hope our coverage is sufficient to replace your current product data solution. If there are gaps that are keeping your app/agent from being a truly great personal shopper, ask in the Discord! These markets are foreign to us (pun intended), and we'd appreciate any help in filling in gaps. **How do I add this to my app?** Locales can be provided in `SearchConfig` on every `/search` request, or you can instantiate your `Channel3` client with a specific locale when using your [preferred SDK](https://docs.trychannel3.com/sdk). The fastest way to get this set up is to install our Channel3 skills and ask your preferred coding agent to add support for your desired locale! Just run: ```bash theme={null} npx skills add channel3-ai/skills --skill channel3-api ``` And copy this into your coding assistant: ``` Use the channel3-ai Skill to only search for products from the UK ``` ## Discord We love the feedback, updates, and requests we've gotten in our inboxes. Instead of having these great ideas sequestered to our inboxes, we want to open up a forum for you all to share what you've built, talk through what you want to build, and socialize amongst other agentic-commerce builders! [Join the Discord at this link.](https://discord.gg/6J6MjctXrH) We have a few channels to start: * **#support** — something broken or misbehaving? Send a message in here! * **#showcase** — show off what you've built. Demo, ideate, offer feedback; get inspiration and beta testers. * **#community** — are your friends tired of you bringing up agentic commerce in conversation? Come hang out in #community! * **#feature-requests** — feeling like your app or agent is *almost* perfect, if *only* Channel3 could do X… send that here! Maybe it's on our radar, maybe it's way too hard, maybe we'll have something up by the end of the day 👀 * **#tips-and-help-forum** — as we see clever ways to build with Channel3 or common pitfalls, we'll broadcast them here. Want to build something, but we don't support your use-case? Drop a request in the Discord or hit reply and let us know. And, as always, we love to hear what you're building! George # Endpoints, endpoints, endpoints Source: https://docs.trychannel3.com/changelog/announcements/update-3-new-endpoints Two new endpoints — /v1/similar and /v1/image-search — plus our first Developer Spotlight *May 9, 2026 · API Update #3* Hello Developer, We added [**/v1/similar**](https://docs.trychannel3.com/api-reference/v1/similar) so you can provide an essential component of any shopping experience: product recommendations. We've all seen a "you might also like this" or "frequently bought with" section of a product detail page. With **/v1/similar**, you can now add the same to your app's PDPs. This is especially powerful when coupled with Channel3's cross-merchant canonicalization, letting shoppers view product alternatives and multiple offers, all in one clean UI and two simple API calls. [**/v1/image-search**](https://docs.trychannel3.com/api-reference/v1/image-search) lets you run visual search across our entire product index. Our /search endpoint is still multimodal, but this is a helpful tool for personal shopping agents specifically. No context leak, just a simple, single-query endpoint. Pricing for both endpoints is 1 credit, like everything else. Pricing info is available [on our docs](https://docs.trychannel3.com/pricing). Lastly, we're kicking off a new section in these updates: a **Developer Spotlight**. In every email, we'll showcase an app or a demo that someone built on the Channel3 API. If you want feedback or just to show off what you've been working on, reply to this email or share it directly in the [#showcase channel of our Discord](https://discord.gg/6J6MjctXrH). ## Similar products **How it works:** `/similar` simply takes a product ID and returns a list of products that are visually similar to the provided product. The easiest way to get set up is to install our Channel3 SDK skills with: ```bash theme={null} npx skills add channel3-ai/skills --skill channel3-api ``` and ask your favorite coding agent to "`/channel3-api` add a product recommendation carousel below my main product view with the /similar endpoint." I asked Claude to do this with our dashboard (literally pasted the exact prompt above) and this is what it one-shotted: A product recommendation carousel one-shotted by Claude using the /similar endpoint The full product detail view with a similar-products carousel beneath it The buck doesn't stop with just a simple lookalike product, though. With our [robust `SearchFilters`](https://docs.trychannel3.com/api-reference/v1/similar), you can build some pretty amazing recommendation experiences. **Some ideas:** * Try excluding the product's returned gender with the gender filter to get a his-and-hers couple shopping experience. * For products in the `shirts-tops` category, set a category filter to `pants` and `shoes` for a "shop the look" response. [Full list of category slugs here.](https://docs.trychannel3.com/categories) * You can get results for the whole family by putting age filters for kids and toddlers. * Set a price filter based on the price of the original product for a deal-finder budget shopper. These are just a few ways we've played with this endpoint internally. If you come up with a clever use case (or for any of our other endpoints), share it in the [Discord #showcase channel](https://discord.gg/6J6MjctXrH)! ## Image search **How it works:** just provide an image URL or base64 and we'll return semantically relevant results based on the image. This is great for shopping someone else's fit recommendations, either from a TikTok or IRL. We'll still support multimodal search and pure image search on our /v1/search endpoint, but we've found agents especially perform better when provided this explicitly as a tool. **An idea:** I'd love to see someone use an image segmentation model + [/v1/image-search](https://docs.trychannel3.com/api-reference/v1/image-search) and build a shop-the-look feature. Take a full-body mirror selfie, grab "top," "bottoms," and "shoes," and run 3 parallel image searches! ## Developer Spotlight: Penny This week's developer spotlight features Penny, a ChatGPT app and browser extension deal finder! They both use the [Channel3 Price Tracking API](https://docs.trychannel3.com/api-reference/price-tracking/start-tracking) to display a time-to-buy graphic and [notify users when prices drop](https://docs.trychannel3.com/price-tracking-webhooks). On ChatGPT, you can install the app and invoke it with **@Penny**. I have a love-hate relationship with ChatGPT shopping, and Penny feels a world better. To me, ChatGPT shopping feels like generic ChatGPT answers with products slapped on top. Penny is a first-class shopping experience; a personal shopper agent embedded in your ChatGPT. Penny running as a shopping app inside ChatGPT Penny surfacing product recommendations in ChatGPT The browser extension is an agentic deal finder that walks the line between finding better deals and recommending alternatives when a deal doesn't exist. You can use it on any PDP either as a simple deal finder or a full-on personal assistant. The Penny browser extension acting as an agentic deal finder on a product page If you want your app spotlighted next, hit reply or check out the [#showcase Discord channel](https://discord.gg/6J6MjctXrH)! Want to build something, but we don't support your use-case? Drop a request in the [Discord](https://discord.gg/6J6MjctXrH) or hit reply and let us know. And, as always, we love to hear what you're building! The Channel3 Team # Brands, Categories, and Search Goes Fast Source: https://docs.trychannel3.com/changelog/announcements/update-4-brands-categories-fast Overhauled Brand and Category endpoints, plus sub-second P50 search *May 16, 2026 · API Update #4* Hey Developer, **We've overhauled our Brand and Category endpoints** to make it as easy as possible to search, refine, and repeat across this metadata. Our goal here at Channel3 is to help you power a shopping experience that surfaces the perfect product for your user. One key component in filtering keyword/semantic matches that don't match the user's intent is robust brand and category filtering. If you can constrain your search space to a set of products a user would be happy picking between, your odds of converting increase significantly. Category endpoints feature slug support, so you don't need to do a pesky category ID lookup. Internally, we ran migrations over all >100M products to both rebrand and recategorize them. More info below, and check out our [docs](https://docs.trychannel3.com/sdk) for a recommended workflow for an agent to best utilize these endpoints. You might think, with all of these additions to our API, that we might tank our search performance. Well, our second announcement today is that our endpoint timings are in, and after long days of infra grinding, we're excited to announce **sub-second P50 timing on /v1/search**. In our experimentation, this is definitely fast enough for agents to multiplex or chain requests while still blowing traditional product search workflows out of the water. ## Categories Our **Categories module** has 3 endpoints: `/v1/categories/search`, `/v1/categories`, and `/v1/categories/{slug}`. On our SDK, these are `client.categories.search`, `client.categories.list`, and `client.categories.retrieve`. Additionally, every `Product` returned [on our API has a list of `categories`](https://docs.trychannel3.com/api-reference/v1/search) (in practice, this is 1 category), which can be used for category narrowing. Categories are structured in a category tree, which you can [view in its entirety on our docs](https://docs.trychannel3.com/categories). The [`CategoryDetail` returned on our API](https://docs.trychannel3.com/api-reference/v1/category-detail) includes `CategoryRefs` that are sufficient for programmatically traversing the category tree to aid in your development or to provide end users with robust filters. The `CategoryDetail` also returns an [`attributes` field](https://docs.trychannel3.com/api-reference/v1/category-detail), which is a map of structured attributes, such as color, size, and material. It'd be pretty cool to filter deterministically on those attributes… more to come on that 👀. For agents, our [Channel3 product-discovery skill](https://github.com/channel3-ai/skills) already has explicit instructions to refine queries with relevant category searches. If you're building your own agentic harness, we recommend doing the same. **Why?** Categories are most important for filtering out semantic or keyword search noise. For example, if you search "canoe" on our API, you'll get some good canoeing options, but you might just as well get a landscape photo of a canoe. Internally, we do attempt to filter down to correct categories based on query intent. But if you're building a clothing shopping app, there's no reason not to constrain your outputs to categories you actually care about. ## Brands Our **Brands module** mirrors the shape of the Categories module: `/v1/brands/search`, `/v1/brands` for listing, and `/v1/brands/{brand_id}` for getting a brand detail. On the SDK, these are `client.brands.search`, `client.brands.list`, and `client.brands.retrieve`. `/v1/brands/search` is a simple keyword lookup by brand name, so you can map "nike" to its brand ID `MpZs` for use in `SearchFilters`. `/v1/brands` lists our relevant brands, which you can page through, so you can programmatically inspect our brand catalog. These are sorted by our internal brand scores, so if you use this in production, you'll only display relevant brands to users. In the future, we'll support filtering down this list, so you can programmatically curate a brand list for your users. All of these endpoints return the same `Brand` object, which includes a name, logo, and best commission rate. **Why?** If categories are useful for refining individual queries, curating a brand list for your platform ensures a high floor of product discovery. We strive to provide as many tools as possible for you to impose your taste and curate your shopping experience. Brands are an essential step in this process. ## Performance We benchmarked our `/v1/search` endpoint and are excited to announce a **sub-second P50 search time**. I won't bore you with all of the internals of our search, but in the span of (less than) a second, we: use language models, sanitize and understand your query, search (both keyword and semantic) our corpus of >100M products, and rerank these keyword and semantic results into one, pageable batch. Lightning-fast search has obvious benefits. The engagement falloff when a page takes a few or several seconds to load is real. However, we're most excited about making search as fast as possible so we can power the optimal **agentic search experience**. We built a simple agentic product search harness internally to compare how multiplexed queries (>1 `/v1/search` calls in a single agent call turn) compared to Gemini and ChatGPT. Building out this harness was less than a day of work. The results speak for themselves. Gemini is quick, admittedly, but it inundates you with 10 or more results. In the time it takes ChatGPT to spit back a single, verbose response, you can do multiple round trips with Channel3. A bar chart comparing product recommendation response times across Channel3, Gemini, and ChatGPT The difference between waiting 4.5 seconds and 12 seconds for a product recommendation is the difference between converting a sale and churning a user to a traditional shopping experience. Every week, we're adding more tools for you to refine your shopping experience and help surface the perfect products. Want to build something, but we don't support your use-case? Drop a request in the [Discord](https://discord.gg/6J6MjctXrH) or hit reply and let us know. And, as always, we love to hear what you're building! The Channel3 Team # SDK 3.3.1 — Color Filters, Cleaned Images & a CLI Source: https://docs.trychannel3.com/changelog/announcements/update-5-sdk-331 Search color filters, cleaned images, and a brand-new Channel3 CLI *May 26, 2026 · API Update #5* Hey Developer, **SDK version 3.3.1 has landed!** Before this release, we were already the best (and only) product API when it came to image understanding. We're doubling down on this, launching **search color filters** and **cleaned images**, all in a minor SDK release. These features are in addition to our in-depth image understanding, including classified image shot types and generated alt text, which is already live on our [API `ProductImage` type](https://docs.trychannel3.com/api-reference/v1/search). Also, **we launched a [CLI](https://docs.trychannel3.com/cli)!** If you're in the MCP-is-dead camp, install our CLI with `brew install channel3-ai/tap/channel3` and point your preferred agent at it. We also [**supercharged our Skills**](https://github.com/channel3-ai/skills) to leverage the CLI, and they really feel like magic when used with a personal agent. If you sleuth through our [**SDK changelog**](https://docs.trychannel3.com/changelog/overview), you'll notice we're not going to cover most of the changes here. We did a lot, and some of these changes deserve their own update (variants, structured attributes). ## Cleaned images **Cleaned images** are product images that have the following properties: 1. Square aspect ratio 2. Uniform, monochromatic background and are indicated on our API under the [`ProductImage` type with the flag `is_cleaned_image`](https://docs.trychannel3.com/api-reference/v1/search). Cleaned images are perfect for displaying a uniform, consistent product grid. Take [nordstrom.com](http://nordstrom.com) on our dashboard. Before cleaned images, this is what the product grid looks like. It's good, but those bad aspect ratios stick out like a sore thumb, and the on-model shots are glaring. A Nordstrom product grid before cleaned images, with mismatched aspect ratios and on-model shots Now, check out the page with cleaned images below. It's subtle, but significantly better: * Every image is the perfect aspect ratio * Those on-model shots have been replaced with cleaned, square lay-flat shots * The sunglasses, which were a narrow rectangle, have padding extending the image to a square The same Nordstrom product grid after cleaned images, with uniform square tiles In practice, this increases the conversion rate of both the products that previously displayed inconsistent on-model shots and the entire product grid. And, it looks super slick. **To adopt cleaned images, simply ask your coding agent to "prefer displaying images with `is_cleaned_image` in my product grid view."** ## Search color filters With **`SearchColorsFilter`**, you can provide a `hex` and a `percentage` filter to your `/v1/search` query, so every search result is a product matching the provided color profile. See the [docs for this filter here](https://docs.trychannel3.com/api-reference/v1/search). [Cosmos](https://www.cosmos.so) is an inspiration/moodboard/design app for creatives. One of its entry points is a simple color picker that kicks you off on a truly beautiful journey through a sea of themed images. We were inspired by this experience and decided we could build this for products. Thus, `SearchColorsFilter` was born. We've analyzed, extracted, and indexed color palettes for millions of products. I'll note that this field is in beta. We were so amazed by this tool, we wanted to share it with you ASAP! Two specific cautions: 1. Our coverage for indexed colors is good, but color space is large (16 million hex codes). At times, some irrelevant results will slip in. This is simply a consequence of the search space with the color filter applied being prohibitively small. 2. We might change the API shape — we've marked it as beta in the docs. Feedback is super helpful here, drop it in the [Discord](https://discord.gg/6J6MjctXrH). ## Search color filters + cleaned images We don't actually expose a way to do specifically this search (yet), but let me brag for a second. Look at these search results — perfectly uniform, totally adherent to the provided palette, and incredibly aesthetic. This is Pinterest or Cosmos for shopping. Someone, please build this!! A product grid combining color filters and cleaned images into a uniform, palette-matched result set ## CLI Full setup instructions can be found [on our docs](https://docs.trychannel3.com/cli), but getting running with the CLI is as easy as: ```bash theme={null} brew install channel3-ai/tap/channel3 export CHANNEL3_API_KEY="your_api_key_here" ``` (add that environment variable to your `.zshrc` or `.bashrc` so you never have to set it again) CLIs are a great tool for pointing personal agents to if you don't want the context bloat of adding MCPs. The CLI is simply our API, in CLI form, fully equipped with search, price tracking, and all the auxiliary endpoints. The CLI is enhanced when paired with our Skills, which instruct your agent on *how* to use the CLI. [Channel3 Skills](https://docs.trychannel3.com/skills) can be installed in one line as well: ```bash theme={null} npx skills add channel3-ai/skills --skill product-discovery ``` Want to build something, but we don't support your use-case? Drop a request in the [Discord](https://discord.gg/6J6MjctXrH) or hit reply and let us know. And, as always, we love to hear what you're building! The Channel3 Team # Variants How-To Source: https://docs.trychannel3.com/changelog/announcements/update-6-variants-how-to A deep dive on Variants — the data model, selecting variants, and building with them *June 4, 2026 · API Update #6* Hey Developer, Today, we're taking a deep dive into **Variants, launched in SDK version 3.3.1**. TLDR: we figured out the hard stuff, so [you just have to copy/paste our docs into Cursor](https://docs.trychannel3.com/variants). If you run into any problems building with Variants, [drop a question in our Discord](https://discord.gg/6J6MjctXrH) or reply to this email. We also did some housekeeping on categories returned on our Products, and you'll have to clean up a deprecated field. Finally, I want to shout out some old work we've done for all of the new devs that have signed up in the last few months. We're refreshing products at an all-time high rate, and recording their price fluctuations every time we refresh. As a result, our [**price tracking suite of endpoints**](https://docs.trychannel3.com/api-reference/price-tracking/start-tracking) **is more powerful than ever**, featuring real-time webhook updates and rich price history components to power a time-to-buy UI. ## Variants We have an in-depth [guide to building with Variants on our docs](https://docs.trychannel3.com/variants). We also have a [Discord channel](https://discord.gg/6J6MjctXrH) designated for supporting your development, so if you hit any blockers, drop them in there! For now, we'll discuss some important high-level concepts: 1. The Variant data model 2. Selecting Variants 3. Building with Variants ### Variant data model The [full Variant schema can be viewed here](https://docs.trychannel3.com/variants#the-variant-data-model). There are two core design primitives when building with variants: the value and the availability status. The image below shows a breakdown of a fully-featured PDP with a variant selector, and how the components map to our returned data model. An annotated product detail page showing how VariantOption values and availability map to the rendered selector **Variant values** Variant values come in two shapes on our API: strings and images. The fields `thumbnail_url` and `label` determine the *content* of a variant selector button. If a `VariantOption` has a `thumbnail_url`, we recommend displaying a thumbnail icon button. Each of these buttons links to a different `product_id` as well. For configurations of the same product, we omit the `thumbnail_url`; these should just be displayed as a group of buttons or a dropdown selector displaying the `label`. These are the "Size" dimensions above. **Availability status** The values `available` and `exists` govern the *styling* of the variant selector button. There are 4 style states for variants: In Stock (`available=InStock`), Out of Stock (`available=OutOfStock`, `exists=true`), Not Available (`exists=false`), and Selected (`VariantOption == selected`). We have a deep dive into [the distinction between these fields in the docs](https://docs.trychannel3.com/variants#available-vs-exists), and if you use our resources, your coding agent will simply get the UX correct. The simple breakdown is: 1. `availability` determines the stock status of an option. This Puma shoe is InStock in size 5.5, OutOfStock in size 5 and 7. 2. `exists` indicates whether a configuration exists at all for a specific selection, independent of availability. In the example above, there are no known listings for the White Vapor shoe in size 6.5. If the user selects 6.5, the API will return the closest computed match, which would be size 6.5 in a different color. If you want to learn more about this, you can research "variant relaxation." Our current support for variant relaxation is V0; if you need more expressive variant selection, we can discuss in Discord. ### Selecting variants You load variant selections using our [ProductDetail endpoint](https://docs.trychannel3.com/api-reference/v1/product-detail). You can select/reference variants two ways: 1. When an option has a `product_id`, you can use this `product_id` directly. 2. For an `OptionValue` without a `product_id`, append the query parameter `option_{VariantOption.name}={OptionValue.label}` — for the example above: `option_size=5.5`. For example, to load the Hyperlink Blue shoe in size 6 from the current selection of the White shoe, you could equivalently call: ``` https://api.trychannel3.com/v1/products/XAtbsEk?option_Size=6 https://api.trychannel3.com/v1/products/SeAHhDT?option_Color=Hyperlink%20Blue-PUMA%20White&option_Size=6 ``` **Every time you load a variant, you should render the selection from the returned `selected` field and rerender the state of each variant selector option from the returned `options`.** ### Building with variants Variants are really complicated. For something so intuitive and seemingly so simple, there are many edge cases and pitfalls. **The best way to build with variants is to lean on our docs, our skills, and a coding agent.** 1. Copy our [Variants docs page](https://docs.trychannel3.com/variants) into your preferred coding agent. 2. Add our [Channel3 API skill](https://docs.trychannel3.com/skills) to your coding agent: `npx skills add channel3-ai/skills --skill channel3-api` 3. Ask your coding agent to "render variant selectors under my product search results and on my PDP view." **If you hit any snags, reach out in the [Discord](https://discord.gg/6J6MjctXrH) so others can learn alongside you.** One final important distinction to understand with variants is our /v1/search vs /v1/products/ support for them, [outlined in-depth here](https://docs.trychannel3.com/variants#search-vs-product-detail). **/v1/search** returns *all offers* for the product, across all of its variations. **/v1/products** filters offers down to only those present in the provided selection — e.g. `/v1/products/ABC123?option_size=5.5` returns only the listed offers for that selection. ## Category We recategorized all 100M+ products, so they have exactly one, high-quality category assignment. `categories` on the Product response is now deprecated. [Switch over to `category`](https://docs.trychannel3.com/product-model), which returns a rich `CategorySummary`, and integrates seamlessly with our [**Categories** module](https://docs.trychannel3.com/categories). Categories and strong categorization are especially important for refining search results. For example, if you're building a fashion app, you should *always* be filtering to the `apparel-accessories` category on all of your searches. This improvement to categorization also increased the quality of our search results, reducing the number of irrelevant or erroneous products returned. ## Price tracking + history One of the highest-converting shopping experiences you can build is a deal finder. With our [Price Tracking module](https://docs.trychannel3.com/api-reference/price-tracking/start-tracking), you can build a deal finder in a matter of minutes. We're now refreshing tens of millions of products a day and recording rich price history for all of them. For even higher-stakes deal hunting, we offer price tracking webhooks that notify you the moment a price drops. Use the `/v0/price-tracking/history` endpoint to load price history for a product and build your own time-to-buy UI. Or, if you don't want to build a somewhat complex UI component, you can wait a week… we might have some components cooking 👀. A price history chart rendered from the Channel3 price tracking history endpoint Want to build something, but we don't support your use-case? Drop a request in the [Discord](https://discord.gg/6J6MjctXrH) or hit reply and let us know. And, as always, we love to hear what you're building! The Channel3 Team # We Built Your Frontend For You Source: https://docs.trychannel3.com/changelog/announcements/update-7-component-library An open-source, fully-featured Channel3 component library — search, PDPs, hooks, and more *June 23, 2026 · API Update #7* Hey Developer, Pause the API talk for a second — **we just launched [an open-source, fully-featured component library](https://github.com/channel3-ai/channel3-ui)!** We've built every core component of a shopping experience, from search to a rich product detail view. And, the best part is, if we don't have a component you want, you can contribute to the repo yourself. This ships as a Shadcn component library. All you have to run is: ```bash theme={null} npx shadcn@latest add https://ui.trychannel3.com/r/all.json ``` and all of the components and hooks land in your repo as editable, customizable code. **We provide the building blocks, and you customize every aspect of them to fit your app.** We're simply handling the boilerplate — variant selectors, price history graphs, image carousels — so you don't have to. And, they look pretty clean. We'll dive into everything that shipped below. TLDR: in two lines of code, you can build a fully-featured shopping app. ## Resources + implementation [Our docs](https://docs.trychannel3.com/ui) have a comprehensive overview. The [README for the repo](https://github.com/channel3-ai/channel3-ui) is well-maintained. And, [the landing page on our website](https://trychannel3.com/developers/ui) shows how easy they are to build with. They even power our interactive chat demo: [trychannel3.com/demos](https://trychannel3.com/demos). If you hit any snags, [hop into the Discord](https://discord.gg/6J6MjctXrH) and ask. You can also contribute back to the library; it's open-source. To build with the component library, simply install it into your app with: ```bash theme={null} npx shadcn@latest add https://ui.trychannel3.com/r/all.json ``` and install the Channel3 skill: ```bash theme={null} npx skills add channel3-ai/skills --skill channel3-api ``` then ask your agent to build with the Channel3 UI components. ## Blocks Rather than me telling you how great these are, let me just show you. The top-level components of the library are `product-search` and `product-details`. `product-search` is a single component for a fully-featured search, including filters and infinitely scrollable results. I love this graphic because it also visualizes how powerful our search has become. Notice the rich brand filters (with logos), and the rust color filter looks fantastic here. The product-search component rendering a full search experience with brand and color filters When a user wants to dive into a search result, use `product-details`. Again, in one component, you get a PDP with variant selection, multiple offers, and similar product search, all built in. The product-details component rendering a full product detail page ## Components The above two screenshots basically constitute an end-to-end shopping app, but they're certainly not exhaustive for our component catalog. The [full list is here](https://github.com/channel3-ai/channel3-ui#catalog), but some notable shoutouts: **Price history and tracking components:** there's a reason these are a staple of the best deal-finding experiences. Almost as important as surfacing *what* to buy is informing your user *when* to buy. Enhance this with our `price-tracking` webhooks to get notified the second a price drops. A price history and tracking component from the Channel3 UI library **Similar product carousels:** a PDP almost looks empty without these. If a user is on a PDP, they're probably interested in the product itself or something like it. Capitalize on the user's intent with `/similar`. A similar-products carousel component from the Channel3 UI library We're also adding more components every week, so keep your eyes on the channel3-ui repo. If you build a great component using our API, we'd love for you to contribute it back to the library. ## Hooks A sneakily challenging part of building an e-commerce app is the UX logic. Variant selection is a nuisance to get perfectly correct. Infinite scroll is another bit of custom logic that you really want to "just work." And every async call is another loading state you have to worry about. So, we solved that in the component library as well. For any core e-commerce business logic, we have a hook: * Don't try to figure out variant relaxation or availability vs. existence states. Use `use-variant-selection`. * You *could* build search filter plumbing and request orchestration yourself. Or, you could use `use-product-search`. * Supercharge your filters with `use-async-options`, so category and brand filters are loaded snappily. Want to build something, but we don't support your use-case? Drop a request in the [Discord](https://discord.gg/6J6MjctXrH) or hit reply and let us know. And, as always, we love to hear what you're building! The Channel3 Team # Changelog Source: https://docs.trychannel3.com/changelog/overview Product updates and release notes Select a version from the sidebar to view release notes. # v2.0.0 — September 2025 Source: https://docs.trychannel3.com/changelog/v2-0-0 New Python SDK * **Breaking:** New auto-generated, type-safe Python SDK with full async/sync client support * Comprehensive type definitions for all API resources # v2.1.0 — September 2025 Source: https://docs.trychannel3.com/changelog/v2-1-0 Exclude products filter * Added `exclude_product_ids` filter to [`POST /v1/search`](/api-reference/v1/search) to exclude specific products from results # v2.10.0 — January 2026 Source: https://docs.trychannel3.com/changelog/v2-10-0 Product endpoint update * Simplified [`GET /v1/products/{product_id}`](/api-reference/v1/product-detail) documentation — removed variant dimension query parameter details * Fixed file handling in PATCH requests # v2.11.0 — January 2026 Source: https://docs.trychannel3.com/changelog/v2-11-0 Model updates * Removed deprecated `variants` description from `Product` and `ProductDetail` response models # v2.12.0 — January 2026 Source: https://docs.trychannel3.com/changelog/v2-12-0 List brands and lookup improvements * Added [`GET /v0/list-brands`](/api-reference/v1/list-brands) endpoint with paginated brand listing * Renamed `brands.list` to `brands.find` for the name-based brand search * Updated [`POST /v0/enrich`](/api-reference/v1/lookup-product) to support real-time fallback retrieval when a product isn't in the database * Added support for binary request streaming # v2.13.0 — March 2026 Source: https://docs.trychannel3.com/changelog/v2-13-0 Search service v2, brands on products, and category exclusion filters * Upgraded [`POST /v1/search`](/api-reference/v1/search) to **search service v2** with improved relevance and performance * Added `brands` field (with `id` and `name`) to `Product` and `ProductDetail` response models * Added `exclude_category_ids` filter to [`POST /v1/search`](/api-reference/v1/search) # v2.2.0 — September 2025 Source: https://docs.trychannel3.com/changelog/v2-2-0 Simplified client configuration * Removed `environment` parameter from client — use `base_url` or the `CHANNEL3_BASE_URL` env var instead # v2.3.0 — October 2025 Source: https://docs.trychannel3.com/changelog/v2-3-0 Enriched product response and redirect mode * Expanded [`POST /v0/enrich`](/api-reference/v1/lookup-product) response to include `brand_id`, `brand_name`, `gender`, `image_urls`, `key_features`, `materials`, and `variants` * Added `redirect_mode` config option to [`POST /v1/search`](/api-reference/v1/search) — choose between `price`, `commission`, or `brand` redirect behavior # v2.4.0 — November 2025 Source: https://docs.trychannel3.com/changelog/v2-4-0 New search filters and config options * Added `category_ids`, `condition`, and `website_ids` filters to [`POST /v1/search`](/api-reference/v1/search) * Added `monetizable_only` config option to [`POST /v1/search`](/api-reference/v1/search) to return only commissionable products * Added `categories` field to search and product response models * Removed `brands.retrieve` endpoint — use [`GET /v1/brands`](/api-reference/v1/list-brands) with the `query` parameter instead * Fixed streams not being properly closed without full consumption # v2.5.0 — November 2025 Source: https://docs.trychannel3.com/changelog/v2-5-0 Python 3.14 and Pydantic v1 compatibility * Added compatibility with **Python 3.14** * Fixed `model_dump` and `model_dump_json` signatures for **Pydantic v1** * Dropped support for Python 3.8 # v2.6.0 — December 2025 Source: https://docs.trychannel3.com/changelog/v2-6-0 Unified product response type * Unified product response type — [`POST /v0/enrich`](/api-reference/v1/lookup-product) now returns `ProductDetail` instead of a separate `EnrichEnrichURLResponse` * Removed deprecated `Product` type from exports # v2.8.0 — December 2025 Source: https://docs.trychannel3.com/changelog/v2-8-0 Price tracking * Added price tracking endpoints: [`POST /v0/price-tracking/start`](/api-reference/price-tracking/start-tracking), [`POST /v0/price-tracking/stop`](/api-reference/price-tracking/stop-tracking), [`GET /v0/price-tracking/history/{canonical_product_id}`](/api-reference/price-tracking/get-price-history), and [`GET /v0/price-tracking/subscriptions`](/api-reference/price-tracking/list-subscriptions) # v2.9.0 — December 2025 Source: https://docs.trychannel3.com/changelog/v2-9-0 Performance improvements * Faster SDK import times # v3.0.0 — March 2026 Source: https://docs.trychannel3.com/changelog/v3-0-0 v1 Product API * **Breaking:** Migrated to the v1 Product API — [`POST /v1/search`](/api-reference/v1/search), [`GET /v1/products/{product_id}`](/api-reference/v1/product-detail), [`POST /v1/lookup`](/api-reference/v1/lookup-product) * Added [`GET /v1/brands/{brand_id}`](/api-reference/v1/brand-detail) for fetching individual brand details * Added pagination support for [`POST /v1/search`](/api-reference/v1/search) results * Removed deprecated fields from product and search responses # v3.1.0 — April 2026 Source: https://docs.trychannel3.com/changelog/v3-1-0 Bug fixes and SDK improvements * Fixed file uploads sending duplicate data in multipart requests on [`POST /v1/image-search`](/api-reference/v1/image-search) * Fixed hardcoded query params being overwritten when merging with user-provided params * Fixed endpoint path parameter sanitization # v3.2.0 — April 2026 Source: https://docs.trychannel3.com/changelog/v3-2-0 Image search, categories, and localization * Added [`POST /v1/image-search`](/api-reference/v1/image-search) endpoint for visual product discovery * Added [`POST /v1/similar`](/api-reference/v1/similar-products) endpoint for finding related products * Added categories endpoints: [`GET /v1/categories`](/api-reference/v1/list-categories), [`GET /v1/categories/search`](/api-reference/v1/search-categories), and [`GET /v1/categories/{slug}`](/api-reference/v1/category-detail) * Added [`GET /v1/brands/search`](/api-reference/v1/search-brands) endpoint * Added `language`, `country`, and `currency` parameters to the client and [`GET /v1/products/{product_id}`](/api-reference/v1/product-detail) * Removed `unisex` from gender filter options on [`POST /v1/search`](/api-reference/v1/search) * Removed `min_price_floor` from search filter price parameters * Clarified that `category` search filter on [`POST /v1/search`](/api-reference/v1/search) accepts slugs # v3.3.0 — May 2026 Source: https://docs.trychannel3.com/changelog/v3-3-0 Variants, structured attributes, color filters, and new locales * Added `variants` to [`GET /v1/products/{product_id}`](/api-reference/v1/product-detail) and [`POST /v1/lookup`](/api-reference/v1/lookup-product) responses — includes `options` (e.g. Color, Size) with availability per value, and `selected` for current selections * Added `structured_attributes` to [`GET /v1/products/{product_id}`](/api-reference/v1/product-detail) and [`POST /v1/lookup`](/api-reference/v1/lookup-product) responses — extracted product attributes keyed by handle (e.g. `color`, `material`) * Added `attributes` filter to [`POST /v1/search`](/api-reference/v1/search) — filter by attribute key/value pairs (e.g. `{"color": ["blue", "red"]}`) * Added `colors` filter to [`POST /v1/search`](/api-reference/v1/search) — filter products by color palette using hex values **(Beta)** * Added `age` filter to [`POST /v1/search`](/api-reference/v1/search) — filter by age group (`newborn`, `infant`, `toddler`, `kids`, `adult`) * Added support for Greece (`GR`) and Romania (`RO`) locales, `RON` currency, and `el`/`ro` languages * Updated `Category.attributes` description to clarify usability as keys in search filters # v3.3.1 — May 2026 Source: https://docs.trychannel3.com/changelog/v3-3-1 Category field and cleaned image flag * Added `category` field to [`GET /v1/products/{product_id}`](/api-reference/v1/product-detail) and [`POST /v1/lookup`](/api-reference/v1/lookup-product) responses — includes the product's category slug and title * Added `is_cleaned_image` flag to product image models — `true` when the image has a square aspect ratio and uniform background, ideal for product grids # v3.4.0 — July 2026 Source: https://docs.trychannel3.com/changelog/v3-4-0 Browse endpoint, search modes, sale and condition filters * Added [`POST /v1/browse`](/api-reference/v1/browse) — list and page through products for a brand, website, or category, ideal for static grid views. Access is restricted; [contact us](mailto:support@trychannel3.com) to enable it * Added `mode` to [`POST /v1/search`](/api-reference/v1/search) config — choose `default` (lexical + semantic, recommended), `keyword` (lexical only, lowest latency), or `agentic` (LLM-planned sub-searches for complex queries). Deprecated `keyword_search_only`; `true` is equivalent to `mode=keyword` * Added `sale` filter to [`POST /v1/search`](/api-reference/v1/search) — pass `on_sale` to only return products with at least one offer priced below its compare-at price * Updated `condition` filter to require at least one offer matching the requested condition, locale, and any price filter — offers without condition data are indexed as `new` * Added `condition` to product offer models — `new`, `refurbished`, or `used`, or `null` when unknown * Added `country` parameter to brand and website endpoints — commission rates now reflect the requested country (default `US`) # v3.5.0 — July 2026 Source: https://docs.trychannel3.com/changelog/v3-5-0 Dimension filters, offer dimensions, and configurable units * Added `dimensions` filter to [`POST /v1/search`](/api-reference/v1/search) — match products by physical size (`length`, `width`, `height`) and `weight`. Each field takes an optional `min`/`max` (inclusive) and a required `unit`. See [Dimension Filters](/guides/dimension-filters) * Added `dimensions` to product offer models — `length`, `width`, `height`, and `weight`, each returned as a `number` plus its `unit`; individual members are `null` when unknown * Added `length_unit` and `weight_unit` controls for the unit dimensions come back in — set them per request (search `config`, or [`GET /v1/products/{product_id}`](/api-reference/v1/product-detail) query params) or as a client default via the SDK constructor or the `CHANNEL3_LENGTH_UNIT` / `CHANNEL3_WEIGHT_UNIT` environment variables. Precedence is: a dimension filter's own unit, then the per-request value, then the client default; when none is set, the merchant's stated unit is returned * Length units are `mm`, `cm`, `m`, `in`, `ft`; weight units are `mg`, `g`, `kg`, `oz`, `lb`. A merchant-stated value whose unit falls outside these sets is omitted rather than converted # CLI Source: https://docs.trychannel3.com/cli Use Channel3 from your terminal. The Channel3 CLI lets you call any API endpoint from your terminal. Source code lives at [github.com/channel3-ai/cli](https://github.com/channel3-ai/cli). ## Installation ```sh theme={null} brew install channel3-ai/tap/channel3 ``` To upgrade to the latest version: ```sh theme={null} brew upgrade channel3 ``` ## Authentication Set your API key via environment variable, or pass it with `--api-key` on any command. ```sh theme={null} export CHANNEL3_API_KEY="your_api_key_here" ``` You can also set `CHANNEL3_LANGUAGE`, `CHANNEL3_COUNTRY`, and `CHANNEL3_CURRENCY` to apply default locale settings to every call. To set these permanently, add the `export` lines to your `~/.zshrc` (or `~/.bashrc`) and run `source ~/.zshrc` to apply them to your current shell. ## Usage Commands follow a resource-based structure: ```sh theme={null} channel3 [resource] [flags...] ``` For example, to search for products: ```sh theme={null} channel3 products search --query "organic cotton t-shirt" ``` Pass `--help` to any command for full flag documentation. ### Passing files Use the `@` prefix to send a file as an argument — useful for image search: ```sh theme={null} channel3 products search --base64-image @shoe.jpg ``` ### Output formats Change the output format with `--format` (`json`, `jsonl`, `yaml`, `pretty`, `raw`, `explore`), or extract fields with `--transform` using [GJSON syntax](https://github.com/tidwall/gjson/blob/master/SYNTAX.md): ```sh theme={null} channel3 products search --query "running shoes" --transform "products.#.title" ``` # Billing & credits Source: https://docs.trychannel3.com/faq/billing-and-credits ### What counts as a credit? Each billable API call is one credit. See [pricing](/pricing) for the per-endpoint breakdown. ### Where can I see my usage? Usage and remaining credits are shown on the [Channel3 dashboard](https://trychannel3.com/dashboard). ### What are the rate limits? We apply reasonable per-account limits to keep the API fast for everyone. If you're planning a high-volume workload, reach out and we'll work with you. # Catalog & coverage Source: https://docs.trychannel3.com/faq/catalog-and-coverage ### Which countries and currencies are supported? Channel3 supports locale-aware search across the U.S., UK, Canada, Australia, and much of Europe. Set a default locale on the SDK client or pass `country`, `language`, and `currency` per call — see [Localization](/guides/localization) and [Default locale](/sdk#default-locale). ### Countries | Code | Market | | ---- | ---------------------------------------------------------------------------------- | | `US` | United States | | `CA` | Canada | | `GB` | United Kingdom | | `IE` | Ireland | | `AU` | Australia | | `DE` | Germany | | `AT` | Austria | | `FR` | France | | `BE` | Belgium | | `IT` | Italy | | `ES` | Spain | | `NL` | Netherlands | | `SE` | Sweden | | `FI` | Finland | | `PT` | Portugal | | `CZ` | Czech Republic | | `GR` | Greece | | `RO` | Romania | | `EU` | Europe (pan-region; use with `currency: EUR` when you don't need a single country) | ### Currencies `USD`, `CAD`, `AUD`, `GBP`, `EUR`, `SEK`, `CZK`, `RON` When you set `country` only, the API infers `currency` (for example `GB` → `GBP`). When all three locale fields are unset, defaults are `en` / `US` / `USD`. ### Languages `en`, `de`, `fr`, `it`, `es`, `nl`, `sv`, `fi`, `pt`, `cs`, `el`, `ro` Coverage outside the U.S. is still growing. If you need a market we don't support yet, contact us or ask in [Discord](https://discord.gg/6J6MjctXrH). ### Can I request a brand or retailer be added? Yes — email us with the brand or retailer and we'll prioritize it. # Commissions Source: https://docs.trychannel3.com/faq/commissions ### How do commissions work? Channel3 has partnered with thousands of brands who pay commission on AI-driven sales. After your agent recommends a product, we track if the end-user buys it (within a retailer-set timeframe). We pay you for purchases. You can see estimated commission rates on the Channel3 dashboard and in the product search response. ### Why do rates show "maximum"? Commissions can be adjusted or canceled by retailers for reasons such as returns, order cancellations, suspected fraud, attribution to another channel, or network quality concerns. ### When and how are commissions paid out? Earnings appear on the [Channel3 dashboard](https://trychannel3.com/dashboard) once attributed sales clear the retailer's return window. Earnings are paid out securely via Stripe. # Support Source: https://docs.trychannel3.com/faq/support ### How do I get help or report a bug? Email us at [support@trychannel3.com](mailto:support@trychannel3.com) or join our [Discord](https://discord.gg/6J6MjctXrH). We're happy to help with integration questions, brand requests, billing, or anything else. # Attribute Search Source: https://docs.trychannel3.com/guides/advanced-search Use structured attributes and category detail to find products by specific features — e.g. sofas with USB charging ports. Every product in Channel3 has a category, and every category has a set of **structured attributes** — machine-extracted features like material, connectivity, power source, and thousands of others. Combining category detail lookup with the `attributes` search filter lets you express queries that plain text search can't — for example, finding sofas that have USB charging ports. ## The two-step pattern 1. **Discover the category and its attributes** — look up the category detail to see which attribute keys are defined and what values they accept. 2. **Search with an attribute filter** — pass those key/value pairs to `/v1/search` to get precisely matched products. *** ## Step 1 — Get a category slug You need a category **slug** (for example `sofas`) before you can inspect its attributes. Either find one by text, or grab it from a product you already have. ### Option A — Search for the category Use the category search endpoint to look up by free text: ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; const client = new Channel3(); const categoryResults = await client.categories.search({ query: "sofas" }); // Pick the best-matching category const category = categoryResults.categories[0]; console.log(category.slug); // e.g. "sofas" console.log(category.title); // "Sofas" ``` ```python Python theme={null} from channel3_sdk import Channel3 client = Channel3() category_results = client.categories.search(query="sofas") category = category_results.categories[0] print(category.slug) # e.g. "sofas" print(category.title) # "Sofas" ``` ```bash cURL theme={null} curl "https://api.trychannel3.com/v1/categories/search?query=sofas" \ -H "x-api-key: $CHANNEL3_API_KEY" ``` ### Option B — Grab the category from an existing product If you already have a representative product — from a search result, lookup, or your own catalog — read its `category.slug` instead of searching: ```typescript TypeScript theme={null} const product = await client.products.retrieve("2yh8WH5"); const slug = product.category.slug; // e.g. "sofas" ``` ```python Python theme={null} product = client.products.retrieve("2yh8WH5") slug = product.category.slug # e.g. "sofas" ``` ```bash cURL theme={null} curl "https://api.trychannel3.com/v1/products/2yh8WH5" \ -H "x-api-key: $CHANNEL3_API_KEY" ``` *** ## Step 2 — Retrieve category detail to see its attributes Call the category detail endpoint with the slug to get the full list of attributes for that category. Each attribute has a `handle` (the key you'll pass to the filter) and a list of known values. ```typescript TypeScript theme={null} const categoryDetail = await client.categories.retrieve("sofas"); // Print all attributes and their example values for (const attr of categoryDetail.attributes) { console.log(`${attr.handle}: ${attr.values.slice(0, 5).join(", ")}`); } // connectivity: USB, Bluetooth, None // material: Leather, Velvet, Linen, Microfiber, ... // seating_capacity: 2, 3, 4, Sectional // style: Mid-Century Modern, Contemporary, ... // color: Beige, Gray, Navy, ... ``` ```python Python theme={null} category_detail = client.categories.retrieve("sofas") for attr in category_detail.attributes: print(f"{attr.handle}: {', '.join(attr.values[:5])}") # connectivity: USB, Bluetooth, None # material: Leather, Velvet, Linen, Microfiber, ... # seating_capacity: 2, 3, 4, Sectional # style: Mid-Century Modern, Contemporary, ... ``` ```bash cURL theme={null} curl "https://api.trychannel3.com/v1/categories/sofas" \ -H "x-api-key: $CHANNEL3_API_KEY" ``` The attributes available vary by category. Always retrieve category detail first — don't guess attribute handles. *** ## Step 3 — Search with the attribute filter Now you have the attribute key and its accepted values. Pass them to `POST /v1/search` via the `attributes` filter. The `attributes` filter takes a map of `handle → [values]`. ```typescript TypeScript theme={null} const results = await client.products.search({ query: "sofa", filters: { category: "sofas", attributes: { connectivity: ["USB"], }, }, limit: 20, }); console.log(`Found ${results.products.length} sofas with USB charging`); results.products.forEach((p) => { console.log(p.title, p.offers[0]?.price); }); ``` ```python Python theme={null} results = client.products.search( query="sofa", filters={ "category": "sofas", "attributes": { "connectivity": ["USB"], }, }, limit=20, ) print(f"Found {len(results.products)} sofas with USB charging") for p in results.products: print(p.title, p.offers[0].price if p.offers else "") ``` ```bash cURL theme={null} curl -X POST https://api.trychannel3.com/v1/search \ -H "x-api-key: $CHANNEL3_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "query": "sofa", "filters": { "category": "sofas", "attributes": { "connectivity": ["USB"] } }, "limit": 20 }' ``` *** ## Full end-to-end example Here's the complete three-step flow in a single function — discover the category, inspect its attributes, then search: ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; const client = new Channel3(); async function findSofasWithUSB() { // 1. Find the category const { categories } = await client.categories.search({ query: "sofas" }); const slug = categories[0].slug; // "sofas" // 2. Inspect its attributes const detail = await client.categories.retrieve(slug); const connectivityAttr = detail.attributes.find( (a) => a.handle === "connectivity", ); if (!connectivityAttr?.values.includes("USB")) { console.warn("USB not listed as a connectivity value for this category"); } // 3. Search with the attribute filter const results = await client.products.search({ query: "sofa", filters: { category: slug, attributes: { connectivity: ["USB"] }, }, limit: 20, }); return results.products; } findSofasWithUSB().then((products) => { console.log(`Found ${products.length} sofas with USB ports:`); products.forEach((p) => console.log(" -", p.title)); }); ``` ```python Python theme={null} from channel3_sdk import Channel3 client = Channel3() def find_sofas_with_usb(): # 1. Find the category category_results = client.categories.search(query="sofas") slug = category_results.categories[0].slug # "sofas" # 2. Inspect its attributes detail = client.categories.retrieve(slug) connectivity = next( (a for a in detail.attributes if a.handle == "connectivity"), None ) if connectivity and "USB" not in connectivity.values: print("Warning: USB not listed as a connectivity value for this category") # 3. Search with the attribute filter results = client.products.search( query="sofa", filters={ "category": slug, "attributes": {"connectivity": ["USB"]}, }, limit=20, ) return results.products products = find_sofas_with_usb() print(f"Found {len(products)} sofas with USB ports:") for p in products: print(f" - {p.title}") ``` *** ## Combining multiple attributes Pass multiple keys to narrow further. Values within a key are OR'd; keys are AND'd — so the example below finds sofas that are `(USB OR Bluetooth)` connectivity **and** Velvet material: ```typescript TypeScript theme={null} const results = await client.products.search({ query: "sofa", filters: { category: "sofas", attributes: { connectivity: ["USB", "Bluetooth"], material: ["Velvet"], }, }, }); ``` ```python Python theme={null} results = client.products.search( query="sofa", filters={ "category": "sofas", "attributes": { "connectivity": ["USB", "Bluetooth"], "material": ["Velvet"], }, }, ) ``` *** ## Reading `structured_attributes` on a product Products returned from `/v1/products/{id}` and `/v1/lookup` include a `structured_attributes` field — a map of attribute handles to their extracted values for that specific product. Use it to display feature chips on a PDP, or to understand what attributes a specific product carries. ```typescript TypeScript theme={null} const product = await client.products.retrieve("2yh8WH5"); const attrs = product.structured_attributes; // { // connectivity: "USB", // material: "Velvet", // color: "Navy Blue", // seating_capacity: "3", // } console.log(`Connectivity: ${attrs.connectivity}`); console.log(`Material: ${attrs.material}`); ``` `structured_attributes` is populated on product detail (`GET /v1/products/{id} ` and `POST /v1/lookup`). It is **not** returned on search results. *** # Agentic Search Source: https://docs.trychannel3.com/guides/agentic-search Let an LLM decompose complex, multi-constraint queries into structured sub-searches for higher-quality results. Set `config.mode: "agentic"` on [`POST /v1/search`](/api-reference/v1/search) when queries read like a person describing what they want rather than a keyword phrase. An LLM decomposes the query into a structured plan — brands, retailers, category, gender, age, condition, price range, colors, and product attributes — then runs multiple structured sub-searches and merges them into one ranked result list. ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; const client = new Channel3(); // reads CHANNEL3_API_KEY from env const results = await client.products.search({ query: "waterproof trail running shoes for wide feet under $120", config: { mode: "agentic" }, }); ``` ```python Python theme={null} from channel3_sdk import Channel3 client = Channel3() # reads CHANNEL3_API_KEY from env results = client.products.search( query="waterproof trail running shoes for wide feet under $120", config={"mode": "agentic"}, ) ``` ```bash cURL theme={null} curl -X POST https://api.trychannel3.com/v1/search \ -H "x-api-key: $CHANNEL3_API_KEY" \ -H "Content-Type: application/json" \ -d '{"query": "waterproof trail running shoes for wide feet under $120", "config": {"mode": "agentic"}}' ``` ## Default vs. agentic Default search already does some entity extraction on your query. Agentic search goes much further: * **Rich filter extraction** — extracts constraints across all `SearchFilters`: price, brands, websites, gender, age, condition, availability, colors, and category. * **Multiple queries** — plans and runs several searches, then intelligently picks the quality results from across them. * **Structured attribute enrichment** — parses implied categories and features out of the query and deterministically filters products down to only those that match the attributes. ## Everything else works the same The request and response shapes are identical to `default` mode. Explicit `filters` are combined with what the planner extracts, and pagination via `next_page_token` works as usual. Text search, filters, pagination, and the other search modes. Build structured attribute filters yourself for full control. # Brand Search Source: https://docs.trychannel3.com/guides/brand-search Find brands in the catalog, then filter future searches by brand. The `brand_ids` filter on `POST /v1/search` limits results to products from specific brands. Brand IDs are stable identifiers you resolve once via the brands API and then reuse. **What's the difference between brands and websites?** A **brand** makes or labels a product (Nike, Dyson). A **website** is the online store selling it (`nike.com`, `bestbuy.com`). Use `brand_ids` to filter by brand and `website_ids` to filter by retailer — they're independent. One brand's products often appear on many websites. See the [Brand](/api-reference/brand-model) and [Website](/api-reference/website-model) models. ## Step 1 — Resolve brand IDs Use `GET /v1/brands/search` to find a brand by name and retrieve its ID. ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; const client = new Channel3(); const brands = await client.brands.search({ query: "Nike" }); const nikeId = brands.brands[0].id; console.log(nikeId); // e.g. "brand_nike_abc123" ``` ```python Python theme={null} from channel3_sdk import Channel3 client = Channel3() brands = client.brands.search(query="Nike") nike_id = brands.brands[0].id print(nike_id) # e.g. "brand_nike_abc123" ``` ```bash cURL theme={null} curl "https://api.trychannel3.com/v1/brands/search?query=Nike" \ -H "x-api-key: $CHANNEL3_API_KEY" ``` ## Step 2 — Filter search results by brand Pass the resolved ID (or IDs) to the `brand_ids` filter. ```typescript TypeScript theme={null} const results = await client.products.search({ query: "running shoes", filters: { brand_ids: [nikeId], }, }); ``` ```python Python theme={null} results = client.products.search( query="running shoes", filters={"brand_ids": [nike_id]}, ) ``` ```bash cURL theme={null} curl -X POST https://api.trychannel3.com/v1/search \ -H "x-api-key: $CHANNEL3_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "query": "running shoes", "filters": { "brand_ids": ["brand_nike_abc123"] } }' ``` ## Filtering to multiple brands Pass multiple IDs to include products from any of the listed brands (OR logic). ```typescript TypeScript theme={null} const [nikeResult, adidasResult] = await Promise.all([ client.brands.search({ query: "Nike" }), client.brands.search({ query: "Adidas" }), ]); const results = await client.products.search({ query: "running shoes", filters: { brand_ids: [nikeResult.brands[0].id, adidasResult.brands[0].id], }, }); ``` ## Browsing all brands Use `GET /v1/brands` to list brands or `GET /v1/brands/{brand_id}` to retrieve a specific brand by its ID. ```typescript TypeScript theme={null} // List brands (paginated) const allBrands = await client.brands.list({ limit: 50 }); // Retrieve a specific brand const brand = await client.brands.retrieve("brand_nike_abc123"); console.log(brand.name, brand.logo_url); ``` ```python Python theme={null} all_brands = client.brands.list(limit=50) brand = client.brands.retrieve("brand_nike_abc123") print(brand.name, brand.logo_url) ``` Full API reference for the brands endpoints. Full overview of the search endpoint and all available filters. # Caching Best Practices Source: https://docs.trychannel3.com/guides/caching How to cache Channel3 data effectively without serving stale results. The recommended path for most integrations is **real-time product discovery** via the [`/search`](/v1/search) endpoint. The guidance below is for use cases where product IDs are stored and revisited later, such as: * **Persisted carts or "saved for later" collections** — users bookmark products and return to them hours or days later * **Hand-curated shopping experiences** — developers select specific products for display, typically originally discovered via [`/search`](/v1/search) or [`/lookup`](/v1/lookup) ## Cache IDs, not data Product IDs and category slugs are stable identifiers — cache them freely and for as long as you like. Everything else on a product object (prices, availability, images, descriptions, offers, variants) should be treated as **unstable**. These fields can change at any time as merchants update their catalogs. Retrieve fresh product snapshots at load time with the **free** [`GET /v1/products/{product_id}`](/v1/products/\{product_id}). **Do:** * Store `product.id` from search results and reuse it later **Don't:** * Cache prices, availability, or offer URLs and serve them to users without refreshing * Assume image URLs or product descriptions are permanent * Cache offer URLs — these are short-lived and must be fetched fresh before presenting to users ## Refresh at load time When you need to display a product to a user, fetch the latest data with [`GET /v1/products/{product_id}`](/v1/products/\{product_id}) rather than relying on a cached snapshot. This ensures prices, stock status, and buy links are current. ```typescript TypeScript theme={null} // At search time — cache the IDs const results = await client.products.search({ query: "running shoes" }); const productIds = results.products.map((p) => p.id); // store productIds in your database or session // At display time — fetch fresh data const product = await client.products.retrieve(productId); ``` ```python Python theme={null} # At search time — cache the IDs results = client.products.search(query="running shoes") product_ids = [p.id for p in results.products] # store product_ids in your database or session # At display time — fetch fresh data product = client.products.retrieve(product_id) ``` ## Short-lived caches are fine Caches with a short TTL (a few minutes to a few hours) on full product objects for presentational data (images, title) is reasonable for use cases that require it. Just avoid caching product data for many hours or days — pricing and availability can shift quickly, and we often update our data model to include new features and info. | Data | Cache strategy | | -------------------------------------------- | -------------------------------------- | | Product IDs, category slugs | Cache indefinitely | | Product details (title, description, images) | Short TTL or refresh on display | | Prices, availability, offers | Always refresh before showing to users | Full overview of the search endpoint, filters, and pagination. Set country, language, and currency for market-specific results. # Cleaned Images Source: https://docs.trychannel3.com/guides/cleaned-images Prefer square, uniform-background product images for consistent grids. Product images on the `ProductImage` type include an `is_cleaned_image` flag. When `true`, the image has a square aspect ratio and a uniform background — ideal for product grids where raw retailer shots would mix on-model photos and mismatched aspect ratios. ## Prefer cleaned images in grids When displaying search or similar-product results, pick the cleaned image when one is available: ```typescript TypeScript theme={null} const heroImage = product.images.find(img => img.is_cleaned_image) ?? product.images[0]; ``` This works on any product response that includes `images` — search, lookup, and product detail all expose the same `ProductImage` model. Visual search is a common place to surface cleaned images in a grid. Combine color filters with cleaned images for palette-matched, uniform grids. Channel3 components can prefer cleaned images in product cards automatically. # Color Filters Source: https://docs.trychannel3.com/guides/color-filters Filter products by color palette using hex values to find items that match a specific color scheme. Color filtering is currently in **Beta**. The API surface may change. The `colors` filter on `POST /v1/search` accepts one or more hex color values and returns products whose dominant colors match the palette. This is useful for building color-matched shopping experiences — for example, finding furniture or clothing that complements a specific color scheme. ``` KitDen chat widget returning two on-budget product picks with an AI rationale Teach your coding agent the Channel3 API for faster integration. The React component catalog and shadcn registry. Credits, free tier, and commission split. Questions or a brand request? We're happy to help. Building with Cursor or Claude Code alongside Lovable? Install the Channel3 API skill in your terminal: `npx skills add channel3-ai/skills --skill channel3-api`. See [Channel3 API skill](/skills/channel3-api). (Terminal agents only — not the Lovable chat box.) # MCP Source: https://docs.trychannel3.com/mcp-overview Add the Channel3 MCP to your agent ## What is the Channel3 MCP? The Channel3 MCP gives your AI agents superpowers for product discovery. Your agent can search through tens of millions of real products in real-time, complete with current prices, rich images, detailed descriptions, and real-time availability. ## Quick Start (Free Tier) No API key required. Connect directly and start searching: ``` https://mcp.trychannel3.com/ ``` ## Unlimited Access The Channel3 MCP has a generous free tier. For pay-as-you-go usage, create an account and add your API key. 1. [Create an account](https://trychannel3.com) and generate an API key. 2. Append `?apiKey=` to the MCP URL: ``` https://mcp.trychannel3.com/?apiKey= ``` ## Setup Install in Cursor Or manually add to `~/.cursor/mcp.json`: ```json theme={null} { "mcpServers": { "Channel3": { "url": "https://mcp.trychannel3.com/" } } } ``` Install in VS Code Or manually add to `.vscode/mcp.json`: ```json theme={null} { "servers": { "Channel3": { "type": "http", "url": "https://mcp.trychannel3.com/" } } } ``` ```bash theme={null} claude mcp add --transport http Channel3 "https://mcp.trychannel3.com/" ``` Add to your Claude Desktop config file: **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json` **Windows:** `%APPDATA%\Claude\claude_desktop_config.json` ```json theme={null} { "mcpServers": { "Channel3": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.trychannel3.com/sse"] } } } ``` ```bash theme={null} codex mcp add Channel3 --url https://mcp.trychannel3.com/ ``` ```json theme={null} { "mcp": { "Channel3": { "type": "remote", "url": "https://mcp.trychannel3.com/", "enabled": true } } } ``` That's it! Your agent can now find any product online. # Webhooks Source: https://docs.trychannel3.com/price-tracking-webhooks Receive real-time notifications when prices change for your tracked products. When you subscribe to price tracking for a product, you can receive webhook notifications whenever the price changes. Use webhooks to alert your users about deals, update your UI, or trigger other actions in real-time. Configure your webhook endpoint in the [Channel3 dashboard](https://trychannel3.com/dashboard). For payload details and event types, see our [webhook event catalog](https://webhooks.trychannel3.com/). # Pricing Source: https://docs.trychannel3.com/pricing Our goal is for you to make much more money on Channel3 than you spend on it, and we've designed our pricing to make that happen. **Each API call is one credit. You get 1000 free credits every month, and extra credits cost just \$0.007.** Looking for bulk pricing or higher commission rates? Contact us. We take a 50% cut of commissions paid out on our platform. This rate will reduce as you drive more sales. | Method | Cost | | --------------- | -------------------- | | /search | 1 credit | | /image-search | 1 credit | | /similar | 1 credit | | /lookup | 1 credit | | /brands | Free | | /websites | Free | | /products | Free | | /categories | Free | | /price-tracking | 1 credit/product/day | # Product Source: https://docs.trychannel3.com/product-model # SDK Source: https://docs.trychannel3.com/sdk Get started with the Channel3 SDKs for TypeScript and Python. ## Installation ```typescript TypeScript theme={null} // npm npm install @channel3/sdk // yarn yarn add @channel3/sdk // pnpm pnpm add @channel3/sdk ``` ```python Python theme={null} # pip pip install channel3-sdk # uv uv add channel3-sdk ``` ## Authentication You can provide your API key using the `CHANNEL3_API_KEY` environment variable, or by passing it directly to the client. ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; // Initialize with environment variable const client = new Channel3(); // Or, initialize with API key directly const clientWithKey = new Channel3({ apiKey: "your_api_key_here", }); ``` ```python Python theme={null} from channel3_sdk import Channel3, AsyncChannel3 # Initialize with environment variable client = Channel3() # Or, initialize with API key directly client_with_key = Channel3(api_key="your_api_key_here") # Async client async_client = AsyncChannel3() ``` ## Default locale Set a default locale once on the client and it'll apply to every search and product detail call. Per-call values (e.g. `config.country` on search, `?country=` on product detail) override the client default. ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; const client = new Channel3({ country: "GB", currency: "GBP", }); // Uses GB / GBP await client.products.search({ query: "raincoat" }); // Override per-call (returns DE / EUR offers regardless of the client default) await client.products.search({ query: "raincoat", config: { country: "DE", currency: "EUR" }, }); ``` ```python Python theme={null} from channel3_sdk import Channel3 client = Channel3(country="GB", currency="GBP") client.products.search(query="raincoat") client.products.search( query="raincoat", config={"country": "DE", "currency": "EUR"}, ) ``` You can also set defaults via environment variables: `CHANNEL3_LANGUAGE`, `CHANNEL3_COUNTRY`, `CHANNEL3_CURRENCY`. The same pattern applies to dimension units — set `lengthUnit` / `weightUnit` on the client (or `CHANNEL3_LENGTH_UNIT` / `CHANNEL3_WEIGHT_UNIT`) to choose the units dimensions come back in. See [Dimension units](/guides/localization#dimension-units). When only `country` is set, the server infers `currency` (e.g. `GB` → `GBP`) and `language` (e.g. `GB` → `en`). When all three are unset, defaults to `en` / `US` / `USD`. ## Usage All top-level endpoints are available as properties on the client. For example, to use the `search` endpoint: ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; const client = new Channel3(); async function main() { const response = await client.products.search({ query: "organic cotton t-shirt", }); console.log(response); } main(); ``` ```python Python theme={null} from channel3_sdk import Channel3 client = Channel3() def main(): response = client.products.search( query="organic cotton t-shirt" ) print(response) if __name__ == "__main__": main() ``` ## Async usage ```typescript TypeScript theme={null} import Channel3 from "@channel3/sdk"; const client = new Channel3(); async function main() { const response = await client.products.search({ query: "organic cotton t-shirt", }); console.log(response); } main(); ``` ```python Python theme={null} import asyncio from channel3_sdk import AsyncChannel3 client = AsyncChannel3() async def main(): response = await client.products.search( query="organic cotton t-shirt" ) print(response) if __name__ == "__main__": asyncio.run(main()) ``` Filters, pagination, image search, product detail, brands, categories, and error handling. # Channel3 API Skill Source: https://docs.trychannel3.com/skills/channel3-api Teach your coding agent how to integrate Channel3 into your app or service The Channel3 API skill is for anyone building with Channel3 — whether you're wiring up a backend, shipping a Lovable app, or adding search to an existing codebase. It gives your coding agent (Claude Code, Cursor, Codex, and others) the API reference, examples, and integration patterns it needs to add Channel3 to your project. ## Install ```bash theme={null} npx skills add channel3-ai/skills --skill channel3-api ``` ## Use it Once installed, paste this prompt into your agent to get started: ```text theme={null} Help me integrate Channel3 into my project using the Channel3 API skill. ``` Ask your agent to use the Channel3 API skill whenever you need to integrate Channel3 — search, product detail, variants, localization, and more. Building on [Lovable](/lovable)? Install this skill in your terminal (Cursor, Claude Code, etc.) alongside Lovable — your terminal agent can wire up Channel3 APIs and edge functions while Lovable handles the UI. The skill does not run inside the Lovable chat box. ## Source View the skill source, open issues, or contribute on GitHub. # Product Discovery Skill Source: https://docs.trychannel3.com/skills/product-discovery Let an existing agent search products, compare prices, and check availability on demand The product discovery skill is for an existing agent, workflow, or harness that needs to search products, compare prices, or check availability directly during a conversation. It is not for integrating Channel3 APIs into a service — use the [Channel3 API skill](/skills/channel3-api) or [MCP server](/mcp-overview) for that. ## Install ```bash theme={null} npx skills add channel3-ai/skills --skill product-discovery ``` ## Use it Once installed, your agent can search the Channel3 catalog on demand. Try a prompt like: ```text theme={null} Use the product discovery skill to find running shoes under $150 and compare the top options. ``` ## Source View the skill source, open issues, or contribute on GitHub. # About the catalog Source: https://docs.trychannel3.com/ucp/about-catalog The three catalog tools and how requests are shaped **`ucp.trychannel3.com`** is one catalog across many online stores. It uses the same product data as the Channel3 REST API. ## Three tools | Tool | Use it when you want to... | | ---------------- | ------------------------------------------------------- | | `search_catalog` | Find products from a text query | | `lookup_catalog` | Load products you already know by id or store URL | | `get_product` | Load one product by id, with optional variant selection | ## How to shape a request Every tool takes the same outer shape: ```json theme={null} { "meta": null, "catalog": { } } ``` * **`catalog`** — your query (`query`, `ids`, `urls`, `id`, `selected`, `preferences`, `pagination`, filters, `context` for currency or country) * **`meta`** — pass `null` on Channel3 today ([details](/ucp/about-profiles#what-is-meta)) The answer lives in **`structuredContent`**: `products`, `pagination`, and sometimes `messages`. ## Channel3 extras Base UCP gives you title, price, variants, and store domain. For filters by store, richer seller info, and URL lookup, use extension **`com.trychannel3.catalog.global`**. Details: [Extension reference](/ucp/catalog-global-extension). ## Same as REST | Tool | REST equivalent | | ---------------------------- | -------------------------------------------------------------- | | `search_catalog` | `POST /v1/search` | | `lookup_catalog` with `ids` | `POST /v1/lookup` | | `lookup_catalog` with `urls` | `POST /v1/lookup` (URL) | | `get_product` | `GET /v1/products/{id}` (`option_=