Incidecoder Ingredients Scraper

Export public INCIDecoder ingredients data as structured product records for formulation research. Search by product or brand, or supply exact product URLs. Each result includes product identity, brand, the ordered full ingredient list, normalized ingredient links, functions, explanations, aliases, disclosed irritancy and comedogenicity values, INCIDecoder ratings, and formulation flags.

Who is it for?

• Cosmetic formulators comparing disclosed ingredient functions.
• Product and category teams researching competing formulations.
• Data analysts building normalized cosmetic ingredient datasets.
• Researchers tracking source-disclosed formulation flags.
• Catalog teams enriching known products with ordered ingredient details.

Why use this Actor?

The source presents valuable details across an overview, a comparison table, and expanded ingredient cards. This Actor joins those surfaces into one stable nested record. It preserves source order and normalized links, avoids loading product images, deduplicates products found through multiple inputs, and charges only for useful product rows.

What can you use it for?

• Compare formulations across products or brands.
• Build ingredient-function and product-flag datasets.
• Enrich an existing cosmetic catalog from known INCIDecoder URLs.
• Schedule repeat runs and compare datasets in your own database or automation.

Extracted data

Field	Meaning
productName	Product name shown by the source.
brand	Product brand when disclosed.
productUrl	Canonical INKEE Decoder product page.
description	Source product description.
uploadedAt	Source-disclosed upload date.
imageUrl	Public product image URL, without downloading the image.
flags	Formulation flags such as alcohol-free.
ingredientCount	Number of ingredients in source order.
ingredientNames	Spreadsheet-friendly ordered names.
ingredients	Full normalized ingredient objects.
keyIngredients	Source-labeled Key Ingredients function-to-name groups.
otherIngredients	Source-labeled Other Ingredients function-to-name groups.
scrapedAt	Extraction timestamp.

Getting started

1. Open the Actor input page.
2. Add a product or brand term under Product or brand searches.
3. Optionally add exact public product URLs.
4. Choose a product limit.
5. Start the run.
6. Open the Product results dataset view.
7. Export JSON, CSV, Excel, XML, or connect the dataset API.

Input parameters

Field	Description
searchQueries	Plain-text terms passed to the source search; no Actor-side exact-match filter. Whitespace-normalized duplicate queries are skipped.
startUrls	Exact public INCIDecoder product pages, processed before searches. Action pages such as /products/create are rejected.
maxItems	Global maximum useful product rows (default 20, range 1–1,000); failed candidates do not consume the limit.
maxSearchPages	Global search-page budget across all queries, including first pages (default 20, range 1–100). Retries are additional attempts. Ignored for URL-only runs.
maxRequestRetries	Additional request retries from 0 to 5 (default 2); 404 pages are not retried.

Provide at least one search query or product URL. Exact URLs come first, followed by queries in input order. Original and canonical hosts, URL queries/fragments and repeated products deduplicate. Only validated same-source product-tab Next links are followed. Unused queries/pages stop as soon as the global useful-product or charge limit is reached. Source exhaustion, page budget, platform timeout or charge budget may produce fewer rows; this is never an exhaustive catalog export.

{
  "searchQueries": ["CeraVe cleanser"],
  "maxItems": 3
}

Output example

{
  "productName": "Cleanser",
  "brand": "CeraVe",
  "productUrl": "https://inkeedecoder.com/products/cerave-cleanser",
  "flags": ["alcohol-free", "fragrance & essentialoil-free"],
  "keyIngredients": {"Anti-acne": ["Niacinamide", "Phytosphingosine"]},
  "otherIngredients": {"Solvent": ["Purified Water"]},
  "ingredientCount": 22,
  "ingredientNames": ["Purified Water", "Cocamidopropyl Hydroxysultaine", "Glycerin"],
  "ingredients": [
    {
      "position": 1,
      "name": "Purified Water",
      "url": "https://inkeedecoder.com/ingredients/water",
      "functions": ["solvent"],
      "alsoCalled": ["Aqua", "Water"],
      "irritancy": null,
      "comedogenicity": null,
      "rating": null
    }
  ]
}

Output details

One default-dataset row represents one product. The nested ingredients array preserves source order and contains position, name, normalized url, functions, explanation, alsoCalled, irritancy, comedogenicity, and rating. Product fields include productName, brand, description, uploadedAt, imageUrl, flags, ingredientCount, ingredientNames, productUrl, and scrapedAt.

Missing source disclosures are returned as null, empty arrays or empty group objects rather than inferred. keyIngredients and otherIngredients preserve the source's labels and ingredient names; they do not classify safety or fetch extra ingredient pages. The example above shows selected ingredient entries; exported records contain the full parsed list.

Run summary and partial completion

The Run summary output links to the uncharged key-value record RUN_SUMMARY. It reports discoveredUnique (unique candidates on fetched pages and supplied URLs), attempted, saved, failed (product extraction failures), searchPages, completion, stopReason, and bounded failureCategories. It contains no raw input, query text, URLs, headers or response bodies. Discovered candidates can exceed attempted/saved products when a page supplies more than the remaining limit.

• complete: useful extraction finished at max_items or source_exhausted; this does not imply exhaustive catalog coverage.
• partial: useful mixed output or an incomplete search traversal (search_page_budget or pagination_cycle). Useful rows remain available even when some candidates fail.
• no_matches: the source explicitly showed no product matches, distinct from transport or markup failures.
• budget_limited: the run stopped at the platform charge budget; no uncharged product rows are emitted.
• failed: all attempted products failed, search requests failed without useful output, or a fatal input/runtime error occurred. The run is non-successful, not a misleading empty success.

Category counts use only not_found, transport, http, response_shape, product_shape, and search_shape. A product needs at least one valid ingredient before it can become a useful row. Platform termination before final persistence can leave a summary unavailable; terminal diagnostics remain separate.

How much does it cost to scrape INCIDecoder product ingredients?

Pay-per-event pricing has a $0.005 run start and a BRONZE product-result rate of $0.0039 per product. A run that returns 10 products emits 10 item events; a run that returns 100 emits 100 item events, in addition to the single start event. Higher usage tiers reduce the per-product rate. Failed, duplicate, and rejected pages are not charged as product results. The charge budget is checked before further work and before saving; each delivered useful product corresponds to one item event. The summary is not a charged dataset row. Apify platform usage may also apply according to your plan.

Example workflows

Brand formulation scan

Search a brand or formulation term and cap both useful products and search pages for a bounded snapshot. For example, {"searchQueries":["acid"],"maxItems":55,"maxSearchPages":2} can traverse beyond the first product-results page if enough valid products remain available. Inspect RUN_SUMMARY for the actual stop reason; 55 products are not guaranteed. Store dated datasets and compare ingredient arrays downstream.

Exact catalog enrichment

Map your known product URLs into startUrls. Join returned rows to your catalog by productUrl, then index ingredientNames for filtering.

Function research

Compare keyIngredients and otherIngredients directly by source function label, preserving the source's distinction. For per-ingredient analysis, flatten the existing nested ingredients array and group by functions, keeping product identity and ingredient position as context.

Run with the API

cURL

curl -X POST "https://api.apify.com/v2/acts/automation-lab~incidecoder-cosmetic-products-ingredients/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://incidecoder.com/products/cerave-cleanser"}],"maxItems":1}'

After completion, fetch items from the run's default dataset.

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/incidecoder-cosmetic-products-ingredients').call({
  searchQueries: ['CeraVe cleanser'],
  maxItems: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/incidecoder-cosmetic-products-ingredients').call(
    run_input={'searchQueries': ['CeraVe cleanser'], 'maxItems': 3}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

MCP setup and prompts

Claude Code

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/incidecoder-cosmetic-products-ingredients"

Claude Desktop, Cursor, and VS Code

Add this MCP JSON configuration in the client's MCP settings:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/incidecoder-cosmetic-products-ingredients"
    }
  }
}

Example prompts:

• "Run the INCIDecoder Actor for CeraVe cleanser and summarize ingredient functions."
• "Extract these two INCIDecoder product URLs and compare formulation flags."
• "Return a table of ingredient name, position, function, and rating for this product."

Integrations

Use the Apify MCP server to run this Actor from compatible AI clients. Scheduled Tasks, webhooks, Make, Zapier, Google Sheets, and database integrations can turn recurring runs into formulation-monitoring workflows.

Reliability and limitations

• Only public INCIDecoder/INKEE Decoder product pages are supported.
• Search lazily traverses bounded public product-result pages; it does not claim exhaustive catalog coverage.
• Runs are sequential HTTP extraction with no paid proxy/browser fallback and no extra ingredient-page requests.
• Mixed failures preserve useful products and expose partial completion in RUN_SUMMARY; all-failed extraction is non-successful.
• Ratings, flags, functions, and explanations are source disclosures, not medical or safety advice.
• The source can rename fields, redirect its domain, rate-limit requests, or remove pages. Transient retries are bounded.
• The Actor does not bypass login, CAPTCHA, or private content.

Data handling and support

This Actor uses deterministic HTTP parsing, not an AI model or external inference provider. Public formulation data is stored in your Apify dataset; input and the run receipt remain in the run's key-value store under your Apify access settings. Dataset/KV/log retention follows your Apify storage settings; delete run storage through Apify when no longer needed. No response-body archive, browser session or downloaded product image is retained by the Actor. For questions or defects, use the Actor's Apify Issues tab and include the run link and expected result; never post secrets in an issue.

INCIDecoder, INKEE Decoder and product brands are named only to identify source data. This Actor is independently operated and is not affiliated with or endorsed by those sources or Apify.

Private failure diagnostics

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; this Actor also redacts searchQueries and startUrls in both SDK and terminal snapshots. Reports are retained for 30 days. Diagnostic reports do not add charged dataset rows or replace the run's useful output.

Legality and responsible use

Scrape only public data and comply with INCIDecoder's terms, applicable laws, and your intended use. Avoid excessive request volume. Product and ingredient descriptions belong to their respective owners.

Troubleshooting

• No records: check that an exact URL points to /products/... or broaden the search term.
• Page not found: verify the product still exists publicly; redirects between INCIDecoder and INKEE Decoder are normalized automatically.
• Temporary upstream error: retry later or increase maxRequestRetries within the supported bound.

Tips for reliable runs

• Prefer exact product URLs when reproducibility matters.
• Use specific search terms instead of a broad one-word query.
• Keep maxItems close to the volume you actually need.
• Schedule at a reasonable cadence and compare datasets downstream.
• Treat missing ratings as missing source disclosure, not a negative rating.

FAQ

Does it return every ingredient?

Yes, it preserves the complete ingredient overview order shown on each successfully parsed product page.

Can I search and submit URLs together?

Yes. Exact URLs are processed first, then searches. Results are deduplicated globally and successfully saved useful products are capped by maxItems; failed candidates can be replaced by further distinct candidates within the page budget.

Does it assess ingredient safety?

No. It exports source-disclosed ratings and flags without producing medical, regulatory, or safety conclusions.

Related Actors

Explore other automation-lab Actors for product catalogs, public datasets, and research automation.