# Advanced Features Source: https://docs.getclaro.ai/advanced_features Dedicated-plan capabilities for high-volume, enterprise-grade catalog operations. The features on this page are available on Dedicated plans. They extend the core platform for organizations running catalogs at scale, with requirements around custom models, real-time predictions, human feedback loops, and bespoke integrations. *** ## Taxonomy generation & dynamic ontology Generate sophisticated multi-level taxonomies from your data and keep them evolving as your catalog grows. * **Multi-level hierarchy** — 3–8 levels deep based on data complexity, auto-detected. * **Semantic relationship mapping** — relationships between nodes are explicit and queryable. * **Dynamic ontology evolution** — as new data patterns emerge, Claro proposes taxonomy extensions for review. * **Cross-domain merging** — consolidate taxonomies from multiple catalogs or data sources into a unified structure. * **Industry-standard templates** — GS1, Google Product, UNSPSC as starting points. * **Validation** — automated consistency checking flags contradictions, orphaned nodes, and coverage gaps. For the standard (non-Dedicated) version, see [Taxonomy](/taxonomy) and the [Generate Taxonomy operation](/operations#generate-taxonomy-beta). *** ## Entity deduplication & resolution Enterprise-grade entity matching that goes beyond string comparison. * **Fuzzy string matching** — configurable similarity thresholds per field. * **Phonetic matching** — handles name variations and misspellings across locales. * **ML-powered semantic similarity** — embedding-based matching for product names, descriptions, and addresses. * **Cross-field correlation** — match entities across different attribute combinations, not just a single key. * **Probabilistic record linkage** — scored match proposals with explicit confidence. * **Negative-example learning** — rejected pairs are remembered and suppress similar proposals. * **Custom matching rules** — domain-specific business logic (e.g. match on GTIN first, fall back to brand + MPN). For the standard version, see [Similarity & Duplicate](/similarity_duplicate) and [Find Duplicates](/operations#find-duplicates-beta). *** ## Near real-time predictions (\< 200 ms) Ultra-low-latency prediction endpoints for production environments where speed is critical. * **Dedicated GPU clusters** with model caching — no cold start. * **Edge deployment** — geographic optimization for latency-sensitive use cases. * **Auto-scaling** — matches request volume without provisioning. * **SLA guarantees** — 99.9% uptime with real-time monitoring and alerting. * **Load balancing** across multiple regions. **Use cases:** Live product recommendations, real-time content moderation, instant classification at point of entry, dynamic pricing feedback. *** ## Human-in-the-loop feedback system Systematic expert review that makes models continuously better over time. * **Review interface** — domain experts approve, correct, or flag AI outputs with an annotation tool. * **Confidence calibration** — expert agreement is tracked and used to refine scoring algorithms. * **Automated retraining** — daily (or configurable: hourly / weekly) model updates incorporating all accumulated feedback. * **Performance tracking** — dashboards showing improvement over time per operation and per attribute. * **Multi-expert consensus** — track agreement across reviewers for contested cases. * **A/B testing framework** — compare model versions before promoting to production. * **Expert validation** — optional gating of model updates behind expert sign-off before deployment. For standard review workflows, see [Notifications](/notifications). *** ## Advanced API integration hub Connect Claro to proprietary datasets and specialized external services. * **Proprietary dataset access** — direct connections to internal databases, data lakes, and enterprise systems. * **Domain-specific APIs** — industry databases, patent systems, regulatory filings, ERP and PIM solutions. * **Auth management** — OAuth, API keys, certificate-based, and custom schemes. * **Data transformation pipelines** — ETL for complex format conversions before values land in the catalog. * **Intelligent caching** — responses are cached to reduce cost and improve latency on repeated lookups. * **Rate-limit management** — quota handling across multiple providers, with backoff and retry. For standard inbound and outbound connectors, see [Data Import & Ingestion](/data_import_ingestion) and [Distribute](/modules/distribute). *** ## Custom analytics A BI suite surfacing catalog health, operation performance, and team activity across the workspace. * Interactive dashboards — configurable per team and per catalog. * Real-time monitoring of operation run metrics. * Data quality trends over time. * Credit consumption and efficiency breakdowns. * Export to BigQuery or BI tools via Webhooks. *** ## Self-hosting Run Claro in your own infrastructure: * **Kubernetes Helm chart** — deploy to any cluster. * **Managed VPC** — Claro sets up a dedicated environment in your cloud account. * **Air-gapped** — fully isolated deployment with no external calls. * **On-premises** — bare-metal or private cloud. Contact your success team for deployment architecture and sizing guidance. *** ## Getting access All features on this page require a Dedicated plan. Talk to us at **[hello@getclaro.ai](mailto:hello@getclaro.ai)** or schedule a call from the dashboard. We'll scope the right configuration for your catalog volume and use case. # AI Tasks Overview Source: https://docs.getclaro.ai/ai_tasks The AI capabilities behind Claro's operations — classification, generation, web enrichment, geolocation, and document extraction. AI Tasks are the building blocks behind Claro's operations and Research Agents. They're rarely invoked directly anymore — Operations like **Bulk Enrichment** and **Generative Engine** wrap them in catalogue-aware workflows with confidence, provenance, and review built in. This page documents each capability so you can choose the right one when configuring an operation or a Research Agent run. *** ## Capabilities * Classification * Generation * Web Enrichment * Geolocation Enrichment * File Extraction * Advanced OCR ### Model selection Most tasks support multiple models. Claro's proprietary model is the default — it generates confidence scores and citations alongside outputs, which makes it the right choice when a task feeds back into a catalogue. Other models are available for specialized use cases with variable pricing. ### Credit consumption Credits are consumed per record. Cost depends on the model and the task type. Failed tasks consume zero credits. *** ### Classification Categorize and tag records with consistent labels. **How it works** — compares each record against your defined categories or asks the model to suggest classifications based on patterns in your data. **Used by** — Bulk Enrichment with a target enum or reference attribute, Generate Taxonomy proposal review, Validate Data rule routing. **Tips** * Works best with ≤ 50 categories per task; for larger label sets use Generate Taxonomy first to build hierarchy. * Provide 2–3 examples per category in the prompt. * Adjust the confidence threshold per attribute, not globally. ### Generation Create or rewrite text content tailored to your specifications. **How it works** — language models produce new content based on the prompt and other attributes on the record. **Used by** — Generative Engine (descriptions, marketing copy, alt-text, translations), SEO Report (suggestions). **Tips** * Specify exact length and format constraints. * Reference other attributes with `@attribute_name` to ground generation. * Attach Knowledge Bases for brand voice and category consistency. ### Web Enrichment Research live information from across the web to enhance records. **How it works** — searches the web for relevant information, extracts key details, and provides citations. **Used by** — Bulk Enrichment with web search as the source. **Tips** * Cannot access paywalled or private content. * Quality scales with how well-known the entity is. * Always keep citations on; review at least the bottom 10% by confidence before raising auto-apply. ### Geolocation Enrichment Transform addresses into rich geographic data and nearby points of interest. **How it works** — converts addresses to coordinates and optionally finds surrounding businesses and amenities. **Used by** — Bulk Enrichment for address-bearing catalogues, the *Find your perfect list* Research Agent. **Tips** * Less accurate for rural or remote locations. * P.O. boxes cannot be geocoded. * Use a tight radius (1–2 km) in dense urban areas. ### File Extraction Extract structured data from PDFs, invoices, forms, and documents — without templates. **How it works** — AI-powered document parser identifies and extracts specific fields against a target schema. **Used by** — *Turn documents into structured data* Research Agent, Bulk Enrichment when the source is a Knowledge Base of supplier datasheets. **Tips** * Specify the exact fields you need. * Group related documents into one Knowledge Base for re-use across many extractions. * Use Advanced OCR for low-quality scans, handwriting, or complex layouts. ### Advanced OCR Extract text from low-quality, handwritten, or complex visual documents. **How it works** — vision-AI pipeline optimized for documents that standard OCR cannot handle. **Used by** — File Extraction as a fallback, *Turn documents into structured data* with the *advanced OCR* option enabled. **Tips** * Try standard File Extraction first — it's faster and cheaper. * Improve scan quality before extraction when you can. * Break very long documents into sections. *** ## Setting up an AI task inside an operation When you configure **Bulk Enrichment** or **Generative Engine**, the same building blocks appear: * **Prompt** — reference attributes with `@attribute_name`. Be specific about format and length. * **Knowledge Bases** — attach domain documents for grounding and citation. * **Model** — choose Claro default for confidence + citations, or another model for specialized cases. * **Confidence thresholds** — auto-apply, review, reject. Defaults are conservative. * **Output format** — text, structured (per the target attribute's type), or multi-value. *** ## Where AI tasks fit in the platform | Surface | How AI tasks are used | | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- | | **Catalogue Operations** | Wrapped in operations (Bulk Enrichment, Generative Engine, Validate, Normalize, Find Duplicates, etc.) with confidence, provenance, and review. | | **Research Agents** | Wrapped in agent flows for one-off datasets — list-building, document parsing, scraping, spreadsheet enrichment. | | **Knowledge Bases** | Attached to operations and agents to ground outputs in domain documents. | For most users the right entry points are [Operations](/operations) and [Research Agents](/research_agents). This page is the underlying reference. # Supplier Matching & Comparison Source: https://docs.getclaro.ai/api-reference/comparison Run supplier-finding and catalogue-comparison workflows. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## Start supplier finding POST `/objects/{objectId}/supplier-finding` Start supplier finding through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "row_id": "00000000-0000-4000-8000-000000000003", "min_suppliers": 10, "search_tier": "focus" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/supplier-finding" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "row_id": "00000000-0000-4000-8000-000000000003", "min_suppliers": 10, "search_tier": "focus" }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/supplier-finding" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "row_id": "00000000-0000-4000-8000-000000000003", "min_suppliers": 10, "search_tier": "focus" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/supplier-finding`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "row_id": "00000000-0000-4000-8000-000000000003", "min_suppliers": 10, "search_tier": "focus" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Generate catalogue comparison details POST `/objects/comparison/details/stream` Generate catalogue comparison details through the Claro Public API. **Required scopes:** `objects`, `team` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/comparison/details/stream" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/objects/comparison/details/stream" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/comparison/details/stream`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.text(); ``` ### Responses * `200` - Server-sent workflow events * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Generate catalogue product matches POST `/objects/comparison/product-matches/stream` Generate catalogue product matches through the Claro Public API. **Required scopes:** `objects`, `team` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/comparison/product-matches/stream" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/objects/comparison/product-matches/stream" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/comparison/product-matches/stream`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierId": "00000000-0000-4000-8000-000000000002" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.text(); ``` ### Responses * `200` - Server-sent workflow events * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get saved comparison statuses POST `/objects/comparison/results/status` Get saved comparison statuses through the Claro Public API. **Required scopes:** `objects`, `team` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "primaryId": "00000000-0000-4000-8000-000000000001", "supplierIds": [ "00000000-0000-4000-8000-000000000002" ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/comparison/results/status" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierIds": [ "00000000-0000-4000-8000-000000000002" ] }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/objects/comparison/results/status" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierIds": [ "00000000-0000-4000-8000-000000000002" ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/comparison/results/status`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "primaryId": "00000000-0000-4000-8000-000000000001", "supplierIds": [ "00000000-0000-4000-8000-000000000002" ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get a saved catalogue comparison result GET `/objects/comparison/result` Get a saved catalogue comparison result through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------------ | -------- | ------ | -------- | | `primaryId` | query | string | Yes | | `supplierId` | query | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects/comparison/result?primaryId=YOUR_PRIMARY_ID&supplierId=YOUR_SUPPLIER_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/objects/comparison/result?primaryId=YOUR_PRIMARY_ID&supplierId=YOUR_SUPPLIER_ID" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/comparison/result?primaryId=YOUR_PRIMARY_ID&supplierId=YOUR_SUPPLIER_ID`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Review a catalogue product match POST `/objects/comparison/product-matches/{matchId}/review` Review a catalogue product match through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | --------- | -------- | ------ | -------- | | `matchId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "reviewStatus": "APPROVED" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/comparison/product-matches/$MATCH_ID/review" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "reviewStatus": "APPROVED" }' ``` ```python Python theme={null} import json import requests match_id = "YOUR_MATCH_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/comparison/product-matches/{match_id}/review" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "reviewStatus": "APPROVED" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const matchId = "YOUR_MATCH_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/comparison/product-matches/${matchId}/review`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "reviewStatus": "APPROVED" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Data Enrichment Source: https://docs.getclaro.ai/api-reference/enrichment Prepare catalogue data and run enrichment workflows. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## Prepare catalogue rows and columns for enrichment POST `/objects/{objectId}/prepare` Prepare catalogue rows and columns for enrichment through the Claro Public API. **Required scopes:** `objects`, `enrich` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "column_ids": [ "00000000-0000-4000-8000-000000000002" ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/prepare" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "column_ids": [ "00000000-0000-4000-8000-000000000002" ] }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/prepare" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "column_ids": [ "00000000-0000-4000-8000-000000000002" ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/prepare`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "column_ids": [ "00000000-0000-4000-8000-000000000002" ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Start table enrichment POST `/enrich` Start table enrichment through the Claro Public API. **Required scope:** `enrich` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "numRows": 10 } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/enrich" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "numRows": 10 }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/enrich" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "numRows": 10 }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/enrich`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "numRows": 10 }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Enrich multiple cells POST `/enrich/multiple-cells` Enrich multiple cells through the Claro Public API. **Required scope:** `enrich` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "cellIds": [ "00000000-0000-4000-8000-000000000007" ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/enrich/multiple-cells" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "cellIds": [ "00000000-0000-4000-8000-000000000007" ] }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/enrich/multiple-cells" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "cellIds": [ "00000000-0000-4000-8000-000000000007" ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/enrich/multiple-cells`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "projectId": "00000000-0000-4000-8000-000000000001", "tableId": "00000000-0000-4000-8000-000000000006", "cellIds": [ "00000000-0000-4000-8000-000000000007" ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Generate enrichment categories POST `/enrich/categories` Generate enrichment categories through the Claro Public API. **Required scope:** `enrich` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "prompt": "Categorize products by department", "projectId": "00000000-0000-4000-8000-000000000001" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/enrich/categories" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "prompt": "Categorize products by department", "projectId": "00000000-0000-4000-8000-000000000001" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/enrich/categories" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "prompt": "Categorize products by department", "projectId": "00000000-0000-4000-8000-000000000001" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/enrich/categories`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "prompt": "Categorize products by department", "projectId": "00000000-0000-4000-8000-000000000001" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Data Quality & Export Source: https://docs.getclaro.ai/api-reference/export Run deduplication workflows and export duplicate, unified, or catalogue data. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## Run deduplication POST `/generate/dedupe` Run deduplication through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] }, "column1": "name", "column2": "supplier", "channelId": "dedupe-progress" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/dedupe" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] }, "column1": "name", "column2": "supplier", "channelId": "dedupe-progress" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/dedupe" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] }, "column1": "name", "column2": "supplier", "channelId": "dedupe-progress" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/dedupe`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] }, "column1": "name", "column2": "supplier", "channelId": "dedupe-progress" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Export duplicate records POST `/generate/dedupe/export/duplicates` Export duplicate records through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "matches": [ { "match_type": "exact" } ], "file1_headers": [ "name" ], "file2_headers": [ "supplier" ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/dedupe/export/duplicates" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "matches": [ { "match_type": "exact" } ], "file1_headers": [ "name" ], "file2_headers": [ "supplier" ] }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/dedupe/export/duplicates" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "matches": [ { "match_type": "exact" } ], "file1_headers": [ "name" ], "file2_headers": [ "supplier" ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() content = response.content ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/dedupe/export/duplicates`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "matches": [ { "match_type": "exact" } ], "file1_headers": [ "name" ], "file2_headers": [ "supplier" ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.arrayBuffer(); ``` ### Responses * `200` - Generated export * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Export unified records POST `/generate/dedupe/export/unified` Export unified records through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "mergeStrategy": "keep_file1", "matches": [], "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] } } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/dedupe/export/unified" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "mergeStrategy": "keep_file1", "matches": [], "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] } }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/dedupe/export/unified" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "mergeStrategy": "keep_file1", "matches": [], "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] } }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() content = response.content ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/dedupe/export/unified`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "mergeStrategy": "keep_file1", "matches": [], "file1_data": { "headers": [ "name" ], "rows": [ { "name": "Acme" } ] }, "file2_data": { "headers": [ "supplier" ], "rows": [ { "supplier": "ACME Ltd" } ] } }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.arrayBuffer(); ``` ### Responses * `200` - Generated export * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Run catalogue export POST `/catalogue-export/templates/{templateId}/export` Run catalogue export through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------------ | -------- | ------ | -------- | | `templateId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "gatingMode": "export_passing_rows" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/catalogue-export/templates/$TEMPLATE_ID/export" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "gatingMode": "export_passing_rows" }' ``` ```python Python theme={null} import json import requests template_id = "YOUR_TEMPLATE_ID" url = f"https://platform.getclaro.ai/api/public/v1/catalogue-export/templates/{template_id}/export" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "gatingMode": "export_passing_rows" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() content = response.content ``` ```javascript JavaScript theme={null} const templateId = "YOUR_TEMPLATE_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/catalogue-export/templates/${templateId}/export`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "gatingMode": "export_passing_rows" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.arrayBuffer(); ``` ### Responses * `200` - Generated export * `Default` - Error response. Rate-limited responses use HTTP 429. # AI Workflows Source: https://docs.getclaro.ai/api-reference/generate Run agentic generation and FindAll discovery workflows. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## Start an agentic list POST `/generate/list` Start an agentic list through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "prompt": "Find European ecommerce software suppliers", "min_rows": 10, "search_tier": "focus" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/list" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "prompt": "Find European ecommerce software suppliers", "min_rows": 10, "search_tier": "focus" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/list" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "prompt": "Find European ecommerce software suppliers", "min_rows": 10, "search_tier": "focus" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/list`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "prompt": "Find European ecommerce software suppliers", "min_rows": 10, "search_tier": "focus" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Generate criteria POST `/generate/criteria` Generate criteria through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "prompt": "Find sustainable packaging suppliers" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/criteria" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "prompt": "Find sustainable packaging suppliers" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/criteria" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "prompt": "Find sustainable packaging suppliers" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/criteria`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "prompt": "Find sustainable packaging suppliers" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Clarify a prompt POST `/generate/clarify-prompt` Clarify a prompt through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "prompt": "Find software suppliers for an ecommerce company" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/clarify-prompt" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "prompt": "Find software suppliers for an ecommerce company" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/clarify-prompt" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "prompt": "Find software suppliers for an ecommerce company" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/clarify-prompt`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "prompt": "Find software suppliers for an ecommerce company" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Generate company details POST `/generate/company-details` Generate company details through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "company_name": "Claro", "domain": "getclaro.ai", "functional_area": "Procurement", "sub_category": "Supplier intelligence" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/company-details" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "company_name": "Claro", "domain": "getclaro.ai", "functional_area": "Procurement", "sub_category": "Supplier intelligence" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/company-details" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "company_name": "Claro", "domain": "getclaro.ai", "functional_area": "Procurement", "sub_category": "Supplier intelligence" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/company-details`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "company_name": "Claro", "domain": "getclaro.ai", "functional_area": "Procurement", "sub_category": "Supplier intelligence" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Ingest FindAll data POST `/generate/find-all/ingest` Ingest FindAll data through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "objective": "Find UK manufacturers of recycled cardboard packaging" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/find-all/ingest" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "objective": "Find UK manufacturers of recycled cardboard packaging" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/find-all/ingest" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "objective": "Find UK manufacturers of recycled cardboard packaging" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/find-all/ingest`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "objective": "Find UK manufacturers of recycled cardboard packaging" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Create FindAll run POST `/generate/find-all/runs` Create FindAll run through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "objective": "Find UK recycled-packaging manufacturers", "entity_type": "company", "match_conditions": [ { "name": "Material", "description": "Produces recycled cardboard packaging" } ], "match_limit": 10 } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/find-all/runs" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "objective": "Find UK recycled-packaging manufacturers", "entity_type": "company", "match_conditions": [ { "name": "Material", "description": "Produces recycled cardboard packaging" } ], "match_limit": 10 }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/find-all/runs" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "objective": "Find UK recycled-packaging manufacturers", "entity_type": "company", "match_conditions": [ { "name": "Material", "description": "Produces recycled cardboard packaging" } ], "match_limit": 10 }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/find-all/runs`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "objective": "Find UK recycled-packaging manufacturers", "entity_type": "company", "match_conditions": [ { "name": "Material", "description": "Produces recycled cardboard packaging" } ], "match_limit": 10 }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get FindAll run GET `/generate/find-all/runs/{findallId}` Get FindAll run through the Claro Public API. **Required scope:** `generate` ### Parameters | Name | Location | Type | Required | | ----------- | -------- | ------ | -------- | | `findallId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/$FINDALL_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests findall_id = "YOUR_FINDALL_ID" url = f"https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/{findall_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const findallId = "YOUR_FINDALL_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/${findallId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get FindAll result GET `/generate/find-all/runs/{findallId}/result` Get FindAll result through the Claro Public API. **Required scope:** `generate` ### Parameters | Name | Location | Type | Required | | ----------- | -------- | ------ | -------- | | `findallId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/$FINDALL_ID/result" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests findall_id = "YOUR_FINDALL_ID" url = f"https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/{findall_id}/result" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const findallId = "YOUR_FINDALL_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/${findallId}/result`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Extend FindAll run POST `/generate/find-all/runs/{findallId}/extend` Extend FindAll run through the Claro Public API. **Required scope:** `generate` ### Parameters | Name | Location | Type | Required | | ----------- | -------- | ------ | -------- | | `findallId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "additional_match_limit": 10 } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/$FINDALL_ID/extend" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "additional_match_limit": 10 }' ``` ```python Python theme={null} import json import requests findall_id = "YOUR_FINDALL_ID" url = f"https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/{findall_id}/extend" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "additional_match_limit": 10 }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const findallId = "YOUR_FINDALL_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/${findallId}/extend`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "additional_match_limit": 10 }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Enrich FindAll run POST `/generate/find-all/runs/{findallId}/enrich` Enrich FindAll run through the Claro Public API. **Required scope:** `generate` ### Parameters | Name | Location | Type | Required | | ----------- | -------- | ------ | -------- | | `findallId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "output_schema": { "employee_count": { "type": "number" } }, "processor": "company_research" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/$FINDALL_ID/enrich" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "output_schema": { "employee_count": { "type": "number" } }, "processor": "company_research" }' ``` ```python Python theme={null} import json import requests findall_id = "YOUR_FINDALL_ID" url = f"https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/{findall_id}/enrich" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "output_schema": { "employee_count": { "type": "number" } }, "processor": "company_research" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const findallId = "YOUR_FINDALL_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/${findallId}/enrich`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "output_schema": { "employee_count": { "type": "number" } }, "processor": "company_research" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Cancel FindAll run POST `/generate/find-all/runs/{findallId}/cancel` Cancel FindAll run through the Claro Public API. **Required scope:** `generate` ### Parameters | Name | Location | Type | Required | | ----------- | -------- | ------ | -------- | | `findallId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/$FINDALL_ID/cancel" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests findall_id = "YOUR_FINDALL_ID" url = f"https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/{findall_id}/cancel" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const findallId = "YOUR_FINDALL_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/find-all/runs/${findallId}/cancel`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Claro API Reference Source: https://docs.getclaro.ai/api-reference/introduction Use Claro's supported public APIs to orchestrate catalogue, enrichment, taxonomy, monitoring, and related workflows. The Claro Public API exposes supported platform workflows through a versioned, API-key-authenticated interface. ## Explore the Public APIs Manage catalogues, sources, records, snapshots, and actions. Read table data and manage columns, rows, and cells. Prepare catalogue data and run enrichment workflows. Run agentic generation and FindAll discovery workflows. Manage knowledge content, HTS classification, and taxonomy mapping. Manage workspaces and review account limits, credits, and usage. Queue scraping work and inspect or retry background jobs. Find suppliers and run catalogue comparison workflows. Configure and run price and product monitoring workflows. Run deduplication and export catalogue or result data. ## Base URL ```text theme={null} https://platform.getclaro.ai/api/public/v1 ``` ## Authentication Send your Claro API key as a Bearer token with every request: ```bash theme={null} curl "https://platform.getclaro.ai/api/public/v1/me" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` Treat API keys as secrets. Never expose them in browser code, public repositories, or client-side logs. ## Create an API key ### 1. Open API key settings Sign in to the Claro platform, open **Settings**, and select the **API Keys** tab. Claro Settings page with an arrow pointing to the API Keys tab ### 2. Start creating a key On the **API keys** page, select **Create key**. Claro API keys page with an arrow pointing to Create key ### 3. Configure the key Enter a descriptive name, select the scope, and then select **Create key**: * **Personal** charges API usage to your personal account. * **Workspace** charges API usage to the selected workspace and is available only to workspace administrators and owners. Create an API key dialog highlighting the name, scope, and Create key controls ### 4. Copy and store the key Use the copy button to save the key in a secure secret manager before closing the dialog. The complete key is displayed only once. One-time API key dialog with the key redacted and arrows highlighting the warning and copy button You cannot retrieve the complete key after closing the dialog. If you lose it, revoke the key and create a replacement. ## API key scopes * `objects` for objects, tables, workspaces, account information, and related workflows * `enrich` for enrichment operations * `generate` for generation, scraping, and job operations * `taxonomy` for knowledge-base and taxonomy operations * `team` for team-restricted comparison, monitoring, supplier-finding, and export operations An operation that lists multiple scopes requires all of them. A request made without a required scope returns `403 Forbidden`. ## Errors and rate limits * `401 Unauthorized` - the API key is missing or invalid * `403 Forbidden` - the key lacks a required scope or workspace access * `404 Not Found` - the resource or endpoint does not exist * `429 Too Many Requests` - the key exceeded its tier's rate limit Rate limits depend on the API key tier. Contact [Claro support](mailto:hello@getclaro.ai) if you need a higher limit. # Background Jobs Source: https://docs.getclaro.ai/api-reference/jobs Queue scraping work and inspect or retry background jobs. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## Queue a scrape POST `/scrape` Queue a scrape through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "urls": [ "https://example.com/products" ], "prompt": "Extract product names and prices" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/scrape" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "urls": [ "https://example.com/products" ], "prompt": "Extract product names and prices" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/scrape" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "urls": [ "https://example.com/products" ], "prompt": "Extract product names and prices" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/scrape`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "urls": [ "https://example.com/products" ], "prompt": "Extract product names and prices" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get job by ID GET `/jobs` Get job by ID through the Claro Public API. **Required scope:** `generate` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | query | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/jobs?id=YOUR_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/jobs?id=YOUR_ID" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/jobs?id=YOUR_ID`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get jobs by reference GET `/jobs/by-reference` Get jobs by reference through the Claro Public API. **Required scope:** `generate` ### Parameters | Name | Location | Type | Required | | --------------- | -------- | ------ | -------- | | `referenceType` | query | string | Yes | | `referenceId` | query | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/jobs/by-reference?referenceType=YOUR_REFERENCE_TYPE&referenceId=YOUR_REFERENCE_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/jobs/by-reference?referenceType=YOUR_REFERENCE_TYPE&referenceId=YOUR_REFERENCE_ID" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/jobs/by-reference?referenceType=YOUR_REFERENCE_TYPE&referenceId=YOUR_REFERENCE_ID`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Retry a job POST `/jobs/retry` Retry a job through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "backgroundTaskId": "00000000-0000-4000-8000-000000000009" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/jobs/retry" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "backgroundTaskId": "00000000-0000-4000-8000-000000000009" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/jobs/retry" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "backgroundTaskId": "00000000-0000-4000-8000-000000000009" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/jobs/retry`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "backgroundTaskId": "00000000-0000-4000-8000-000000000009" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Knowledge & Taxonomy Source: https://docs.getclaro.ai/api-reference/knowledge-taxonomy Manage knowledge-base content and taxonomy mapping workflows. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## List knowledge base items GET `/knowledge-base` List knowledge base items through the Claro Public API. **Required scope:** `taxonomy` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/knowledge-base" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/knowledge-base" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/knowledge-base`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get knowledge base item GET `/knowledge-base/{id}` Get knowledge base item through the Claro Public API. **Required scope:** `taxonomy` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/knowledge-base/$ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/knowledge-base/{id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/knowledge-base/${id}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Update knowledge base item PATCH `/knowledge-base/{id}` Update knowledge base item through the Claro Public API. **Required scope:** `taxonomy` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Procurement policy", "description": "Current purchasing requirements" } ``` ### Example request ```bash cURL theme={null} curl -X PATCH "https://platform.getclaro.ai/api/public/v1/knowledge-base/$ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Procurement policy", "description": "Current purchasing requirements" }' ``` ```python Python theme={null} import json import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/knowledge-base/{id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Procurement policy", "description": "Current purchasing requirements" }''') response = requests.patch(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/knowledge-base/${id}`, { method: "PATCH", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Procurement policy", "description": "Current purchasing requirements" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Upload knowledge base files POST `/knowledge-base/upload/files` Upload knowledge base files through the Claro Public API. **Required scope:** `taxonomy` ### Request body Content type: `multipart/form-data` (required) Upload the source file using the `file` form field. ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/knowledge-base/upload/files" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -F "file=@path/to/file.csv" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/knowledge-base/upload/files" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} files = {"file": open("path/to/file.csv", "rb")} response = requests.post(url, headers=headers, files=files) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const formData = new FormData(); formData.append("file", fileInput.files[0]); const response = await fetch(`https://platform.getclaro.ai/api/public/v1/knowledge-base/upload/files`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, body: formData, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `202` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Upload knowledge base content POST `/knowledge-base/upload/content` Upload knowledge base content through the Claro Public API. **Required scope:** `taxonomy` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Procurement policy", "description": "Purchasing requirements", "content": "All suppliers must complete due diligence." } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/knowledge-base/upload/content" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Procurement policy", "description": "Purchasing requirements", "content": "All suppliers must complete due diligence." }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/knowledge-base/upload/content" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Procurement policy", "description": "Purchasing requirements", "content": "All suppliers must complete due diligence." }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/knowledge-base/upload/content`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Procurement policy", "description": "Purchasing requirements", "content": "All suppliers must complete due diligence." }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Classify an HTS code POST `/generate/hts-agent` Classify an HTS code through the Claro Public API. **Required scope:** `generate` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "prompt": "Find software suppliers for an ecommerce company" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/generate/hts-agent" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "prompt": "Find software suppliers for an ecommerce company" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/generate/hts-agent" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "prompt": "Find software suppliers for an ecommerce company" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/generate/hts-agent`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "prompt": "Find software suppliers for an ecommerce company" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Detect taxonomy structure POST `/taxonomy/detect-structure` Detect taxonomy structure through the Claro Public API. **Required scope:** `taxonomy` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "headers": [ "Department", "Category" ], "rows": [ { "Department": "Electronics", "Category": "Laptops" } ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/taxonomy/detect-structure" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "headers": [ "Department", "Category" ], "rows": [ { "Department": "Electronics", "Category": "Laptops" } ] }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/taxonomy/detect-structure" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "headers": [ "Department", "Category" ], "rows": [ { "Department": "Electronics", "Category": "Laptops" } ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/taxonomy/detect-structure`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "headers": [ "Department", "Category" ], "rows": [ { "Department": "Electronics", "Category": "Laptops" } ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Map taxonomy POST `/taxonomy/{taxonomyId}/map` Map taxonomy through the Claro Public API. **Required scope:** `taxonomy` ### Parameters | Name | Location | Type | Required | | ------------ | -------- | ------ | -------- | | `taxonomyId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "catalogObjectId": "00000000-0000-4000-8000-000000000001" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/taxonomy/$TAXONOMY_ID/map" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "catalogObjectId": "00000000-0000-4000-8000-000000000001" }' ``` ```python Python theme={null} import json import requests taxonomy_id = "YOUR_TAXONOMY_ID" url = f"https://platform.getclaro.ai/api/public/v1/taxonomy/{taxonomy_id}/map" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "catalogObjectId": "00000000-0000-4000-8000-000000000001" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const taxonomyId = "YOUR_TAXONOMY_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/taxonomy/${taxonomyId}/map`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "catalogObjectId": "00000000-0000-4000-8000-000000000001" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## List taxonomy assignments GET `/taxonomy/{taxonomyId}/assignments` List taxonomy assignments through the Claro Public API. **Required scope:** `taxonomy` ### Parameters | Name | Location | Type | Required | | ------------ | -------- | ------ | -------- | | `taxonomyId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/taxonomy/$TAXONOMY_ID/assignments" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests taxonomy_id = "YOUR_TAXONOMY_ID" url = f"https://platform.getclaro.ai/api/public/v1/taxonomy/{taxonomy_id}/assignments" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const taxonomyId = "YOUR_TAXONOMY_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/taxonomy/${taxonomyId}/assignments`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Review taxonomy assignment PATCH `/taxonomy/assignments/{id}` Review taxonomy assignment through the Claro Public API. **Required scope:** `taxonomy` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "reviewStatus": "ACCEPTED" } ``` ### Example request ```bash cURL theme={null} curl -X PATCH "https://platform.getclaro.ai/api/public/v1/taxonomy/assignments/$ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "reviewStatus": "ACCEPTED" }' ``` ```python Python theme={null} import json import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/taxonomy/assignments/{id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "reviewStatus": "ACCEPTED" }''') response = requests.patch(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/taxonomy/assignments/${id}`, { method: "PATCH", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "reviewStatus": "ACCEPTED" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Reassign taxonomy assignment PATCH `/taxonomy/assignments/{id}/reassign` Reassign taxonomy assignment through the Claro Public API. **Required scope:** `taxonomy` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "categoryRowId": "00000000-0000-4000-8000-000000000008" } ``` ### Example request ```bash cURL theme={null} curl -X PATCH "https://platform.getclaro.ai/api/public/v1/taxonomy/assignments/$ID/reassign" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "categoryRowId": "00000000-0000-4000-8000-000000000008" }' ``` ```python Python theme={null} import json import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/taxonomy/assignments/{id}/reassign" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "categoryRowId": "00000000-0000-4000-8000-000000000008" }''') response = requests.patch(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/taxonomy/assignments/${id}/reassign`, { method: "PATCH", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "categoryRowId": "00000000-0000-4000-8000-000000000008" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Price & Product Monitoring Source: https://docs.getclaro.ai/api-reference/monitoring Configure and run price and product monitoring workflows. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## Get price monitoring config GET `/price-monitoring/config/{configOrObjectId}` Get price monitoring config through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------------------ | -------- | ------ | -------- | | `configOrObjectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/price-monitoring/config/$CONFIG_OR_OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests config_or_object_id = "YOUR_CONFIG_OR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/config/{config_or_object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configOrObjectId = "YOUR_CONFIG_OR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/config/${configOrObjectId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Update price monitoring config PUT `/price-monitoring/config/{configOrObjectId}` Update price monitoring config through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------------------ | -------- | ------ | -------- | | `configOrObjectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Daily Amazon prices", "is_active": true } ``` ### Example request ```bash cURL theme={null} curl -X PUT "https://platform.getclaro.ai/api/public/v1/price-monitoring/config/$CONFIG_OR_OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Daily Amazon prices", "is_active": true }' ``` ```python Python theme={null} import json import requests config_or_object_id = "YOUR_CONFIG_OR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/config/{config_or_object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Daily Amazon prices", "is_active": true }''') response = requests.put(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configOrObjectId = "YOUR_CONFIG_OR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/config/${configOrObjectId}`, { method: "PUT", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Daily Amazon prices", "is_active": true }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Delete price monitoring config DELETE `/price-monitoring/config/{configOrObjectId}` Delete price monitoring config through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------------------ | -------- | ------ | -------- | | `configOrObjectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X DELETE "https://platform.getclaro.ai/api/public/v1/price-monitoring/config/$CONFIG_OR_OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests config_or_object_id = "YOUR_CONFIG_OR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/config/{config_or_object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.delete(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configOrObjectId = "YOUR_CONFIG_OR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/config/${configOrObjectId}`, { method: "DELETE", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Create price monitoring config POST `/price-monitoring/config` Create price monitoring config through the Claro Public API. **Required scopes:** `objects`, `team` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "object_id": "00000000-0000-4000-8000-000000000001", "name": "Amazon prices", "options": { "marketplaces": [ "Amazon" ], "matchStrategy": "NameBrand" } } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/price-monitoring/config" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "object_id": "00000000-0000-4000-8000-000000000001", "name": "Amazon prices", "options": { "marketplaces": [ "Amazon" ], "matchStrategy": "NameBrand" } }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/config" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "object_id": "00000000-0000-4000-8000-000000000001", "name": "Amazon prices", "options": { "marketplaces": [ "Amazon" ], "matchStrategy": "NameBrand" } }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/config`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "object_id": "00000000-0000-4000-8000-000000000001", "name": "Amazon prices", "options": { "marketplaces": [ "Amazon" ], "matchStrategy": "NameBrand" } }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## List price monitoring runs GET `/price-monitoring/config/{configId}/runs` List price monitoring runs through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `configId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/price-monitoring/config/$CONFIG_ID/runs" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests config_id = "YOUR_CONFIG_ID" url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/config/{config_id}/runs" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configId = "YOUR_CONFIG_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/config/${configId}/runs`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Trigger price monitoring run POST `/price-monitoring/config/{configId}/runs` Trigger price monitoring run through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `configId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/price-monitoring/config/$CONFIG_ID/runs" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests config_id = "YOUR_CONFIG_ID" url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/config/{config_id}/runs" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configId = "YOUR_CONFIG_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/config/${configId}/runs`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get price monitoring run GET `/price-monitoring/runs/{runId}` Get price monitoring run through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------- | -------- | ------ | -------- | | `runId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/price-monitoring/runs/$RUN_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests run_id = "YOUR_RUN_ID" url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/runs/{run_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const runId = "YOUR_RUN_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/runs/${runId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get price monitoring results GET `/price-monitoring/runs/{runId}/results` Get price monitoring results through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------- | -------- | ------ | -------- | | `runId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/price-monitoring/runs/$RUN_ID/results" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests run_id = "YOUR_RUN_ID" url = f"https://platform.getclaro.ai/api/public/v1/price-monitoring/runs/{run_id}/results" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const runId = "YOUR_RUN_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/price-monitoring/runs/${runId}/results`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get product monitoring config GET `/product-monitoring/config/{configOrObjectId}` Get product monitoring config through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------------------ | -------- | ------ | -------- | | `configOrObjectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/product-monitoring/config/$CONFIG_OR_OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests config_or_object_id = "YOUR_CONFIG_OR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/config/{config_or_object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configOrObjectId = "YOUR_CONFIG_OR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/config/${configOrObjectId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Update product monitoring config PUT `/product-monitoring/config/{configOrObjectId}` Update product monitoring config through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ------------------ | -------- | ------ | -------- | | `configOrObjectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Weekly competitor monitoring", "is_active": true } ``` ### Example request ```bash cURL theme={null} curl -X PUT "https://platform.getclaro.ai/api/public/v1/product-monitoring/config/$CONFIG_OR_OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Weekly competitor monitoring", "is_active": true }' ``` ```python Python theme={null} import json import requests config_or_object_id = "YOUR_CONFIG_OR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/config/{config_or_object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Weekly competitor monitoring", "is_active": true }''') response = requests.put(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configOrObjectId = "YOUR_CONFIG_OR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/config/${configOrObjectId}`, { method: "PUT", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Weekly competitor monitoring", "is_active": true }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Create product monitoring config POST `/product-monitoring/config` Create product monitoring config through the Claro Public API. **Required scopes:** `objects`, `team` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "object_id": "00000000-0000-4000-8000-000000000001", "name": "Competitor monitoring", "options": { "matchModel": "exact", "competitorSegment": "all", "sites": [], "cadenceDays": 7, "discoverNew": true, "alertThreshold": "5" } } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/config" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "object_id": "00000000-0000-4000-8000-000000000001", "name": "Competitor monitoring", "options": { "matchModel": "exact", "competitorSegment": "all", "sites": [], "cadenceDays": 7, "discoverNew": true, "alertThreshold": "5" } }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/config" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "object_id": "00000000-0000-4000-8000-000000000001", "name": "Competitor monitoring", "options": { "matchModel": "exact", "competitorSegment": "all", "sites": [], "cadenceDays": 7, "discoverNew": true, "alertThreshold": "5" } }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/config`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "object_id": "00000000-0000-4000-8000-000000000001", "name": "Competitor monitoring", "options": { "matchModel": "exact", "competitorSegment": "all", "sites": [], "cadenceDays": 7, "discoverNew": true, "alertThreshold": "5" } }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Start product monitoring setup POST `/product-monitoring/setup/{objectId}/start` Start product monitoring setup through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "forceRestart": false } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/start" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "forceRestart": false }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/start" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "forceRestart": false }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/start`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "forceRestart": false }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get product monitoring setup status GET `/product-monitoring/setup/{objectId}/status` Get product monitoring setup status through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/status" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/status" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/status`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Confirm product monitoring setup POST `/product-monitoring/setup/{objectId}/confirm` Confirm product monitoring setup through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "mappings": [ { "dashboardKey": "product", "sourceColumnId": "00000000-0000-4000-8000-000000000005", "resolution": "map" } ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/confirm" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "mappings": [ { "dashboardKey": "product", "sourceColumnId": "00000000-0000-4000-8000-000000000005", "resolution": "map" } ] }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/confirm" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "mappings": [ { "dashboardKey": "product", "sourceColumnId": "00000000-0000-4000-8000-000000000005", "resolution": "map" } ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/confirm`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "mappings": [ { "dashboardKey": "product", "sourceColumnId": "00000000-0000-4000-8000-000000000005", "resolution": "map" } ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Create setup column POST `/product-monitoring/setup/{objectId}/create-column` Create setup column through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "fieldKey": "price" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/create-column" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "fieldKey": "price" }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/create-column" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "fieldKey": "price" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/create-column`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "fieldKey": "price" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Finalize product monitoring setup POST `/product-monitoring/setup/{objectId}/finalize` Finalize product monitoring setup through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "answers": [ { "fieldKey": "product", "type": "map", "columnId": "00000000-0000-4000-8000-000000000005" } ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/finalize" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "answers": [ { "fieldKey": "product", "type": "map", "columnId": "00000000-0000-4000-8000-000000000005" } ] }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/finalize" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "answers": [ { "fieldKey": "product", "type": "map", "columnId": "00000000-0000-4000-8000-000000000005" } ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/finalize`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "answers": [ { "fieldKey": "product", "type": "map", "columnId": "00000000-0000-4000-8000-000000000005" } ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Start product research POST `/product-monitoring/setup/{objectId}/research/start` Start product research through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/research/start" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/research/start" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/research/start`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Customize product research POST `/product-monitoring/setup/{objectId}/research/customize` Customize product research through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "customInstructions": "Focus on UK retailers and manufacturer websites" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/research/customize" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "customInstructions": "Focus on UK retailers and manufacturer websites" }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/research/customize" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "customInstructions": "Focus on UK retailers and manufacturer websites" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/research/customize`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "customInstructions": "Focus on UK retailers and manufacturer websites" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Confirm product research POST `/product-monitoring/setup/{objectId}/research/confirm` Confirm product research through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/research/confirm" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/research/confirm" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/research/confirm`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Clarify competitors POST `/product-monitoring/setup/{objectId}/competitors/clarify` Clarify competitors through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "answers": { "target_market": "United Kingdom" } } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/competitors/clarify" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "answers": { "target_market": "United Kingdom" } }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/competitors/clarify" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "answers": { "target_market": "United Kingdom" } }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/competitors/clarify`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "answers": { "target_market": "United Kingdom" } }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Start source selection POST `/product-monitoring/setup/{objectId}/sources/start` Start source selection through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/sources/start" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/sources/start" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/sources/start`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Complete source selection POST `/product-monitoring/setup/{objectId}/sources/complete` Complete source selection through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/sources/complete" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/sources/complete" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/sources/complete`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Clarify sources POST `/product-monitoring/setup/{objectId}/sources/clarify` Clarify sources through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "answers": { "target_market": "United Kingdom" } } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/$OBJECT_ID/sources/clarify" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "answers": { "target_market": "United Kingdom" } }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/{object_id}/sources/clarify" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "answers": { "target_market": "United Kingdom" } }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/setup/${objectId}/sources/clarify`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "answers": { "target_market": "United Kingdom" } }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Trigger product monitoring runs POST `/product-monitoring/config/{configId}/runs` Trigger product monitoring runs through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `configId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/config/$CONFIG_ID/runs" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests config_id = "YOUR_CONFIG_ID" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/config/{config_id}/runs" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configId = "YOUR_CONFIG_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/config/${configId}/runs`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Trigger product monitoring run POST `/product-monitoring/config/{configId}/runs/{sku}` Trigger product monitoring run through the Claro Public API. **Required scopes:** `objects`, `team` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `configId` | path | string | Yes | | `sku` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/product-monitoring/config/$CONFIG_ID/runs/$SKU" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests config_id = "YOUR_CONFIG_ID" sku = "YOUR_SKU" url = f"https://platform.getclaro.ai/api/public/v1/product-monitoring/config/{config_id}/runs/{sku}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.post(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const configId = "YOUR_CONFIG_ID"; const sku = "YOUR_SKU"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/product-monitoring/config/${configId}/runs/${sku}`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Catalogues & Records Source: https://docs.getclaro.ai/api-reference/objects Create and manage catalogues, sources, records, snapshots, and actions. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## List objects GET `/objects` List objects through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/objects" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Create object POST `/objects` Create object through the Claro Public API. **Required scope:** `objects` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Supplier catalogue", "description": "Products received from suppliers" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Supplier catalogue", "description": "Products received from suppliers" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/objects" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Supplier catalogue", "description": "Products received from suppliers" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Supplier catalogue", "description": "Products received from suppliers" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get object GET `/objects/{objectId}` Get object through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Update object PATCH `/objects/{objectId}` Update object through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Updated supplier catalogue", "auto_enrich": true } ``` ### Example request ```bash cURL theme={null} curl -X PATCH "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Updated supplier catalogue", "auto_enrich": true }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Updated supplier catalogue", "auto_enrich": true }''') response = requests.patch(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}`, { method: "PATCH", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Updated supplier catalogue", "auto_enrich": true }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Delete object DELETE `/objects/{objectId}` Delete object through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X DELETE "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.delete(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}`, { method: "DELETE", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Upload an object source POST `/objects/{objectId}/sources/upload` Upload an object source through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `multipart/form-data` (required) Upload the source file using the `file` form field. ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/sources/upload" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -F "file=@path/to/file.csv" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/sources/upload" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} files = {"file": open("path/to/file.csv", "rb")} response = requests.post(url, headers=headers, files=files) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const formData = new FormData(); formData.append("file", fileInput.files[0]); const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/sources/upload`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, body: formData, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Import object records POST `/objects/{objectId}/records/import` Import object records through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "file_id": "00000000-0000-4000-8000-000000000001", "mappings": { "Product Name": "name", "SKU": "sku" } } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/records/import" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "file_id": "00000000-0000-4000-8000-000000000001", "mappings": { "Product Name": "name", "SKU": "sku" } }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/records/import" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "file_id": "00000000-0000-4000-8000-000000000001", "mappings": { "Product Name": "name", "SKU": "sku" } }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/records/import`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "file_id": "00000000-0000-4000-8000-000000000001", "mappings": { "Product Name": "name", "SKU": "sku" } }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Extract an uploaded source POST `/objects/extract` Extract an uploaded source through the Claro Public API. **Required scope:** `objects` ### Request body Content type: `multipart/form-data` (required) Upload the source file using the `file` form field. ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/extract" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -F "file=@path/to/file.csv" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/objects/extract" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} files = {"file": open("path/to/file.csv", "rb")} response = requests.post(url, headers=headers, files=files) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const formData = new FormData(); formData.append("file", fileInput.files[0]); const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/extract`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, body: formData, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## List object snapshots GET `/objects/{objectId}/snapshots` List object snapshots through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/snapshots" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/snapshots" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/snapshots`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## List object actions GET `/objects/{objectId}/actions` List object actions through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/actions" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/actions" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/actions`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get object action GET `/objects/{objectId}/actions/{actionId}` Get object action through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | | `actionId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/actions/$ACTION_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" action_id = "YOUR_ACTION_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/actions/{action_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const actionId = "YOUR_ACTION_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/actions/${actionId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get object action diff GET `/objects/{objectId}/actions/{actionId}/diff` Get object action diff through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | | `actionId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/actions/$ACTION_ID/diff" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" action_id = "YOUR_ACTION_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/actions/{action_id}/diff" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const actionId = "YOUR_ACTION_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/actions/${actionId}/diff`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Apply object action POST `/objects/{objectId}/actions/{actionId}/apply` Apply object action through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---------- | -------- | ------ | -------- | | `objectId` | path | string | Yes | | `actionId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/actions/$ACTION_ID/apply" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" action_id = "YOUR_ACTION_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/actions/{action_id}/apply" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const actionId = "YOUR_ACTION_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/actions/${actionId}/apply`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get snapshot diff GET `/objects/{objectId}/snapshots/{snapshotId}/diff` Get snapshot diff through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ------------ | -------- | ------ | -------- | | `objectId` | path | string | Yes | | `snapshotId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/snapshots/$SNAPSHOT_ID/diff" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests object_id = "YOUR_OBJECT_ID" snapshot_id = "YOUR_SNAPSHOT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/snapshots/{snapshot_id}/diff" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const snapshotId = "YOUR_SNAPSHOT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/snapshots/${snapshotId}/diff`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Apply snapshot POST `/objects/{objectId}/snapshots/{snapshotId}/apply` Apply snapshot through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ------------ | -------- | ------ | -------- | | `objectId` | path | string | Yes | | `snapshotId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/objects/$OBJECT_ID/snapshots/$SNAPSHOT_ID/apply" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] }' ``` ```python Python theme={null} import json import requests object_id = "YOUR_OBJECT_ID" snapshot_id = "YOUR_SNAPSHOT_ID" url = f"https://platform.getclaro.ai/api/public/v1/objects/{object_id}/snapshots/{snapshot_id}/apply" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const objectId = "YOUR_OBJECT_ID"; const snapshotId = "YOUR_SNAPSHOT_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/objects/${objectId}/snapshots/${snapshotId}/apply`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "scope": "rows", "row_ids": [ "00000000-0000-4000-8000-000000000004" ] }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Tables & Cells Source: https://docs.getclaro.ai/api-reference/tables Read table data and manage its columns, rows, and cells. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## Get table grid GET `/tables/{tableId}` Get table grid through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | --------- | -------- | ------ | -------- | | `tableId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/tables/$TABLE_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests table_id = "YOUR_TABLE_ID" url = f"https://platform.getclaro.ai/api/public/v1/tables/{table_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const tableId = "YOUR_TABLE_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/tables/${tableId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get table columns GET `/tables/columns/{tableId}` Get table columns through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | --------- | -------- | ------ | -------- | | `tableId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/tables/columns/$TABLE_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests table_id = "YOUR_TABLE_ID" url = f"https://platform.getclaro.ai/api/public/v1/tables/columns/{table_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const tableId = "YOUR_TABLE_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/tables/columns/${tableId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get table rows GET `/tables/rows/{tableId}` Get table rows through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | --------- | -------- | ------ | -------- | | `tableId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/tables/rows/$TABLE_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests table_id = "YOUR_TABLE_ID" url = f"https://platform.getclaro.ai/api/public/v1/tables/rows/{table_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const tableId = "YOUR_TABLE_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/tables/rows/${tableId}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Add table column POST `/tables/{tableId}/add-column` Add table column through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | --------- | -------- | ------ | -------- | | `tableId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Brand", "type": "string", "metadata": {} } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/tables/$TABLE_ID/add-column" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Brand", "type": "string", "metadata": {} }' ``` ```python Python theme={null} import json import requests table_id = "YOUR_TABLE_ID" url = f"https://platform.getclaro.ai/api/public/v1/tables/{table_id}/add-column" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Brand", "type": "string", "metadata": {} }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const tableId = "YOUR_TABLE_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/tables/${tableId}/add-column`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Brand", "type": "string", "metadata": {} }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Add table row POST `/tables/{tableId}/add-row` Add table row through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | --------- | -------- | ------ | -------- | | `tableId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "rowsData": { "00000000-0000-4000-8000-000000000005": "Example product" } } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/tables/$TABLE_ID/add-row" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "rowsData": { "00000000-0000-4000-8000-000000000005": "Example product" } }' ``` ```python Python theme={null} import json import requests table_id = "YOUR_TABLE_ID" url = f"https://platform.getclaro.ai/api/public/v1/tables/{table_id}/add-row" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "rowsData": { "00000000-0000-4000-8000-000000000005": "Example product" } }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const tableId = "YOUR_TABLE_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/tables/${tableId}/add-row`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "rowsData": { "00000000-0000-4000-8000-000000000005": "Example product" } }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Update table cell PUT `/tables/cells` Update table cell through the Claro Public API. **Required scope:** `objects` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "columnId": "00000000-0000-4000-8000-000000000005", "rowId": "00000000-0000-4000-8000-000000000004", "data": "Example product" } ``` ### Example request ```bash cURL theme={null} curl -X PUT "https://platform.getclaro.ai/api/public/v1/tables/cells" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "columnId": "00000000-0000-4000-8000-000000000005", "rowId": "00000000-0000-4000-8000-000000000004", "data": "Example product" }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/tables/cells" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "columnId": "00000000-0000-4000-8000-000000000005", "rowId": "00000000-0000-4000-8000-000000000004", "data": "Example product" }''') response = requests.put(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/tables/cells`, { method: "PUT", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "columnId": "00000000-0000-4000-8000-000000000005", "rowId": "00000000-0000-4000-8000-000000000004", "data": "Example product" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Workspace & Account Management Source: https://docs.getclaro.ai/api-reference/workspaces-account Manage workspaces and review identity, subscription, limits, and credit usage. Authenticate every request with `Authorization: Bearer clr_live_YOUR_API_KEY`. ## List workspaces GET `/workspaces` List workspaces through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/workspaces" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/workspaces" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Create workspace POST `/workspaces` Create workspace through the Claro Public API. **Required scope:** `objects` ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Procurement", "domain": "example.com", "max_members": 20, "max_pro_users": 5 } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/workspaces" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Procurement", "domain": "example.com", "max_members": 20, "max_pro_users": 5 }' ``` ```python Python theme={null} import json import requests url = f"https://platform.getclaro.ai/api/public/v1/workspaces" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Procurement", "domain": "example.com", "max_members": 20, "max_pro_users": 5 }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Procurement", "domain": "example.com", "max_members": 20, "max_pro_users": 5 }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get workspace GET `/workspaces/{id}` Get workspace through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/workspaces/$ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/workspaces/{id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces/${id}`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Update workspace PUT `/workspaces/{id}` Update workspace through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "name": "Global procurement", "max_members": 30 } ``` ### Example request ```bash cURL theme={null} curl -X PUT "https://platform.getclaro.ai/api/public/v1/workspaces/$ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "name": "Global procurement", "max_members": 30 }' ``` ```python Python theme={null} import json import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/workspaces/{id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "name": "Global procurement", "max_members": 30 }''') response = requests.put(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces/${id}`, { method: "PUT", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "name": "Global procurement", "max_members": 30 }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Delete workspace DELETE `/workspaces/{id}` Delete workspace through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X DELETE "https://platform.getclaro.ai/api/public/v1/workspaces/$ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/workspaces/{id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.delete(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces/${id}`, { method: "DELETE", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## List workspace members GET `/workspaces/{id}/members` List workspace members through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/workspaces/$ID/members" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/workspaces/{id}/members" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces/${id}/members`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Add workspace members POST `/workspaces/{id}/members` Add workspace members through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | ---- | -------- | ------ | -------- | | `id` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "invitee_emails": [ "buyer@example.com" ], "role": "MEMBER" } ``` ### Example request ```bash cURL theme={null} curl -X POST "https://platform.getclaro.ai/api/public/v1/workspaces/$ID/members" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "invitee_emails": [ "buyer@example.com" ], "role": "MEMBER" }' ``` ```python Python theme={null} import json import requests id = "YOUR_ID" url = f"https://platform.getclaro.ai/api/public/v1/workspaces/{id}/members" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "invitee_emails": [ "buyer@example.com" ], "role": "MEMBER" }''') response = requests.post(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces/${id}/members`, { method: "POST", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "invitee_emails": [ "buyer@example.com" ], "role": "MEMBER" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `201` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Update workspace member role PUT `/workspaces/{id}/members/{userId}` Update workspace member role through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | -------- | -------- | ------ | -------- | | `id` | path | string | Yes | | `userId` | path | string | Yes | ### Request body Content type: `application/json` (required) ```json Request example theme={null} { "role": "ADMIN" } ``` ### Example request ```bash cURL theme={null} curl -X PUT "https://platform.getclaro.ai/api/public/v1/workspaces/$ID/members/$USER_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" \ -H "Content-Type: application/json" \ --data '{ "role": "ADMIN" }' ``` ```python Python theme={null} import json import requests id = "YOUR_ID" user_id = "YOUR_USER_ID" url = f"https://platform.getclaro.ai/api/public/v1/workspaces/{id}/members/{user_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} payload = json.loads(r'''{ "role": "ADMIN" }''') response = requests.put(url, headers=headers, json=payload) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const userId = "YOUR_USER_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces/${id}/members/${userId}`, { method: "PUT", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", "Content-Type": "application/json", }, body: JSON.stringify({ "role": "ADMIN" }), }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Remove workspace member DELETE `/workspaces/{id}/members/{userId}` Remove workspace member through the Claro Public API. **Required scope:** `objects` ### Parameters | Name | Location | Type | Required | | -------- | -------- | ------ | -------- | | `id` | path | string | Yes | | `userId` | path | string | Yes | ### Example request ```bash cURL theme={null} curl -X DELETE "https://platform.getclaro.ai/api/public/v1/workspaces/$ID/members/$USER_ID" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests id = "YOUR_ID" user_id = "YOUR_USER_ID" url = f"https://platform.getclaro.ai/api/public/v1/workspaces/{id}/members/{user_id}" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.delete(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const id = "YOUR_ID"; const userId = "YOUR_USER_ID"; const response = await fetch(`https://platform.getclaro.ai/api/public/v1/workspaces/${id}/members/${userId}`, { method: "DELETE", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get current identity GET `/me` Get current identity through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/me" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/me" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/me`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get credit balance GET `/account/credits` Get credit balance through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/account/credits" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/account/credits" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/account/credits`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get subscription GET `/account/subscription` Get subscription through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/account/subscription" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/account/subscription" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/account/subscription`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get account limits GET `/account/limits` Get account limits through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/account/limits" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/account/limits" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/account/limits`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get credit summary GET `/account/credits/summary` Get credit summary through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/account/credits/summary" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/account/credits/summary" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/account/credits/summary`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## List credit transactions GET `/account/credits/transactions` List credit transactions through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/account/credits/transactions" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/account/credits/transactions" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/account/credits/transactions`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. *** ## Get credit usage analytics GET `/account/credits/usage` Get credit usage analytics through the Claro Public API. **Required scope:** `objects` ### Example request ```bash cURL theme={null} curl -X GET "https://platform.getclaro.ai/api/public/v1/account/credits/usage" \ -H "Authorization: Bearer clr_live_YOUR_API_KEY" ``` ```python Python theme={null} import requests url = f"https://platform.getclaro.ai/api/public/v1/account/credits/usage" headers = {"Authorization": "Bearer clr_live_YOUR_API_KEY"} response = requests.get(url, headers=headers) response.raise_for_status() print(response.text) ``` ```javascript JavaScript theme={null} const response = await fetch(`https://platform.getclaro.ai/api/public/v1/account/credits/usage`, { method: "GET", headers: { Authorization: "Bearer clr_live_YOUR_API_KEY", }, }); if (!response.ok) throw new Error(await response.text()); const data = await response.json(); ``` ### Responses * `200` - Successful response * `Default` - Error response. Rate-limited responses use HTTP 429. # Integrations & Automation Source: https://docs.getclaro.ai/automation Connect Claro to your workflows — schedules, chained pipelines, connectors, and notifications. Claro is designed for continuous catalog work, not one-off runs. Three layers handle automation: 1. **Schedules** — recurring runs of any operation. 2. **Chained pipelines** — output of one operation triggers the next. 3. **Connectors** — inbound and outbound integrations with your existing systems. *** ## Schedules Every operation can run on a schedule. From the catalogue's **Operation** tab, choose a recurrence — hourly, daily, weekly, or a cron expression — and pick a filter so only the relevant records are processed each run. Use schedules for: * Daily price and competitor monitoring. * Weekly data quality reports (Analyse). * Hourly supplier portal pickups when suppliers update frequently. * Recurring exports to BigQuery or S3. Each scheduled run shows up in the operation's run history alongside on-demand runs. *** ## Chained pipelines Operations can be chained — completion of one triggers the next, optionally gated by filters or review checkpoints. A typical onboarding pipeline: ``` Data Source Mapping ↓ Validate Data ↓ Normalize Data ↓ Bulk Enrichment ↓ Push & Sync ``` Pipelines are configured on the catalogue's **Operation** tab. You can: * Branch on outcome (e.g. *route low-confidence enrichment to a different reviewer*). * Halt on validation failure to prevent bad data downstream. * Re-run a single stage without re-running the whole pipeline. *** ## Inbound connectors For ingesting data, see [Data Import & Ingestion](/data_import_ingestion). The full set: * File upload (CSV, XLSX) * Google Drive * S3 * HTTPS scraping * Scheduled HTTP pulls * Supabase, BigQuery, Postgres * Supplier Portal * Email-as-source A **write API** also accepts changes from upstream systems with full schema validation. *** ## Outbound connectors For pushing data, see [Distribute](/modules/distribute). The full set: | Connector | Use | | ----------------------- | --------------------------------------------------- | | **Shopify** | Products, variants, metafields, images. | | **Amazon** | Listings via SP-API. | | **BigQuery** | Append/replace tables, with partitioning. | | **Google Sheets** | Bi-directional sync with named ranges. | | **Webhooks** | Per-change, batched, or scheduled, signed payloads. | | **S3** | Periodic dumps. | | **Supabase / Postgres** | Insert/update via SQL or REST. | A **read API** is available for downstream systems that prefer to pull. *** ## Notifications and alerts ### Slack Real-time alerts for operation completions, failures, and Monitor drifts. * Per-channel routing — different channels for different operations or catalogues. * Slash commands to trigger operations on demand. * Configurable verbosity (summary vs. per-record). Setup: **Settings → Integrations → Slack**, then authorize the workspace and pick channels. ### Email Per-user or per-team email digests for review queues and monitoring alerts. Configurable cadence (real-time, hourly, daily). ### Webhooks Subscribe an endpoint to operation events: `run.started`, `run.completed`, `run.failed`, `change.applied`, `change.queued_for_review`, `change.approved`, `change.rejected`. Payloads are signed for verification. *** ## Custom integrations (Dedicated plan) For systems not covered by the built-in connectors: * Custom REST endpoints for proprietary systems. * Database connectors for direct pipeline integration. * ETL integration with Airflow, Prefect, dbt. * Dedicated technical support during implementation, with sandbox access. *** ## Integration requests Want a specific integration? We prioritize based on user demand. * In-app: **Help → Feature Request**. * Direct: **[hello@getclaro.ai](mailto:hello@getclaro.ai)**. Most-requested integrations are fast-tracked in our quarterly review. # Catalogue Source: https://docs.getclaro.ai/catalogue Your products, suppliers, SKUs, and the relationships between them — with full attribute schemas, history, and provenance. A Catalogue is a typed object — Products, Suppliers, Line Items, Variants, etc. — that holds your records and everything that acts on them. Catalogues are persistent: they accumulate history, track provenance per field, and survive across operations and runs. Multiple catalogues can exist in a workspace and can reference each other (e.g. `Product.supplier` → `Supplier`). *** ## The five tabs Each catalogue opens with five tabs along the top. ### Attributes The schema for the catalogue. Each attribute is a typed field: * **text** — free text or constrained patterns * **number** — integers, decimals, with optional units * **image** — single image or gallery, with metadata (dimensions, format) * **date** — date or datetime, with timezone handling * **enum** — a fixed value set, with optional ordering * **reference** — a pointer to a record in another catalogue Per-attribute settings include: required, default value, validation rules (regex, range, length), and (for references) the related catalogue and reverse relationship name. Edit the schema at any time — Claro tracks attribute history alongside record history. Adding or changing an attribute does not destroy existing data; type migrations produce a preview before they are applied. ### Records The actual rows. Sortable, filterable, editable in a spreadsheet-like grid. * Inline edits create change events with provenance. * Per-field history is browsable and roll-back is per-field. * Filters, saved views, and bulk edits are first-class. * Each record has a stable identity that survives across data source updates. ### Data Source The upstream feeds that populate the catalogue. * **File upload** — CSV, XLSX (one-off or repeated) * **Scheduled scrape** — URL templates with mapping * **HTTPS pull** — periodic pulls of JSON or CSV endpoints * **Supplier Portal** — submissions land here pre-mapped * **Database connectors** — BigQuery, Postgres, Supabase * **Email-as-source** — emails to a workspace address are parsed Each source has its own mapping to the catalogue's attributes, its own schedule, and its own conflict policy (overwrite, append, write-if-empty). ### Operation The transformations available against this catalogue. The Operations tab is the launch surface for **Export**, **Price Insights & Monitoring**, **Bulk Enrichment**, **Analyse**, **Data Source Mapping**, **Push & Sync**, **Enrich Images**, **SEO Report**, **Find Duplicates**, **Find Similarities**, **Validate Data**, **Normalize Data**, and **Generate Taxonomy**. Operations can be run on demand, scheduled, or chained. Every run produces a reversible diff and confidence per change. See [Operations](/operations) for the full reference. ### Config Governance for the catalogue. * **Access** — who can read, edit, and approve. * **Retention** — history depth, archival rules. * **Write-back targets** — which downstream connectors are allowed. * **Default reviewers** — who receives review queue items. * **Auto-apply thresholds** — per-operation and per-attribute confidence cutoffs. *** ## Relationships between catalogues Reference attributes connect catalogues. A `Product.supplier` reference to a `Supplier` catalogue carries: * Forward navigation from product to supplier on the Records grid. * Reverse navigation from supplier to all related products. * Cascade rules on supplier merge or delete. * Cross-catalogue filtering (e.g. *all products from suppliers in Germany*). Operations can read across references — Bulk Enrichment can use values from a referenced supplier record as context, for example. *** ## History and provenance Every value in the Catalogue carries the source of its last write — which operation, which run, which underlying data source, which model, which reviewer. This is visible inline on every cell and is the basis for: * **Roll-back** — per-field, to any prior value. * **Audit** — full activity trail per record. * **Trust** — every model-generated value is traceable to its inputs. *** ## Promoting a dataset to a Catalogue Datasets produced by Research Agents are not catalogues by default. To promote one: 1. Open the dataset in **Generated Datasets**. 2. Choose **Promote to Catalogue**. 3. Pick the target catalogue type or create a new one. 4. Map columns to attributes; new attributes can be created on the fly. Once promoted, the records become persistent and subject to all the same operations, provenance tracking, and review gates as native catalogues. # Confidence Scoring & Citations Source: https://docs.getclaro.ai/confidence_scoring Every model-driven write in Claro is scored. Here's how the score is computed and how to act on it. Every time an operation writes a value to the catalogue using a model, it attaches a confidence score (0–100) and citations to that value. The score governs whether the write is auto-applied, queued for review, or discarded — and it travels with the value as part of its provenance. *** ## How confidence is computed Claro's confidence score combines four factors: | Factor | Weight | What it measures | | ----------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source reliability** | 40% | How trustworthy is the underlying source? First-party documents and authoritative sites score higher than unknown web sources. Knowledge Base content scores higher than open-web search. | | **Content consistency** | 30% | Do multiple sources agree? Consistent cross-source signals raise the score; conflicting signals lower it. Single-source answers receive moderate confidence. | | **Model certainty** | 20% | How confident was the model in its own output? Low variance in the model's internal probability distribution indicates higher certainty. | | **Retrieval quality** | 10% | How relevant was the retrieved context to the task? Strong semantic match and comprehensive coverage push this higher. | *** ## Confidence bands and their meaning | Band | Score | What happens | | ---------- | ------ | ------------------------------------------------------------------ | | **High** | 85–100 | Auto-apply (if at or above the auto-apply threshold). | | **Medium** | 60–84 | Typically queued for review. | | **Low** | 0–59 | Queued for review or discarded, depending on the reject threshold. | Thresholds are configurable per operation and per attribute. Defaults are conservative — most teams raise them incrementally as they gain confidence in an operation's output quality. *** ## Three thresholds per operation | Setting | Effect | | ------------------------ | ------------------------------------------------------------------------------------------------------ | | **Auto-apply threshold** | Confidence at or above this → the value is written to the record without review. | | **Review threshold** | Between auto-apply and this → the value is queued in [Notifications](/notifications) for human review. | | **Reject threshold** | Below this → the proposed value is discarded with a logged reason. | Set these under the catalogue's **Config** tab. You can override per attribute (e.g. a stricter threshold for pricing fields than for descriptions). *** ## Citations Every auto-applied or queued value carries citations — links to the specific sources the model drew from. **Citation types:** * **Knowledge Base** — document name, page number, and the relevant passage. * **Web sources** — URL and the extracted text snippet. * **Geolocation** — map service and data provider. * **File extraction** — document section and page reference. * **Intra-catalogue** — another record and attribute on the same or related catalogue. Citations are visible inline on every cell, in the review item in Notifications, and in the operation's run history. They form part of the value's provenance and are retained even after auto-apply. *** ## Working with confidence in practice **Reviewing outputs:** * In Notifications, sort review items by confidence ascending to tackle the most uncertain first. * For large batches, review the bottom decile before raising the auto-apply threshold. **Improving confidence:** * Add relevant Knowledge Bases — authoritative content is weighted higher than open-web search. * Write tighter prompts that define the exact format and scope of the answer. * Provide examples of the desired output. * Cross-reference multiple sources: configure enrichment to search more than one source and let Claro compare the results. **When confidence stays low:** * A persistently low-confidence field usually means the source data doesn't cover it, or the prompt is ambiguous. Fix the prompt or the source rather than just lowering the threshold. * Use the review queue as a training signal: approved values become positive examples that improve future matching in the similarity graph and in human-in-the-loop feedback flows (Dedicated plan). *** ## Rollback Every auto-applied write is reversible. From the record's per-field history, you can roll back to any prior value. A roll-back is itself a logged event, with your identity as the source. # Core Concepts Source: https://docs.getclaro.ai/core_concepts The vocabulary you need to use Claro effectively. Claro is built around a small set of concepts that show up across every surface. Once you know these, the rest of the platform is consistent. ### Catalogue A typed, persistent object — Products, Suppliers, Line Items, Variants, etc. — that holds your records. Each catalogue has its own schema (Attributes), data (Records), upstream feeds (Data Sources), transformations (Operations), and governance (Config). Multiple catalogues coexist in a workspace and can reference each other (e.g. `Product.supplier` → `Supplier`). ### Attribute A typed field on a catalogue: text, number, image, date, enum, or reference. Attributes carry validation rules, required flags, enum value sets, and (for references) the related catalogue. ### Record A row in a catalogue. Each record has a stable identity, a value per attribute, and a per-field history. Inline edits create change events with provenance. ### Data Source An upstream input that populates records. Sources include file uploads, scheduled scrapes, HTTPS pulls, supplier portal submissions, and database connectors. Each source has its own mapping to the catalogue's attributes and its own schedule. ### Operation A verb of the platform — Validate, Normalize, Bulk Enrich, Find Duplicates, Generate Taxonomy, Push & Sync, etc. Operations read records, optionally call models or external systems, and write back changes. Every operation produces a run with inputs, outputs, confidence per change, and a reversible diff. ### Run A single execution of an operation. Runs are auditable: you can see which records were read, what changed, what didn't, and why. ### Confidence A 0–100 score attached to every model-driven write, derived from source reliability, content consistency, model certainty, and retrieval quality. Each operation has configurable auto-apply, review, and reject thresholds. ### Provenance The chain of custody on every value: the operation, run, data source, model, and reviewer that produced it. Roll-back is per-field. ### Taxonomy A first-class hierarchical, versioned object — not a free-text label. Taxonomies can be generated from your data, imported from a standard (GS1, Google, internal), or hand-edited. Taxonomy assignments are themselves tracked operations with confidence scores. ### Similarity & Duplicate graph A workspace-level graph across records using embedding similarity and rule-based matching. Find Duplicates, Find Similarities, supplier match, and variant grouping all read from this graph. ### Knowledge Base A workspace-scoped collection of documents (datasheets, brand guidelines, catalogs, policies) that operations can cite when generating or matching content. ### Notification A queued review item from an operation whose confidence fell below the auto-apply threshold. Notifications can be approved, rejected, or edited inline; bulk actions are available per cluster. ### Credit A unit of usage. Operations consume credits per record processed; cost varies by operation type and model selection. # Data Import & Ingestion Source: https://docs.getclaro.ai/data_import_ingestion Every way data gets into a catalogue or a Research Agents dataset. Data flows into Claro through inbound connectors. For catalogues, inbound is configured per catalogue on the **Data Source** tab. For Research Agents, inbound is configured per agent run. This page covers every supported source, when to use it, and the limits and trade-offs to know about. *** ## Inbound for Catalogues Each catalogue's **Data Source** tab is where you connect feeds. Each source has its own attribute mapping, schedule, and conflict policy. ### File upload (CSV, XLSX) * **Use for** — initial loads, supplier files, periodic dumps from systems without an API. * **Mapping** — column-to-attribute mapping is saved on first upload and reused on subsequent uploads of the same shape. * **Limits** — large files are split into chunks server-side. For millions of rows, use a database connector or S3 instead. ### Supplier Portal * **Use for** — suppliers without API access who need a self-serve way to send updates. * **Behavior** — submissions land as Data Sources with the supplier's identity attached. Pre-mapped if the supplier has uploaded before. * **Detail** — see [Onboard → Supplier Portal](/modules/onboard). ### Scheduled scrape * **Use for** — public catalog pages, marketplace listings, competitor sources. * **Configuration** — URL templates, target schema, cadence, throttling. * **Outputs** — scrape runs land as a Data Source and feed any chained operations. ### HTTPS pull * **Use for** — partner APIs, internal systems with REST endpoints. * **Configuration** — endpoint, auth, request schedule, response parsing (JSON / CSV). * **Limits** — auth modes supported: bearer, basic, OAuth, signed requests. ### Database connectors | Source | Modes | | ------------ | ---------------------------------------------------------- | | **BigQuery** | Read tables or query results on a schedule. | | **Postgres** | Read tables or query results; per-row CDC where available. | | **Supabase** | Read tables and views via the managed REST API. | ### Cloud storage | Source | Modes | | ---------------- | ------------------------------------------- | | **S3** | Pull files matching a prefix on a schedule. | | **Google Drive** | Watch a folder for new files. | ### Email-as-source * **Use for** — suppliers who only send updates by email. * **Behavior** — emails sent to a workspace address are parsed; attachments become Data Source uploads, body content can populate a target schema. *** ## Inbound for Research Agents Research Agents accept inputs per agent type. See [Research Agents](/research_agents) for details. | Agent | Inputs | | ----------------------------------- | ---------------------------------------------- | | Find your perfect list | Natural-language brief and seed criteria. | | Turn documents into structured data | PDFs, scanned docs, datasheets, target schema. | | Analyze & enrich spreadsheets | CSV / XLSX file, enrichment goal. | | Scrape data from URLs | List of URLs or base URL plus crawl rules. | Outputs land in **Generated Datasets** and can be promoted into a Catalogue at any time. *** ## Mapping and conflict resolution For every inbound source, you configure how it interacts with existing records. ### Mapping Map source columns to catalogue attributes. Mappings include: * **Type coercion** — convert strings to numbers, normalize dates and currencies. * **Computed fields** — derive an attribute from one or more source columns. * **Constants** — fill an attribute with a fixed value (e.g. *source = supplier\_x*). * **Lookups** — translate enum-like source values to your canonical enum. ### Conflict policy When an inbound row matches an existing record: * **Overwrite** — replace existing values (default for trusted sources). * **Append** — for multi-value attributes only. * **Write-if-empty** — only fill blanks, never replace. * **Custom rule** — most-recent, highest-confidence, or attribute-specific policy. ### Identity matching Every inbound row needs to resolve to a record. **Data Source Mapping** runs first, using the similarity graph and configured key fields. Unmatched rows are flagged for review before they land in the catalogue. *** ## Limits and best practices * Test with a small sample first — 50 to 200 rows — before connecting a recurring source. * Validate the schema upstream when possible (Supplier Portal does this for you). * Prefer column-level mappings to ad-hoc fixes; mappings are reused, ad-hoc fixes are not. * For very high volume, prefer database or S3 connectors over file upload. *** ## Outbound Distributing data downstream is handled by [Distribute](/modules/distribute) — Unified Catalog and Sync & Export. # FAQ Source: https://docs.getclaro.ai/faq Frequently asked questions about Claro. ## Catalog & data **Q: What's the difference between a Catalogue and a dataset?** A: A Catalogue is persistent — it has a defined schema (Attributes), versioned records, data sources, and a full history with provenance. Operations write back to it on a schedule or in a pipeline. A dataset (from a Research Agent) is a one-off output; it exists until you promote it into a Catalogue. **Q: Can I have multiple catalogues in one workspace?** A: Yes. Catalogues can also reference each other — for example, `Product.supplier` → `Supplier`. Cross-catalogue references enable filtering, enrichment, and denormalization across related objects. **Q: How do I handle large catalogs (millions of records)?** A: Use database connectors (BigQuery, Postgres, Supabase) or S3 as Data Sources rather than file uploads. Operations run in parallel batches server-side. Contact us for guidance on sharding and scheduling for very large volumes. **Q: What file formats are supported for import?** A: CSV and XLSX for file upload. Structured JSON and CSV via HTTPS pull and database connectors. PDFs for Knowledge Bases (Word, PowerPoint, and plain text coming soon). *** ## Operations **Q: How is the confidence score computed?** A: Confidence combines four factors: source reliability (40%), content consistency (30%), model certainty (20%), and retrieval quality (10%). See [Confidence Scoring](/confidence_scoring) for details. **Q: What happens if an operation fails partway through?** A: Failed rows are retried automatically. Rows that continue to fail after retry consume zero credits. The run shows a partial success count and per-row error details. **Q: Can I roll back a bulk enrichment that went wrong?** A: Yes. Every write is reversible from the record's per-field history. Roll-back is per-field and is itself a logged event with your identity as the source. **Q: What does "chained pipeline" mean?** A: You can configure operations to trigger each other in sequence — for example, Data Source Mapping → Validate Data → Normalize Data → Bulk Enrichment → Push & Sync. Each stage gates the next; a failed validation stops the pipeline before bad data reaches the catalog. *** ## Plans & billing **Q: Do unused subscription credits roll over?** A: No. Monthly subscription credits reset each billing cycle. Top-up pack credits never expire. **Q: Can I cancel my subscription at any time?** A: Yes. Cancel from **Settings → Billing**. You retain access until the end of the current billing period. **Q: Can I supply my own OpenAI API key?** A: This is planned for a future release. Currently all AI processing runs through Claro's managed infrastructure. **Q: Is self-hosting available?** A: Yes, on Dedicated plans. We provide a Kubernetes Helm chart or can set up a managed VPC in your environment. See [Security & Compliance](/security) for details. *** ## Research Agents **Q: Can I turn a Research Agent dataset into a persistent catalog?** A: Yes. From any Generated Dataset, choose **Promote to Catalogue**, pick the target catalogue, and map columns to attributes. The records become persistent and subject to all the same operations, history, and review workflows as native catalogues. **Q: Are Research Agents the same as the old Claro product?** A: Research Agents are the evolved form of the original dataset-generation features. They've been expanded with new agent types and now sit alongside the persistent Catalogue as one of two complementary surfaces on the platform. *** ## Security & compliance **Q: Where is my data stored?** A: EU and US data residency options are available. Region is selected at workspace creation. **Q: Is Claro SOC 2 certified?** A: A SOC 2 Type II audit is in progress; expected completion Q4 2025. DPA available on request. **Q: How do I get support?** A: Free and Starter plans include community support via our Slack channel. Dedicated plans include a dedicated success team. Email **[hello@getclaro.ai](mailto:hello@getclaro.ai)** for anything urgent. # Getting Started Source: https://docs.getclaro.ai/getting_started Common workflows you can run today — from supplier onboarding to taxonomy improvement to competitive monitoring. This page walks through the workflows most teams set up first. Each is built from the same primitives — catalogues, operations, and (where helpful) Research Agents — and each produces auditable, scored, reversible changes. If you're new to the platform, start with the [Quick Start Guide](/quick_start) to set up your first catalogue, then come back here for the recipes. *** ## Workflow 1 · Onboard a new supplier Bring a supplier's catalog into yours, mapped, validated, enriched, and synced — without manual cleanup. 1. Send the supplier a [Supplier Portal](/modules/onboard) link. 2. Supplier uploads their feed. 3. **Data Source Mapping** matches their SKUs to existing records; unmatched rows are flagged. 4. **Validate Data** checks schema and rule conformance. 5. **Bulk Enrichment** fills gaps from supplier docs, web sources, or model generation. 6. Reviewer approves uncertain items in [Notifications](/notifications). 7. **Push & Sync** publishes to downstream platforms. Wire steps 3–7 into a single chained pipeline so every supplier upload flows through the same gates. *** ## Workflow 2 · Improve an existing taxonomy Move from messy free-text categories to a versioned, hierarchical taxonomy. 1. Run [**Analyse**](/modules/analyse) on the catalogue to identify weak coverage. 2. Run **Generate Taxonomy** for a proposed structure. 3. Curate in the [Taxonomy](/taxonomy) surface; publish a new version. 4. **Bulk Enrichment** reassigns records to the new taxonomy with confidence scores. 5. Below-threshold assignments queue for review. Keep the old taxonomy version live while you migrate — Claro tracks which records are on which version, and roll-back is one click. *** ## Workflow 3 · Monitor competitive drift Detect when a competitor changes pricing, content, or imagery — and react. 1. Configure [**Monitor → Competitor**](/modules/monitor) with target SKUs and competitor sources. 2. Configure [**Monitor → Price**](/modules/monitor) thresholds for alerts. 3. Anomalies and drifts feed into [Notifications](/notifications) and Slack. 4. **Bulk Enrichment** can update internal listings in response, gated by review. Most teams start with a small set (e.g. top-100 SKUs) and expand once thresholds are tuned. *** ## Workflow 4 · Find and merge duplicates Reduce a noisy catalogue to one record per real-world entity. 1. Run **Find Duplicates** on a catalogue. 2. Review clusters in [Similarity & Duplicate](/similarity_duplicate). 3. Approve merges; rejected pairs are remembered as negative examples to refine future matching. Run Find Duplicates on a schedule once you're happy with the thresholds — new duplicates that arrive via supplier uploads will be caught and queued automatically. *** ## Workflow 5 · One-off prospect or supplier list You don't always need a catalogue. For a list you'll use once, reach for [Research Agents](/research_agents). 1. Open **Research Agents → Find your perfect list**. 2. Describe the entity class and seed criteria. 3. Review the dataset and citations. 4. (Optional) Promote the dataset into a Catalogue if it becomes ongoing. *** ## Workflow 6 · Generate SEO-ready content at scale Replace thousands of weak titles, descriptions, and metadata fields. 1. Run [**SEO Report**](/operations#seo-report-beta) on the catalogue to identify weak fields and per-record opportunities. 2. Configure **Generative Engine** with prompts that reference brand guidelines (Knowledge Base) and target attributes. 3. Run, review the bottom decile by confidence, then raise the auto-apply threshold once you're comfortable. 4. **Push & Sync** publishes the approved content. *** ## What to do next * For a full tour of every surface, see [Platform Overview](/platform_overview). * For the operation reference, see [Operations](/operations). * For governance — confidence, review, rollback — see [Confidence Scoring](/confidence_scoring). * For pricing and credits, see [Pricing & Credits](/pricing). # Introduction Source: https://docs.getclaro.ai/introduction Run your catalog like a system, not a spreadsheet. Claro is a platform for keeping product and supplier catalogs clean, structured, and decision-ready — at the scale and frequency that real catalogs actually change. Most catalog tooling assumes data arrives once, gets cleaned once, and stays clean. In practice, catalogs are continuously edited by suppliers, partners, and internal teams; attributes drift; new SKUs arrive without specs; taxonomies evolve; duplicates accumulate. Claro is built around that continuous reality. The platform is organized around two complementary surfaces: * **A persistent Catalogue** — your products, suppliers, SKUs, and the relationships between them, with full attribute schemas, history, and provenance. * **Operations that run on the Catalogue** — enrichment, validation, normalization, deduplication, taxonomy generation, monitoring, and sync — each producing auditable changes with confidence scores attached. Research Agents (lists, document parsing, scraping, spreadsheet analysis) remain available for one-off datasets and exploration, but the center of gravity of the platform is now the Catalogue and the operations that act on it. *** ## Core concepts ### Catalogue A Catalogue is a typed object — Products, Suppliers, Line Items, Variants, etc. Each object has: * **Attributes** — the schema (typed fields: text, number, image, date, enum, reference). * **Records** — the actual rows. * **Data Sources** — the upstream feeds, files, APIs, or scrapes that populate it. * **Operations** — the running and scheduled transformations against it. * **Config** — access, retention, write-back rules. Multiple catalogues can exist in a workspace and can reference each other (e.g. `Product.supplier` → `Supplier`). ### Operations Operations are the verbs of the platform. They read records, optionally call models or external systems, and write back changes. Every operation produces a run with inputs, outputs, confidence per change, and a reversible diff. Operations can be triggered manually, scheduled, or chained into pipelines. ### Confidence and review Every model-driven write is scored. Each operation has a configurable confidence threshold: * Above threshold → auto-apply * Below threshold → queue for human review in the Notifications surface Thresholds, reviewers, and auto-apply behavior are set per operation and per attribute. ### Provenance Every value in the Catalogue carries the source of the last write — which operation, which run, which underlying data source, which model, which reviewer. Roll-back is per-field. ### Taxonomy Taxonomies are first-class objects, not free-text labels. They are hierarchical, versioned, and can be generated from your data, imported from a standard (GS1, Google, internal), or hand-edited. Taxonomy assignments are themselves tracked operations with confidence scores. ### Similarity & Duplicate graph Claro maintains a similarity graph across records using a combination of embedding similarity and rule-based matching. Duplicate detection, supplier match, variant grouping, and entity resolution all read from this graph. *** ## Platform layout The product is organized into three groups in the sidebar: ``` CORE — the persistent catalog and its global views MODULES — the operational stages: Onboard, Analyse, Monitor, Distribute RESEARCH AGENTS — one-off list-building and extraction tasks ``` See [Platform Overview](/platform_overview) for a tour of every surface. *** ## What changed from the previous version If you used Claro before, the most important changes: * **Catalogues are now the center of the platform.** What used to be one-off datasets generated by Research Agents now sit alongside persistent catalogues with attributes, records, data sources, operations, and config. * **Operations are first-class.** Every transformation — enrichment, validation, normalization, deduplication, taxonomy assignment, sync — is an auditable run with confidence scores and a reversible diff. * **The sidebar is restructured** into Core (persistent state), Modules (operational stages: Onboard, Analyse, Monitor, Distribute), and Research Agents (ad-hoc tasks). * **Continuous monitoring is built in.** Price, competitor, and validation operations can run on a schedule and alert into Notifications. * **Confidence and review are explicit.** Every operation has thresholds; uncertain changes queue for human approval rather than failing silently or shipping unreviewed. Ready to set up a catalogue? Continue to [Quick Start Guide](/quick_start). # Knowledge Bases Source: https://docs.getclaro.ai/knowledge_bases Workspace-scoped document collections that operations and agents cite when generating or matching content. A Knowledge Base is a collection of documents — supplier datasheets, brand guidelines, prior catalogs, domain references, policy files — indexed for retrieval and cited in operation outputs. When an operation draws from a Knowledge Base, it tells you which document and passage it used, so every generated value is traceable. Knowledge Bases are workspace-scoped (shared across catalogues) but attached per-operation (you choose which KBs a given run can see). *** ## How they work 1. Upload documents (PDFs today; Word, PowerPoint, and plain text coming soon). 2. Claro chunks and indexes the content automatically. 3. When an operation runs, the model retrieves the most relevant passages per record. 4. Outputs include citations — document name, page number, the relevant passage. Retrieval is semantic, not keyword-based. A product description about *"wireless over-ear headphones with active noise cancellation"* will pull the relevant section of a supplier datasheet even if the wording differs. *** ## When to use a Knowledge Base | Use case | What to add | | --------------------------------------------- | ------------------------------------------------------------------- | | **Bulk Enrichment** — product attributes | Supplier datasheets, product manuals, technical specs. | | **Generative Engine** — descriptions and copy | Brand voice guidelines, style guides, example copy. | | **Validate Data** — compliance checks | Policy documents, regulatory standards, certification requirements. | | **Generative Engine** — translations | Glossaries, approved terminology lists per locale. | | **Classification / Taxonomy** | Category definitions, GS1 or internal taxonomy descriptions. | | **Find Similarities** — matching | Prior approved-match decisions, entity resolution rules. | *** ## Storage limits by plan | Plan | Knowledge Bases | Storage per KB | Max file size | | --------- | --------------- | -------------- | ------------- | | Free | 1 | 10 MB | 10 MB | | Starter | 5 | 50 MB | 20 MB | | Dedicated | Unlimited | 500 MB\* | 100 MB | \*Higher quotas available on request. *** ## Setting up a Knowledge Base **Step 1 · Create** * From the Knowledge Bases panel, click **New Knowledge Base**. * Use a descriptive name: `Brand-Guidelines-EN`, `Supplier-Datasheets-2025`, `REACH-Compliance-Docs`. **Step 2 · Add content** * Drag and drop PDFs, or paste text directly. * Organize by topic — focused collections retrieve better than broad dumps. * Update documents when the source changes; old versions can be archived rather than deleted so existing provenance links stay valid. **Step 3 · Attach to an operation** * When configuring Bulk Enrichment, Generative Engine, or a Research Agent run, select the relevant Knowledge Bases. * Multiple KBs can be selected; the model searches across all of them. *** ## Best practices * **Stay focused.** One KB per topic is more accurate than a single large collection. The retriever scores passages against the query; fewer irrelevant passages means better hits. * **Keep current.** Archive old versions; don't leave outdated docs alongside current ones. * **Use descriptive names.** Include purpose and date so it's clear what each KB contains and whether it's current. * **Test relevance.** After attaching a KB, check the citations on a sample of outputs to confirm the right passages are being retrieved. * **Multilingual data.** Create separate KBs per language rather than mixing locales in one collection. *** ## Deleting a Knowledge Base Deleting a KB does not affect existing operation results — they retain their citations and provenance. It only means future runs can no longer access that content. # Analyse Source: https://docs.getclaro.ai/modules/analyse Operations that read the catalogue and produce assessments, suggestions, or transformations. Analyse is where you understand the state of a catalogue and trigger the transformations that improve it. The module exposes two surfaces: **Analyse** (data-quality reporting) and **Generative Engine** (model-driven content operations). *** ## Analyse Runs a data-quality assessment on a catalogue or a filtered record set. Output includes: * **Headline metrics** — total records, unique entries, duplicate estimates, columns analysed. * **Strengths and attention areas** — narrative summary of what's good and what's weak. * **Prioritized recommendation** — the single highest-leverage next operation to run. * **Per-field scores** — fill rate, uniqueness, length variance, with an `excellent / good / fair / poor` rating. * **Distribution stats** — mean, median, standard deviation, min, max — for numeric columns. * **Critical issues** — issues with one-click follow-on actions: * *Trigger Enrichment* on a low-fill column * *Review and Validate* on suspicious distributions * *Find Duplicates* on suspected entity collisions * *Generate Taxonomy* when category coverage is poor * **Overall Data Quality Score** — out of 100, computed from per-field scores weighted by the importance configured in the catalogue's Config tab. Analyse is non-destructive — it reads records and writes a report, never modifies data. ### When to run * Before kicking off a new pipeline, to set a baseline. * After a large batch of new records, to spot regressions. * On a schedule (e.g. weekly), to track quality over time. Reports are versioned; you can diff two reports to see what improved or regressed. *** ## Generative Engine Model-driven generation operations that produce content from your records. | Capability | Output | | ----------------------------------- | ------------------------------------------------------------------------------------------- | | **Descriptions** | Long-form product descriptions, optimized for SEO and brand voice. | | **Marketing copy** | Short copy variants — headlines, taglines, social posts. | | **Structured attribute extraction** | Pull typed fields out of free-text descriptions or supplier blurbs. | | **Image alt-text** | Accessibility-compliant alt text from product images. | | **Translations** | Multi-language variants of any text attribute, with brand-voice consistency across locales. | ### Configuration For every Generative Engine job you choose: * **Target attribute(s)** — where the output is written. * **Prompt** — the instruction, with `@attribute` references to other fields on the same record. * **Knowledge Bases** — domain documents (brand guidelines, datasheets) the model can cite. * **Model** — Claro default (with confidence scoring and citations) or another available model. * **Confidence thresholds** — auto-apply, review, reject. * **Length and format constraints** — character limits, schema, allowed tones. Outputs ship with confidence scores and citations to the sources used, so each generated value is auditable. Below-threshold outputs queue for review in Notifications. ### Tips * Reference other attributes by name with `@` to ground generation in the record. *"Write a 100-word description for `@product_name` based on `@spec_summary`, in the voice of `@brand`."* * Include a Knowledge Base of brand and category guidelines for consistency across thousands of generations. * Generate in batches and review confidence distributions before raising the auto-apply threshold. # Distribute Source: https://docs.getclaro.ai/modules/distribute Pushing clean data downstream — Unified Catalog and Sync & Export. Distribute is the last mile: getting catalogue data out of Claro and into the systems that use it. Two surfaces: * **Unified Catalog** — a denormalized, query-ready view of the catalogue. * **Sync & Export** — connectors to Shopify, Amazon, BigQuery, Google Sheets, Webhooks, and S3. *** ## Unified Catalog A read-optimized view that flattens references and joins multiple catalogues into a single shape ready for consumers. ### What it produces * **Denormalized records** — `Product` joined to `Supplier`, `Category`, `Variants`, etc., with chosen fields inlined. * **A read API** — paginated, filterable, with the same auth as the rest of your workspace. * **Exports** — CSV, JSONL, Parquet — generated on schedule or on demand. * **Versioned snapshots** — each export is tagged so downstream consumers can pin to a specific snapshot. ### Configuration * **Source catalogues** — which catalogues feed the unified view. * **Field selection and renaming** — pick the attributes to expose, alias them to consumer-friendly names. * **Filter** — only rows that satisfy a predicate (e.g. published == true). * **Refresh** — live (always current) or scheduled. * **Access control** — per-consumer API keys with field-level permissions. ### When to use * A search index or recommendation system that needs a flat, denormalized feed. * Analytics consumers who need a stable, versioned snapshot. * Internal tools that want one endpoint instead of joining multiple catalogues themselves. *** ## Sync & Export Outbound connectors that push records (and updates) into external systems. ### Built-in connectors | Connector | Modes | | ----------------------- | ------------------------------------------------------------------- | | **Shopify** | Create/update products, variants, metafields, images. | | **Amazon** | Push listings via SP-API; manage feed types and processing reports. | | **BigQuery** | Append or replace tables; partition and clustering supported. | | **Google Sheets** | Bi-directional sync with named ranges. | | **Webhooks** | POST per change, batch, or on schedule; signed payloads. | | **S3** | Periodic dumps, with optional encryption. | | **Supabase / Postgres** | Insert/update via SQL or REST. | | **Slack** | Notification deliveries (not record sync). | Each connector has its own: * **Mapping** — catalogue attributes to platform fields, with type coercion. * **Schedule** — real-time, hourly, daily. * **Conflict policy** — how to resolve if the downstream system has a value that conflicts. * **Filter** — a subset predicate so you can sync only published, only specific categories, etc. * **Retry and backoff** — configurable per connector. ### Push & Sync (Beta) The **Push & Sync** operation on a catalogue runs an immediate push for the records in scope. It honors the connector's mapping and conflict policy, and produces a run with success/failure counts and per-record errors. Use Push & Sync for: * One-off backfills or migrations. * Re-syncing after a large bulk update. * Triggered pushes from a chained pipeline. ### Custom connectors For systems not listed, two paths: * **Webhooks** — receive every change (or a batch) at your endpoint with a signed payload. * **Custom connector** (Dedicated plans) — Claro's success team builds a connector against your system's API. *** ## Inbound vs. outbound Distribute handles outbound only. Inbound connectors (file upload, scheduled scrapes, HTTPS pulls, Supabase/BigQuery/Postgres reads, Supplier Portal, email-as-source) live on each catalogue's **Data Source** tab — see [Data Import & Ingestion](/data_import_ingestion). # Monitor Source: https://docs.getclaro.ai/modules/monitor Continuous observation operations — Price and Competitor. Monitor watches your catalogue and the outside world on a schedule. Where Analyse produces a one-time assessment, Monitor produces a continuous stream of recurring runs that feed alerts into Notifications. *** ## Price Track prices across a configurable cadence. Flag drifts, deltas, and anomalies relative to history or competitor data. ### What it watches * **Internal prices** — your own price attribute on a catalogue. * **Marketplace prices** — Amazon, Shopify, and configurable URL templates. * **Competitor prices** — when paired with the Competitor surface, side-by-side history per matched SKU. ### Configuration Per Price monitor, you configure: * **Catalogue and filter** — which records to watch. * **Sources** — which marketplaces or URLs to pull. * **Cadence** — hourly, daily, or weekly per source. * **Alert rules** — threshold-based (e.g. *alert when delta > 10%*), absolute (e.g. *alert when price \< cost + margin*), or anomaly-based (statistical outliers vs. history). * **Recipients** — Notifications, Slack, email. ### Outputs * **Price history** — full time series per record per source. * **Drift alerts** — pushed to Notifications when a rule fires. * **Pricing dashboards** — distribution, outliers, gap-to-competitor views. *** ## Competitor Pull competitor listings for matched SKUs, normalize them, and surface side-by-side comparisons. ### What it does * Identifies the competitor listing for each SKU using the similarity graph and configured match rules (GTIN, MPN, name + brand). * Pulls listing data (title, description, images, price, availability, rating) on a schedule. * Normalizes competitor fields against your schema so comparisons are apples-to-apples. * Surfaces side-by-side views: yours vs. each tracked competitor. ### Configuration Per Competitor monitor, you configure: * **Catalogue and filter** — which of your records to track. * **Competitor sources** — domains, marketplace seller IDs, or scrape templates. * **Match strategy** — which similarity threshold, which fields drive matching. * **Cadence** — daily or weekly per source. * **Alert rules** — new listings appearing, listings disappearing, content drift, image changes, rating shifts. ### Outputs * **Side-by-side record view** — yours vs. competitors with diff highlights. * **Competitor catalogue** — a parallel catalogue object holding normalized competitor records. * **Drift alerts** — fed into Notifications and/or Slack. *** ## Alerts vs. review items Monitor alerts are *informational*: they tell you something happened. They surface in Notifications but don't block anything — you don't have to approve them. If a Monitor alert needs to *change* a record (e.g. update internal pricing in response to a competitor drop), the alert can trigger a downstream operation — typically Bulk Enrichment with a pricing rule — whose outputs go through the normal review gate. *** ## Combining Monitor with other modules A common pattern: **Monitor → Analyse → Bulk Enrich → Push & Sync**. 1. **Monitor → Competitor** detects a competitor description has been updated. 2. **Analyse** flags that your description no longer covers a feature the competitor mentions. 3. **Bulk Enrichment** rewrites the affected records, gated by review. 4. **Push & Sync** publishes the approved updates to your storefront. # Onboard Source: https://docs.getclaro.ai/modules/onboard Bringing new data — suppliers, SKUs, files — into the catalogue. Onboard is the module for everything that happens before records are clean: receiving files, mapping them to the schema, resolving identities, and enriching gaps so the data is ready for downstream operations. The two surfaces under Onboard are **Status** and **Supplier Portal**. *** ## Status A pipeline view of in-flight onboarding jobs. ``` file received → mapped → resolved → enriched → ready ``` For every batch (a file upload, a portal submission, a scheduled scrape), Status shows: * **Stage** — the current step in the pipeline. * **Counts** — total rows, mapped, unmatched, in review, ready. * **Errors and stalls** — surfaced with a one-click jump to the failing operation. * **Run history** — every previous batch from the same source, with timing and outcome. Each stage maps to an operation: | Stage | Operation | | ---------- | ----------------------------------- | | Mapped | Data Source Mapping | | Resolved | Find Duplicates / Find Similarities | | Validated | Validate Data | | Normalized | Normalize Data | | Enriched | Bulk Enrichment | | Synced | Push & Sync | You can chain these into a pipeline so each new batch flows through the same gates without manual intervention. *** ## Supplier Portal A hosted intake surface you can share with suppliers. Suppliers don't need a Claro account — they upload files or fill structured forms via a tokenized link. ### What suppliers see * A branded portal with your workspace name and logo. * Clear instructions for the schema you expect (column names, required fields, allowed enum values). * A file uploader with inline schema validation — bad files are rejected with line-level error messages. * An optional structured form for small submissions. * A submission history so suppliers can resubmit corrections. ### What you see * Submissions land as Data Sources on the relevant catalogue. * Pre-mapped where possible: known suppliers with a saved mapping skip straight to validation. * New suppliers go through Data Source Mapping first. * Schema violations are flagged and routed back to the supplier (with optional auto-email). ### Configuring a portal Per portal, you configure: * **Target catalogue(s)** — which catalogues this portal feeds. * **Schema** — required fields, optional fields, enum value lists. * **File formats** — CSV, XLSX, fixed templates. * **Notifications** — who is alerted on submission, who is alerted on validation failure. * **Auth** — public link, password, or per-supplier tokens. *** ## A typical onboarding flow 1. Supplier receives a Supplier Portal link. 2. Supplier uploads their feed. 3. **Data Source Mapping** matches their SKUs to existing records; unmatched rows are flagged. 4. **Validate Data** checks schema and rule conformance. 5. **Bulk Enrichment** fills gaps from supplier docs, web sources, or model generation. 6. Reviewer approves uncertain items in Notifications. 7. **Push & Sync** publishes to downstream platforms. Most teams configure this as a chained pipeline so the entire flow runs unattended after step 2. # Notifications Source: https://docs.getclaro.ai/notifications The review queue for every operation that needs human approval. Every operation that produces a below-threshold change lands here. Notifications is the single place where reviewers approve, reject, or edit pending writes — for any catalogue, any operation, any data source. *** ## How items get here Three settings govern how aggressive each operation is: | Setting | Effect | | ------------------------ | ------------------------------------------------------ | | **Auto-apply threshold** | Confidence above which a write happens without review. | | **Review threshold** | Below auto-apply but above this — queues for review. | | **Reject threshold** | Below this — discarded with a logged reason. | Defaults are conservative. Per-operation, per-attribute, and per-source overrides are supported (set under the catalogue's Config tab). A change with confidence in the *review* band is sent to Notifications. A change in the *auto-apply* band is written immediately and shows up in operation history, not in Notifications. *** ## What a review item looks like Each item shows: * **The proposed change** — old value, new value, attribute, record. * **Confidence score** — the 0–100 score and the factors that contributed to it. * **Provenance** — the operation, run, data source, model, and any cited Knowledge Base passages. * **Side-by-side context** — for similarity merges, the two records and per-field similarity. * **Actions** — Approve, Reject, Edit, Skip, Snooze. Items are grouped by operation and clustered when they share a cause (e.g. all values from the same supplier upload, all merges from a single Find Duplicates run). *** ## Bulk actions Reviewers rarely act one-by-one. Common patterns: * **Approve all in this cluster** — one click to accept every change from a single run, optionally filtered by confidence range or attribute. * **Reject all from this source** — when an upstream supplier file is bad. * **Edit-then-apply** — fix the value inline; the edited value is recorded with the reviewer as the source. * **Refine and re-run** — adjust the operation's prompt or thresholds, then re-run on the failing subset. *** ## Reviewer assignment Each catalogue's Config tab specifies default reviewers. Reviewers can also be assigned per attribute (e.g. legal team for `compliance_*` fields, merch team for category and pricing fields). Items in your queue are filtered by your role and the attributes you own. An admin view shows everything in the workspace. *** ## What happens after review * **Approved** — the value is written to the record. Provenance includes both the originating operation and the reviewer. * **Rejected** — the proposed value is discarded. The reject is logged and (for similarity matches) used as a negative example to refine future matching. * **Edited** — the reviewer's value is written with the reviewer as the source. Every action is part of the catalogue's history and is reversible from the record's per-field log. *** ## Notifications vs. alerts Don't confuse review items (which need a decision) with monitoring alerts (which signal something happened). Monitor → Price and Monitor → Competitor publish alerts to the same surface, but alerts are informational — they link out to the relevant catalogue view rather than waiting on approval. Slack delivery is configurable per alert class. # Operations Source: https://docs.getclaro.ai/operations The verbs of the platform. Every transformation is an auditable run with confidence scores and a reversible diff. Operations are the building blocks of the Catalog Operations workflow. Every operation runs against a catalogue (or a filtered subset), produces a reversible change set, and writes scored, traceable updates back to records. This page is the reference for every operation currently available. Find them under the **Operation** tab on any catalogue. *** ## How operations run An operation always: 1. **Reads** records (the entire catalogue, or a saved filter). 2. **Optionally calls** models, web sources, or another catalogue. 3. **Produces a run** — a record of inputs, outputs, and per-change confidence. 4. **Writes back** changes, gated by the auto-apply / review / reject thresholds you've configured. Operations can be: * **Run on demand** — single execution against a filter. * **Scheduled** — recurring (hourly, daily, weekly, on-event). * **Chained** — output of one operation triggers the next (e.g. *Onboard → Validate → Normalize → Bulk Enrich → Push & Sync*). Every run is reversible. The catalogue maintains per-field history; rolling back affects only the field(s) you select. *** ## Operation reference | Operation | What it does | | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | | **Export** | Produce a file in CSV, XLS, Shopify, or Amazon format. Filters and column selection are honored. | | **Price Insights & Monitoring** | Configure recurring price checks across marketplaces; pricing trends and anomalies feed into Monitor → Price. | | **Bulk Enrichment** | Fill missing or incomplete attributes at scale. Sources can be web search, model generation, supplier lookup, or another catalogue. | | **Analyse** | Run the data-quality report (per-field scores, distribution stats, critical issues, overall score). | | **Data Source Mapping** | Match uploaded files to existing records using text similarity scoring; produces a mapping draft you can review before merge. | | **Push & Sync** | Push records to Shopify or Amazon (Beta). Maps catalogue attributes to platform fields per a configurable schema. | | **Enrich Images** | Generate or repair images with metadata: alt text, primary subject tags, dimensions, format normalization (Beta). | | **SEO Report** | Score listings on SEO health and produce optimization suggestions per field (Beta). | | **Find Duplicates** | Identify duplicate records using AI matching; produces merge proposals you can approve in bulk (Beta). | | **Find Similarities** | Group similar records into clusters and surface relationships; useful for variant grouping and supplier match (Beta). | | **Validate Data** | Run schema, format, and rule checks; produce an issue list with severity (Beta). | | **Normalize Data** | Standardize formats — units, currencies, dates, casing, language — across selected fields (Beta). | | **Generate Taxonomy** | Propose a hierarchical taxonomy from your records. Output goes to the Taxonomy surface for curation and versioning (Beta). | *** ### Export Produce a file in CSV, XLS, Shopify-ready, or Amazon-ready format. * **Inputs** — catalogue or filter, column selection, output format. * **Outputs** — a downloadable file, with a record of the export in run history. * **Formats** — generic CSV/XLS, plus marketplace-shaped templates that match required columns and value formats for direct upload. ### Price Insights & Monitoring Configure recurring price checks across marketplaces. Detected drifts and anomalies feed into [Monitor → Price](/modules/monitor). * **Inputs** — catalogue, target SKUs, source marketplaces, cadence, alert rules. * **Outputs** — price history time series, drift alerts, pricing dashboards. ### Bulk Enrichment Fill missing or incomplete attributes at scale. The most-used operation in most workflows. * **Inputs** — catalogue or filter, target attribute(s), source (web search, model generation, supplier lookup, another catalogue, Knowledge Base), prompt and grounding, confidence thresholds. * **Outputs** — proposed values per record with confidence and citations. Auto-applied above threshold; queued in Notifications below. * **Tips** — start narrow (one attribute, 100 records), tune the prompt and threshold, then expand. ### Analyse The data-quality report described in [Modules → Analyse](/modules/analyse). * **Inputs** — catalogue or filter. * **Outputs** — per-field scores, distribution stats, critical issues with one-click follow-on operations, overall Data Quality Score. * **Side effects** — none. Analyse never modifies records. ### Data Source Mapping Match the rows in an uploaded file (or any new Data Source) to existing records using text similarity scoring before merging. * **Inputs** — Data Source, target catalogue, fields to drive matching, threshold. * **Outputs** — a mapping draft: matched, unmatched, ambiguous. Review before merging. * **Use** — first stage of every onboarding pipeline; keeps duplicates out of the catalogue. ### Push & Sync (Beta) Push records to Shopify or Amazon. Maps catalogue attributes to platform fields per a configurable schema. * **Inputs** — catalogue or filter, target connector, mapping, conflict policy. * **Outputs** — a run with success/failure counts and per-record errors. Errors include the platform-side response. ### Enrich Images (Beta) Generate or repair images with metadata. * **Inputs** — catalogue or filter, image attribute, target metadata (alt text, subject tags, dimensions, format). * **Outputs** — alt text, structured tags, normalized image variants, with confidence per generated value. ### SEO Report (Beta) Score listings on SEO health and produce per-field optimization suggestions. * **Inputs** — catalogue or filter, target attributes (title, description, meta, alt text), keyword sources. * **Outputs** — per-record SEO score, per-field recommendations, opportunity list. ### Find Duplicates (Beta) Identify duplicate records using AI matching; produce merge proposals. * **Inputs** — catalogue, fields to weight, similarity threshold. * **Outputs** — clusters of likely duplicates with per-pair confidence; merge proposals you can approve in bulk via [Similarity & Duplicate](/similarity_duplicate). ### Find Similarities (Beta) Group similar records into clusters; useful for variant grouping and supplier match. * **Inputs** — catalogue, fields to weight, threshold. * **Outputs** — clusters with intra-cluster similarity scores and visualizations. ### Validate Data (Beta) Run schema, format, and rule checks against records. * **Inputs** — catalogue or filter, ruleset (built-in plus custom rules). * **Outputs** — an issue list with severity, attribute, and a suggested fix where applicable. ### Normalize Data (Beta) Standardize formats — units, currencies, dates, casing, language — across selected fields. * **Inputs** — catalogue or filter, target fields, normalization rules (currency target, unit system, date format, casing). * **Outputs** — proposed normalized values with provenance back to the original. ### Generate Taxonomy (Beta) Propose a hierarchical taxonomy from your records. Output goes to the [Taxonomy](/taxonomy) surface for curation and versioning. * **Inputs** — catalogue, fields used for clustering, target depth, optional seed taxonomy. * **Outputs** — a draft taxonomy with proposed assignments per record. Curate, then publish a version. *** ## Confidence, review, and rollback Three settings govern how aggressive each operation is: | Setting | Effect | | ------------------------ | ------------------------------------------------------ | | **Auto-apply threshold** | Confidence above which a write happens without review. | | **Review threshold** | Below auto-apply but above this — queues for review. | | **Reject threshold** | Below this — discarded with a logged reason. | Defaults are conservative. Per-operation, per-attribute, and per-source overrides are supported. Every write is reversible. The catalogue maintains a per-field history; rolling back affects only the field(s) you select, and a roll-back is itself a logged event. See [Confidence Scoring](/confidence_scoring) for how the score is computed. *** ## Chained pipelines Operations can be chained — the completion of one triggers the next. A typical onboarding pipeline: ``` Data Source Mapping ↓ Validate Data ↓ Normalize Data ↓ Bulk Enrichment ↓ Push & Sync ``` Each stage gates the next, so failures and below-threshold items in any stage halt the pipeline (or branch to review) before the catalogue is touched. # Platform Overview Source: https://docs.getclaro.ai/platform_overview A tour of every surface in the sidebar. The product is organized into three groups in the sidebar: ``` CORE — the persistent catalog and its global views MODULES — the operational stages: Onboard, Analyse, Monitor, Distribute RESEARCH AGENTS — one-off list-building and extraction tasks ``` *** ## Core ### Dashboard Entry point for any new workflow. The Dashboard splits the platform's two modes: * **Catalog Operations** — for working against your persistent catalog (onboard SKUs, improve taxonomies, monitor competition, analyze inventory). * **Research Agents** — for one-off lists and extractions (find prospects, parse documents, enrich spreadsheets, scrape URLs). Recent activity, active operations, and pending review items also surface here. ### Catalogue The Catalogue page is where you spend most of your time. Each catalog object opens with five tabs: | Tab | Purpose | | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Attributes** | Define and edit the schema. Add fields, change types, set validation rules, mark fields as required, set enum values, configure reference relationships. | | **Records** | The data itself. Sortable, filterable, editable in a spreadsheet-like grid. Inline edits create change events with provenance. | | **Data Source** | Connect upstream — file uploads, scheduled scrapes, supplier portals, APIs, database connections. Each source has its own mapping to attributes. | | **Operation** | Run and schedule operations against the records. See [Operations](/operations). | | **Config** | Access control, retention, write-back targets, default reviewers, auto-apply thresholds. | See the dedicated [Catalogue](/catalogue) guide for details. ### Taxonomy Manage hierarchical categories used across your catalogue. View the tree, edit nodes, version the taxonomy, and track which records map to which leaf. The **Generate Taxonomy** operation (under Modules → Analyse) can propose a taxonomy from your data; the [Taxonomy](/taxonomy) page is where you curate and publish the result. ### Similarity & Duplicate Inspect the similarity graph. Browse clusters, review proposed merges, set match thresholds, and configure which fields drive similarity. This surface is shared by the **Find Duplicates** and **Find Similarities** operations. See [Similarity & Duplicate](/similarity_duplicate). ### Notifications Every operation that needs review lands here. Review items are grouped by operation and can be approved, rejected, or edited inline. Bulk actions are available per cluster. See [Notifications](/notifications). *** ## Modules Modules group operations by the stage of work they support. Each module exposes its own surfaces in the sidebar but ultimately reads from and writes to the Catalogue. ### Onboard Bringing new data — suppliers, SKUs, files — into the catalogue. * **Status** — pipeline view of in-flight onboarding jobs (file received → mapped → resolved → enriched → ready). Errors and stalls surface here. * **Supplier Portal** — a hosted intake surface you can share with suppliers. Suppliers upload files or fill structured forms; submissions land as Data Sources on the relevant catalogue, pre-mapped where possible. See [Onboard](/modules/onboard). ### Analyse Operations that read the catalogue and produce assessments, suggestions, or transformations. * **Analyse** — a data-quality assessment with per-field scores, distribution stats, critical issues, and an overall Data Quality Score. * **Generative Engine** — model-driven generation: descriptions, marketing copy, attribute extraction, alt-text, translations. See [Analyse](/modules/analyse). ### Monitor Continuous observation operations. * **Price** — track prices across a configurable cadence; flag drifts, deltas, anomalies. * **Competitor** — pull competitor listings for matched SKUs and surface side-by-side comparisons. Both produce recurring runs and feed alerts into Notifications. See [Monitor](/modules/monitor). ### Distribute Pushing clean data downstream. * **Unified Catalog** — a denormalized, query-ready view of the catalogue, available as a read API and as exports. * **Sync & Export** — connectors to Shopify, Amazon, BigQuery, Google Sheets, Webhooks, and S3. Each connector has its own mapping, schedule, and conflict policy. See [Distribute](/modules/distribute). *** ## Research Agents Task-specific tools for ad-hoc work that doesn't (yet) belong in your persistent catalogue. | Agent | Use case | | --------------------------------------- | ------------------------------------------------------------------------------------- | | **Find your perfect list** | Generate a researched dataset of prospects, suppliers, partners, or any entity class. | | **Turn documents into structured data** | Extract structured records from PDFs, contracts, datasheets, or reports. | | **Analyze & enrich spreadsheets** | Upload a spreadsheet; validate, standardize, and complete missing data. | | **Scrape data from URLs** | Collect structured records from web pages. | Outputs land in **Generated Datasets** and **Uploaded Files**. Any generated dataset can be promoted into a Catalogue, at which point it becomes a persistent object. A growing library of additional agents is available in **Agent Library**. See [Research Agents](/research_agents). # Pricing & Credits Source: https://docs.getclaro.ai/pricing How credits work, what's included on each plan, and how to estimate your usage. Claro uses a credit-based system. Credits are consumed per record when an operation runs; failed tasks or empty results cost zero credits. Credit consumption varies by operation type and model selected. Credits are workspace-pooled. *** ## Plans | Plan | Monthly cost | Credits included | Best for | | ------------- | ------------ | -------------------- | --------------------------- | | **Free** | €0 | 200 + 200 bonus\* | Testing and small catalogs. | | **Starter** | €20 | 2,500 / month | Regular business use. | | **Dedicated** | Contact us† | Per entity ingested‡ | High-volume and enterprise. | \*Bonus credits awarded for sending feedback.\ †Contact **[hello@getclaro.ai](mailto:hello@getclaro.ai)** for custom pricing.\ ‡Dedicated plans charge per entity ingested (per row, not per column), with up to 5 operations per entity included. *** ## Additional credit packs * **2,000 credits for €20** — available on any plan. * No subscription required — purchase only when needed. * Credits from packs never expire. * Subscription credits reset monthly; unused credits do not roll over. *** ## Plan feature comparison | Feature | Free | Starter | Dedicated | | -------------------------------------------- | --------- | -------------- | ----------------------- | | API access | — | Yes | Yes | | Team roles & permissions | — | Yes | Yes | | Knowledge Bases | 1 (10 MB) | 5 (50 MB each) | Unlimited (500 MB each) | | Feedback loops & custom model | — | — | Yes | | Taxonomy generation & dynamic ontology | — | — | Yes | | Entity deduplication & resolution (advanced) | — | — | Yes | | Near real-time predictions | — | — | Yes | | Self-hosting | — | — | Yes | | Support | Community | Standard | Dedicated team | All plans include the core platform: Catalogue, Operations, Research Agents, Modules (Onboard, Analyse, Monitor, Distribute), Similarity & Duplicate, Taxonomy (standard), Notifications, and all built-in connectors. *** ## Credit consumption by operation | Operation | Credits per record | | ------------------------------------- | ------------------ | | Bulk Enrichment — Claro default model | 2 | | Bulk Enrichment — other models | varies | | Generative Engine | 2 | | Validate Data | 1 | | Normalize Data | 1 | | Find Duplicates / Find Similarities | 1 | | SEO Report | 2 | | Enrich Images | 2 | | Data Source Mapping | 1 | | Analyse (report) | 0 (read-only) | | Export | 0 | | Advanced OCR | 4 | Operations that read without writing (Analyse, Export) consume no credits. *** ## Enterprise features (Dedicated) * **Volume discounts** — tiered pricing for high-usage scenarios. * **Priority processing** — 20 concurrent operations with faster queue times. * **Custom integrations** — bespoke connectors built with our SDK. * **Dedicated success team** — direct technical support. * **Flexible deployment** — self-hosting and VPC options. * **Advanced features** — see [Advanced Features](/advanced_features). *** ## Billing Billing is managed from **Settings → Billing**. You can: * View credit balance and usage history. * Purchase top-up packs. * Upgrade or downgrade your plan. * Download invoices. * Cancel at any time — access continues until the end of the current billing period. # Quick Start Guide Source: https://docs.getclaro.ai/quick_start Stand up your first catalogue and run an operation against it in under 10 minutes. This guide walks through the catalogue-first flow: create a catalogue, connect a data source, run operations, review the changes, and sync downstream. If you only need a one-off dataset, skip ahead to [Research Agents](/research_agents). ### Step 1 · Create a catalogue (1 minute) * From the **Dashboard**, choose **Catalog Operations → Onboard & enrich SKUs** (or click **Start managing your catalog**). * Name the catalogue (e.g. *Products*, *Suppliers*) and pick a starting object type. Each catalogue is opened with five tabs: **Attributes**, **Records**, **Data Source**, **Operation**, **Config**. ### Step 2 · Define your attributes (1–2 minutes) * On the **Attributes** tab, add the typed fields your records need: text, number, image, date, enum, reference. * Mark fields as required, set enum values, and configure references between catalogues (e.g. `Product.supplier` → `Supplier`). * You can edit the schema later — Claro tracks attribute history alongside record history. ### Step 3 · Connect a data source (2 minutes) * On the **Data Source** tab, pick an upstream input: * File upload (CSV, XLSX) * Scheduled scrape or HTTPS pull * Supplier Portal submission * Database connector (BigQuery, Postgres, Supabase) * Map the source columns to your attributes. The mapping is saved per source and reused on subsequent syncs. ### Step 4 · Run your first operation (2–3 minutes) Open the **Operation** tab. The operation grid shows everything you can run against this catalogue. A typical first run: 1. **Validate Data** — surfaces schema issues, missing required fields, and rule violations. 2. **Normalize Data** — standardizes units, currencies, dates, and casing across the records. 3. **Bulk Enrichment** — fills missing attributes from web search, model generation, supplier docs, or another catalogue. Each operation produces a run with a reversible diff and a confidence score per change. ### Step 5 · Review and apply (1–2 minutes) * Above-threshold writes are auto-applied. * Below-threshold writes queue in **Notifications** for human review. * Review items can be approved, rejected, or edited inline; bulk actions are available per cluster. ### Step 6 · Sync downstream (1 minute) * Under **Distribute**, configure **Sync & Export** with the connectors you need: Shopify, Amazon, BigQuery, Google Sheets, Webhooks, S3. * Or expose the **Unified Catalog** as a query-ready view for downstream consumers. ### Tips * Start small — load 50–100 records, run the operations end-to-end, and tune the thresholds before scaling up. * Chain operations into a pipeline (Onboard → Validate → Normalize → Bulk Enrich → Push & Sync) so each new batch of records flows through the same gates. * Every value carries provenance — the operation, run, source, model, and reviewer that produced it. Roll-back is per-field. Ready to go deeper? See [Catalogue](/catalogue), [Operations](/operations), and the module guides for [Onboard](/modules/onboard), [Analyse](/modules/analyse), [Monitor](/modules/monitor), and [Distribute](/modules/distribute). # Research Agents Source: https://docs.getclaro.ai/research_agents Task-specific tools for ad-hoc list-building, document parsing, scraping, and spreadsheet enrichment. Research Agents are fast, task-specific AI agents for ad-hoc work that doesn't (yet) belong in your persistent catalogue. They generate lists, extract structured data from documents, enrich spreadsheets, and scrape URLs — with no schema setup required. If the result of an agent run is something you want to maintain over time, promote it into a [Catalogue](/catalogue). *** ## The four core agents | Agent | Use case | | --------------------------------------- | --------------------------------------------------------------------------------------------------------- | | **Find your perfect list** | Generate a researched dataset of prospects, suppliers, partners, or any entity class with key attributes. | | **Turn documents into structured data** | Extract structured records from PDFs, contracts, datasheets, or reports. | | **Analyze & enrich spreadsheets** | Upload a spreadsheet; validate, standardize, and complete missing data. | | **Scrape data from URLs** | Collect structured records from web pages. | ### Find your perfect list Describe your ideal prospects, suppliers, or partners and Claro generates a researched dataset with key attributes. * **Input** — a natural-language brief plus any seed criteria (region, size, industry, etc.). * **Output** — a typed dataset with rows, attributes, and per-cell citations. * **Use** — outbound prospecting, supplier discovery, market mapping. ### Turn documents into structured data Extract structured records from one or many documents at once. * **Input** — PDFs, scanned docs, contracts, datasheets, or reports plus a target schema (or *infer*). * **Output** — a typed dataset, one row per source document (or per logical entity), with per-field provenance. * **Use** — invoice batches, datasheet libraries, contract analysis, compliance ingest. ### Analyze & enrich spreadsheets Upload an existing spreadsheet and Claro validates, standardizes, and completes missing data. * **Input** — CSV / XLSX, plus an enrichment goal (fill missing, validate against rules, add derived columns). * **Output** — the enriched sheet with confidence scores per cell. * **Use** — quick clean-up of supplier exports, lead lists, or partner data before further work. ### Scrape data from URLs Collect structured records from web pages. * **Input** — a list of URLs (or a base URL with crawl rules) plus a target schema. * **Output** — a typed dataset with per-record source URL. * **Use** — competitor catalog snapshots, content audits, location data collection. *** ## Where outputs live * **Generated Datasets** — every agent run produces a dataset listed here. * **Uploaded Files** — input files retained for re-use and reproducibility. Both surfaces appear in the sidebar under Research Agents. *** ## Promoting a dataset into a Catalogue When a one-off result becomes ongoing, promote it. From any Generated Dataset: 1. Choose **Promote to Catalogue**. 2. Pick the target catalogue (existing or new). 3. Map columns to attributes. New attributes can be created on the fly. After promotion the records become persistent and subject to all the same operations, provenance tracking, and review gates as native catalogues. *** ## Agent Library Research Agents is not a closed set. Browse **Agent Library** in the sidebar for additional task-specific agents (added regularly), and pin the ones your team uses most to your dashboard. *** ## When to use a Research Agent vs. a Catalogue operation | Situation | Use | | ------------------------------------------------------ | ---------------------- | | One-off list, won't repeat | Research Agent | | Quick exploration before defining a schema | Research Agent | | Recurring data, accountable for accuracy over time | Catalogue + Operations | | Multi-source feeds with versioning, review, sync needs | Catalogue + Operations | The two surfaces complement each other. Many teams use Research Agents to scope a dataset, then promote it into a catalogue once the schema and quality bar are clear. # Security & Compliance Source: https://docs.getclaro.ai/security How Claro protects your catalog data and meets enterprise compliance requirements. ## Data protection * **Encryption in transit** — TLS 1.3 for all API and browser traffic. * **Encryption at rest** — AES-256 for all stored data. * **Per-workspace encryption keys** — available on Dedicated plans. * **Data residency** — EU and US regions available; region is selected at workspace creation. ## Authentication & access control * **Single Sign-On** — Okta and Azure AD on Dedicated plans. * **Role-based access control** — per-catalogue permissions for read, edit, and approve. Reviewer roles restrict access to the Notifications surface only. * **API security** — bearer token authentication with per-token scope and rate limiting. * **Audit log** — complete activity log covering operations, record edits, approvals, sync events, and user management changes. ## Workspace isolation Each workspace is isolated at the data layer. Cross-workspace access is not possible. All catalogue data, operation runs, and Knowledge Base content stay within the workspace boundary. ## Compliance * **GDPR** compliant. Data Processing Agreement (DPA) available on request. * **CCPA** compliant. * **SOC 2 Type II** — audit in progress; expected completion Q4 2025. Full compliance documentation is available at **[hello@getclaro.ai](mailto:hello@getclaro.ai)**. ## Self-hosting (Dedicated) For organizations that require on-premises or private-cloud deployment: * Kubernetes Helm chart for any cluster. * Managed VPC setup in your cloud account. * Air-gapped environment support (no external calls). * On-premises installation with dedicated support. ## Responsible disclosure If you discover a security vulnerability, please report it to **[security@getclaro.ai](mailto:security@getclaro.ai)**. We aim to acknowledge reports within 24 hours and provide a resolution timeline within 72 hours. # Similarity & Duplicate Source: https://docs.getclaro.ai/similarity_duplicate Inspect the similarity graph, review proposed merges, and configure how matching works across the catalogue. Claro maintains a similarity graph across records using a combination of embedding similarity and rule-based matching. Duplicate detection, supplier match, variant grouping, and entity resolution all read from this graph. *** ## What the graph contains Every record in a catalogue is embedded across the attributes you select. The graph stores: * **Pairwise similarity scores** — between records in the same catalogue, and across catalogues you've connected. * **Cluster memberships** — high-confidence groups of records likely to be the same entity or close variants. * **Match decisions** — every approve/reject decision is remembered and used as positive or negative training signal for future matching. The graph is updated continuously as records change, are added, or are removed. *** ## The Similarity & Duplicate surface The page is a single workspace for inspecting and acting on the graph. * **Cluster browser** — proposed clusters of likely duplicates or variants, sortable by size, average similarity, and confidence. * **Pair view** — for any two records, a side-by-side diff with attribute-level similarity scores. * **Threshold controls** — set the score above which proposals auto-merge, and the score below which they're discarded. * **Field weights** — configure which attributes drive similarity (e.g. weight `gtin` and `mpn` higher than `description`). * **Reasoning** — for every proposed merge, the contributing fields and their individual scores. *** ## How operations use the graph * **Find Duplicates** — surfaces clusters of likely duplicate records and produces merge proposals you can approve in bulk. * **Find Similarities** — surfaces broader similarity clusters useful for variant grouping, supplier match, and cross-catalogue linking. * **Data Source Mapping** — when an uploaded file lands as a Data Source, the graph is queried to match each row to existing records before merge. * **Bulk Enrichment** can pull values from similar records when filling gaps. *** ## Merging and rejecting When you approve a merge proposal: * The records are combined into a single record. * Conflicting attribute values resolve via configured rules (most-recent, highest-confidence, source priority, manual choice). * All references and history from both records are preserved on the survivor. * The merge is reversible from the record's history. When you reject a pair: * The pair is added to a negative-examples set used to suppress similar proposals in the future. * This is workspace-scoped and improves match precision over time. *** ## Tuning matching You'll typically tune three things per catalogue: 1. **Field weights** — which attributes matter most for identity. `gtin` should dominate `description`. 2. **Auto-merge threshold** — high enough that auto-applied merges are virtually always correct. 3. **Review threshold** — the floor for proposals that queue in [Notifications](/notifications). Below this, proposals are discarded. Defaults are conservative. Adjust them once you've reviewed a few hundred merges and have a sense of where the score distribution lands for your data. # Taxonomy Source: https://docs.getclaro.ai/taxonomy Hierarchical, versioned categorization — first-class, not a free-text label. Taxonomies in Claro are managed objects, not strings on a record. Every taxonomy has a structure, a version, an owner, and assignment history per record. *** ## What a taxonomy is A taxonomy is a tree (or forest) of nodes. Each node has: * **Name** — the human-readable label. * **Path** — the full path from root, e.g. `Electronics > Audio > Headphones > Over-Ear`. * **Synonyms / aliases** — alternate spellings or supplier-specific names. * **Description** — optional definition used by AI assignment. * **Properties** — typed attributes inherited by every record assigned to this node. Taxonomies are versioned. Each published version is immutable; changes happen on a draft until you publish. *** ## Where taxonomies come from You can populate a taxonomy in three ways: 1. **Generate from data** — run the **Generate Taxonomy** operation under Modules → Analyse. Claro proposes a hierarchy from your records, which you curate before publishing. 2. **Import a standard** — bring in GS1, Google Product, UNSPSC, or your internal taxonomy as a starting point. 3. **Hand-edit** — build or refine the tree manually in the Taxonomy surface. Most teams combine all three: import a starting standard, generate proposals for the gaps, and curate by hand. *** ## Assigning records to taxonomy nodes Assignment is itself a tracked operation with confidence scores. * **Bulk Enrichment** with the taxonomy as a target attribute will propose assignments for unclassified records. * Above-threshold proposals are auto-applied; below-threshold proposals queue in [Notifications](/notifications) for review. * Assignments are versioned alongside the taxonomy: when you publish a new version, Claro shows you what would change and lets you re-classify in bulk. *** ## Working with the Taxonomy surface The Taxonomy page lets you: * Browse the tree and inspect node properties. * See record counts per leaf and per branch. * Drill into a node to view assigned records, with confidence and provenance. * Edit nodes — rename, merge, split, move, or deprecate. * Compare versions side-by-side. * Publish a new version, with a preview of which records would be re-assigned. *** ## Versioning and rollback Each published version has a version number and an effective date. Every record's taxonomy assignment is linked to a specific version. When a new version is published: * Existing assignments stay valid. * Records assigned to deprecated nodes are flagged for re-assignment. * A bulk re-classification job can be queued automatically. You can roll back to a prior version at any time; assignments revert to their state under that version. *** ## Tips * Keep node descriptions specific and unambiguous — they directly improve AI assignment accuracy. * Use synonyms aggressively: every supplier-specific term you add reduces manual review later. * Don't model attributes as taxonomy nodes. *Color: Red* is an attribute, not a category. * Generate Taxonomy works best on catalogues that already have decent free-text descriptions or category hints.