# Non-food Barcode and ISBN Catalog Lookup (`automation-lab/nonfood-barcode-isbn-catalog-lookup`) Actor

Look up UPC, EAN and ISBN batches in beauty, pet, classified non-food products and Open Library catalogs. Export source-attributed identities, image links, package text, book metadata and explicit unresolved statuses.

- **URL**: https://apify.com/automation-lab/nonfood-barcode-isbn-catalog-lookup.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 completed catalog lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Non-food Barcode and ISBN Catalog Lookup

Run **barcode product lookup** for supplied UPC, EAN and ISBN batches to enrich non-food catalogs with source-attributed identities, images, package text and book metadata. This Actor searches Open Beauty Facts, Open Pet Food Facts, classified non-food Open Products Facts records, and Open Library. It does not query Open Food Facts or Google Books.

### Who is it for?

Catalog operators can enrich cosmetics and household listings. Pet-supply teams can attach public product identities to inventory codes. Booksellers can normalize ISBNs and retrieve edition metadata. The Actor is a public-catalog lookup, not a universal commercial product database or barcode scanner.

### Why use it?

Keep each source match and its attribution instead of merging conflicting catalogs into a fabricated authoritative record. Preserve leading zeros, validate checksums, convert ISBN-10, and get explicit unresolved statuses suitable for spreadsheet joins. Images are returned as links, not downloaded assets.

### Getting started

1. Enter identifiers as strings in `codes`.
2. Leave all four sources selected, or select a known catalog.
3. Set `maxItems` to the number of distinct identifiers to process.
4. Run and inspect the default dataset.
5. Join on normalized `code` and retain `matches[].source` when saving results.

```json
{"codes":["9300830092116","4056489928225","0047871276929","9780140328721"],"maxItems":100}
```

### Input parameters

| Field | Behavior |
|---|---|
| `codes` | Required array of 1–1000 strings. Supports EAN-8/13, UPC-A, ISBN-10/13. Removes spaces and hyphens; validates every supplied checksum before work. |
| `sources` | Defaults to beauty, pet, household, books. These are exact catalog keys, not keyword filters. |
| `maxItems` | Global cap on distinct normalized identifiers after deduplication, including unresolved rows. Default 100, range 1–1000. No zero/unlimited option. |

ISBNs beginning 978/979 search Open Library only. ISBN-10 converts to ISBN-13; UPC-A receives a leading zero for the Facts catalogs. Equivalent normalized identifiers are processed once, retaining the first input spelling. If no selected source applies, the result is `excluded`.

### Extracted data

| Field | Meaning |
|---|---|
| `inputCode` | First original input string |
| `code` | Normalized barcode or ISBN |
| `status` | `found`, `not_found` or `excluded` |
| `matches` | One structured match per catalog with usable identity |
| `lookedUpAt` | UTC completion timestamp |
| `matches[].title` | Original catalog title |
| `brands`, `categories` | Source text, null when unavailable |
| `imageUrl`, `sourceUrl` | Image and original record links |
| `quantity`, `packaging` | Original package text, not converted units |
| `book` | Authors, publishers, publish date, pages and identifier families; null for products |
| `attribution` | Source and reuse guidance |

### Output example

The local ISBN control returned this edition identity (abbreviated):

```json
{
  "inputCode":"0140328726",
  "code":"9780140328721",
  "status":"found",
  "matches":[{
    "source":"books",
    "title":"Fantastic Mr. Fox",
    "sourceUrl":"http://openlibrary.org/books/OL7353617M/Fantastic_Mr._Fox",
    "book":{"authors":["Roald Dahl"],"publishers":["Puffin"],"publishDate":"October 1, 1988","numberOfPages":96},
    "attribution":"Open Library / Internet Archive; review source terms before reuse"
  }]
}
```

Actual records also include nullable image/package fields, identifier families and `lookedUpAt`. Export JSON to preserve nested matches; flatten matches downstream for CSV.

### How much does it cost to look up non-food barcodes and ISBNs?

A one-time run fee and one `item` event per **completed distinct identifier lookup** apply, whether found or not_found. A verified catalog miss is billed because the selected catalogs were checked. Multiple source matches have no separate charge. Excluded identifiers and failed/incomplete lookups have no item charge. Invalid input fails validation before charging start.

The run fee is **$0.0015 per run**. Per completed lookup, the prices are:

| Store spend tier | Item event price |
|---|---:|
| FREE | $0.0023 |
| BRONZE | $0.002 |
| SILVER | $0.00156 |
| GOLD | $0.0012 |
| PLATINUM | $0.0012 |
| DIAMOND | $0.0012 |

At BRONZE, estimated totals are $0.0035 for one completed lookup, $0.0215 for ten and $0.2015 for 100, including one run fee. These totals are the same for found identities and completed catalog misses. A run containing only excluded identifiers has only the $0.0015 run fee. Spend tiers depend on qualifying aggregate monthly Apify Store spend, not this Actor's batch size. Consult the live pricing tab for your applicable tier and platform billing limits. Examples are estimates, not guaranteed invoices.

### Coverage and exclusions

These are community catalogs, not exhaustive inventories. A valid checksum does not guarantee a record. Records without a usable title are omitted. Beauty and pet catalogs are source-specific; pet food is supported, human food is not a supported catalog category.

Household uses Open Products Facts, but only records with recognized non-food category roots: home/garden, electronics, health/beauty, office supplies, hardware, vehicle parts, arts/entertainment, sporting goods, toys/games, furniture, apparel/accessories, luggage/bags and media. Uncategorized products are deliberately omitted because that catalog contains misclassified food. Source classification can still be wrong; this is not certification of product contents.

No title search, manufacturer-code decoding, country-of-origin inference, price comparison, barcode generation, nutritional data, image recognition or built-in change alerts are supplied.

### Limits and troubleshooting

Requests run serially with approximately one-second pacing per catalog. Non-book codes may check three catalogs. Increase the run timeout for larger batches; roughly four seconds per non-book identifier is a starting estimate without retries. Each identifier has a shared 20-second lookup deadline, including response consumption, all selected catalogs, pacing and retry backoff. Transient network/429/5xx failures receive up to three attempts within that deadline; permanent errors fail immediately. The deadline or retry exhaustion fails the run, rather than turning an outage or incomplete source check into a not_found status. Source metadata is limited to 64 KiB per response; oversized responses fail rather than becoming misses. Already saved rows are partial if a run fails or times out; their completed-lookup charges remain. Split very large batches to stay within your run timeout.

A `not_found` row means no selected source provided a usable allowed identity. Try correcting the code or selecting its applicable catalog. Never convert a spreadsheet identifier to a number: leading zeros matter.

### Integrations

Export to Google Sheets for inventory reconciliation, or consume dataset JSON in Make, n8n and your ETL pipeline. Schedule your own supplied-code batch and compare snapshots externally; the Actor does not perform change detection or send alerts. Keep original source attribution with downstream records.

### API usage

Use your Apify token privately; do not put it in stored input.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~nonfood-barcode-isbn-catalog-lookup/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"codes":["9780140328721"]}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nonfood-barcode-isbn-catalog-lookup').call({codes:['9780140328721']});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/nonfood-barcode-isbn-catalog-lookup').call(run_input={'codes':['9780140328721']})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

### MCP setup

```bash
claude mcp add --transport http apify 'https://mcp.apify.com?tools=automation-lab/nonfood-barcode-isbn-catalog-lookup'
```

For Claude Desktop, Cursor and VS Code clients supporting remote HTTP MCP:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/nonfood-barcode-isbn-catalog-lookup"}}}
```

Discover actual names and argument schemas with scoped `tools/list`. Actor selection also exposes run/data helpers. Example prompt: “Look up ISBN 9780140328721 and show its source-attributed edition metadata.” Run only with authorization. Start once and retain its run/storage IDs; IDs are not output rows. If nonterminal, follow that same run with bounded 2/4/8-second backoff (cap 10 seconds, total deadline 120 seconds), never restart to poll. At deadline report pending with the run ID. After success fetch dataset pages of 20 rows, at most 100 rows and 64 KiB of serialized result content admitted to model context. Enforce the byte limit host-side, disclose truncation and continuation offset, and keep full exports outside model context. Clients unable to intercept oversized responses cannot guarantee that byte ceiling. Failed-run rows remain partial.

### Legality and privacy

Review each source's terms and licenses before reuse. Facts-family database records use ODbL and images have separate CC BY-SA terms; image URLs do not grant unrestricted reuse. Open Library metadata and cover rights should be checked at the source. Catalog data may be incomplete or incorrect and is not safety, legal or regulatory advice.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days. Do not include customer secrets in barcode inputs.

No AI processes lookup inputs or runtime output. Identifiers are sent only to the selected public catalog APIs. Source names are nominative references; this Actor is not affiliated with or endorsed by these catalogs. Input, dataset and logs are stored in your Apify account under its retention settings; delete run storage there when no longer needed. No cross-run cache is maintained. For support, open an Apify Actor issue or contact automation_labs_support@agentmail.to.

### FAQ

**Does it cover every UPC?** No. Coverage depends on the selected public catalogs and identity/category completeness.

**Why is my ISBN excluded?** You deselected `books`. Product catalogs never substitute for Open Library.

**Can I retrieve human-food nutrition?** Not here. Use our dedicated food lookup below.

**Are duplicates billed twice?** No. Equivalent normalized codes are processed once per run. Multiple source matches are included in the same completed-lookup event. Completed not-found checks are also charged; exclusions and incomplete/failed checks are not.

### Related Actors

For human-food catalog enrichment, use [Open Food Facts EAN UPC GTIN Lookup](https://apify.com/automation-lab/ean-upc-gtin-product-lookup). Its nutritional and ingredient fields are intentionally outside this Actor's scope.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/nonfood-barcode-isbn-catalog-lookup/changelog.md

# Actor input Schema

## `codes` (type: `array`):

Supply 1–1000 strings: EAN-8/13, UPC-A or ISBN-10/13. Completed found/not_found checks are billed once; excluded/failed checks are not. Each identifier has a 20-second deadline covering all sources, retries and pacing; exhaustion fails the run with partial prior rows. Preserve leading zeros. Spaces/hyphens are removed, checksums validated, ISBN-10 converted to ISBN-13, and normalized duplicates processed once. ISBNs use books only; other codes use selected product catalogs.

## `sources` (type: `array`):

Search these exact catalogs: beauty=Open Beauty Facts, pet=Open Pet Food Facts, household=Open Products Facts with recognized non-food category roots, books=Open Library. Default is all four. ISBNs do not search product catalogs. Codes with no applicable selected source produce excluded status. Unclassified household records are omitted; coverage is not universal.

## `maxItems` (type: `integer`):

Global run limit after identifier normalization and deduplication, in input order. Default 100; allowed 1–1000. Includes not-found and excluded rows, not individual source matches. Zero/unlimited is unsupported. All supplied codes are validated even beyond the limit. Larger batches need a longer run timeout (approximately 4 seconds per non-book code without retries).

## Actor input object example

```json
{
  "codes": [
    "9300830092116",
    "4056489928225",
    "0047871276929",
    "9780140328721"
  ],
  "sources": [
    "beauty",
    "pet",
    "household",
    "books"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with lookup statuses and source matches.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "codes": [
        "9300830092116",
        "4056489928225",
        "0047871276929",
        "9780140328721"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nonfood-barcode-isbn-catalog-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "codes": [
        "9300830092116",
        "4056489928225",
        "0047871276929",
        "9780140328721",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nonfood-barcode-isbn-catalog-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "codes": [
    "9300830092116",
    "4056489928225",
    "0047871276929",
    "9780140328721"
  ],
  "maxItems": 10
}' |
apify call automation-lab/nonfood-barcode-isbn-catalog-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/nonfood-barcode-isbn-catalog-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/K1996isTGqhTJqRwZ/builds/g16P7aXfhALmon2Bh/openapi.json