# Supplier Catalog Converter for Odoo & Shopify (`nezucloud/nezu-catalog-converter`) Actor

Convert supplier CSV and Excel files into structured product catalogs for Odoo 16 and Shopify. Preserve SKUs and prices, detect duplicate products, flag missing information, and download CSV, Excel, and validation reports. No coding required.

- **URL**: https://apify.com/nezucloud/nezu-catalog-converter.md
- **Developed by:** [NEZU SAS](https://apify.com/nezucloud) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1,500.00 / 1,000 catalog converteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## NEZU Catalog Converter

**Convert supplier CSV and Excel catalogs into structured, review-ready import files for Odoo 16 and Shopify.**

Save time preparing product catalogs, checking prices, identifying duplicates, and organizing supplier information.

No coding or AI processing required.

Developed by **NEZU SAS**.

### Why use NEZU Catalog Converter?

- **Save hours of manual work.** Convert supplier spreadsheets into structured product import files.
- **Odoo 16 and Shopify support.** Generate files for either platform or both in a single conversion.
- **No invented prices.** Missing, negative, or ambiguous sale prices are flagged for review.
- **Safe Shopify imports.** Products are exported as drafts, not automatically published.
- **Built-in validation.** Identify missing SKUs, duplicate products, invalid prices, and skipped rows.
- **English and Spanish headers.** Recognizes common columns such as `Name`, `Nombre`, `SKU`, `Código`, `Price`, `Precio de venta`, and `Costo`.
- **Pay per completed conversion.** One conversion event covers the selected output formats.

### How to use it

#### Step 1 — Upload your catalog

Open the Actor and select the **Input** tab.

Under **Catalog file (CSV or XLSX)**, click **Upload new file** and choose your supplier catalog.

Alternatively, paste an accessible HTTPS download URL.

Supported formats:

- `.csv` — CSV files with common delimiters
- `.xlsx` — Excel workbooks (first worksheet only)

Your catalog must contain a header row and at least one product name column, such as `Name`, `Nombre`, `Producto`, or `Title`.

#### Step 2 — Authorize private Apify storage

**Important for version 0.2.6**

If your uploaded file is stored in a private Apify Key-value store, you must authorize read-only access before starting the conversion.

1. Find the storage ID in your uploaded file's URL. It appears between `/key-value-stores/` and `/records/`.
2. Under **Catalog storage (read only)**, select the storage containing your uploaded file.
3. Make sure the selected storage ID matches the ID in the file URL.

**If your storage does not appear in the selector:**

1. Open **Storage → Key-value stores** in Apify Console.
2. Enable **Include unnamed storages**.
3. Locate the storage using its ID.
4. Open it and assign a recognizable name.
5. Return to the Actor's Input tab and select the newly named storage.

For publicly accessible or appropriately signed HTTPS download URLs, the storage selection is generally unnecessary.

The Actor requests **read-only access** to the selected storage. It does not require full permissions to your Apify account.

#### Step 3 — Select the output format

Under **Output format**, choose:

- **Both (Odoo + Shopify)** — Generate files for both systems.
- **Odoo 16** — Generate Odoo import files.
- **Shopify** — Generate Shopify import files.

#### Step 4 — Start the conversion

Click **Start**.

Small catalogs typically process within a few seconds. Processing time depends on file size and format.

#### Step 5 — Download your results

Open the **Output** tab after the run finishes.

Download the generated import files and validation reports.

We recommend reviewing `validation_report.json` and, when available, `pending_products.csv` before importing data into a production store.

### Files you receive

| File | Availability | Description |
|---|---|---|
| `odoo_catalog.csv` | Odoo or Both | Product import file for Odoo 16 |
| `odoo_catalog.xlsx` | Odoo or Both | Excel version of the Odoo import file |
| `shopify_catalog.csv` | Shopify or Both | Shopify product import file, with products set as drafts |
| `pending_products.csv` | When applicable | Products requiring correction before import |
| `normalized_products.json` | Always | Normalized product data for review |
| `validation_report.json` | Always | Processing statistics, recognized columns, and warnings |
| `summary.json` | Always | Conversion summary and generated file names |

For completed conversions, a short summary record is also written to the run's Dataset.

### How the converter works

#### Automatic column recognition

The converter recognizes common English and Spanish column names.

| Information | Example headers |
|---|---|
| Product name | Name, Nombre, Producto, Title |
| SKU | SKU, Código, Reference |
| Sale price | Price, Precio, Precio de venta |
| Cost | Cost, Costo |
| Category | Category, Categoría |
| Vendor | Vendor, Supplier, Proveedor |
| Description | Description, Descripción |

#### Price validation

Supported price formats include:

- `1234.56`
- `1,234.56`
- `1.234,56`
- `12,50`
- Values containing `$`, `€`, `USD`, or `EUR`

Ambiguous, negative, or invalid sale prices are not automatically corrected or invented.

Products without a usable sale price are excluded from the importable product files and listed for review.

**No currency conversion is performed.** Review your destination store's currency before importing.

#### Duplicate detection

The converter identifies repeated products inside the uploaded catalog.

Products are matched using their SKU or, when no SKU exists, their name and vendor.

The first matching product is retained.

#### Product identifiers

For Odoo, the converter generates deterministic External IDs using product information.

For Shopify, it generates URL handles and a default product variant.

Repeated imports should be reviewed carefully, especially when product names, SKUs, or supplier information have changed.

#### Spreadsheet safety

Text beginning with spreadsheet formula characters is escaped to reduce the risk of formula execution when opening exported files.

### Pricing

#### $1.50 per completed conversion

Billing uses Apify's **Pay per event** model.

The configured event is:

`catalog-converted`

**One successful conversion generates one conversion event**, whether you select Odoo, Shopify, or Both.

A conversion is considered billable when at least one importable product is generated.

If no products have valid sale prices, the converter is designed not to trigger a conversion event. Reports and pending-product information can still be generated.

Errors occurring before the conversion charge do not trigger that event. Any other applicable platform fees depend on Apify's published pricing and your account plan.

You can review recorded events and charges in the run details and Apify billing information.

**Maximum cost per run:** Set your event budget to at least $1.50 to allow one completed conversion. A lower limit may prevent the conversion from being finalized.

### Technical limits

| Parameter | Limit |
|---|---|
| Maximum input file size | 3 MB |
| Maximum product rows | 1,000 |
| Excel worksheets processed | First sheet only |
| Maximum Excel columns | 60 |
| File types | CSV, XLSX |
| Maximum remote download time | 40 seconds |
| Supported output systems | Odoo 16, Shopify |

The following features are not included in this version:

- PDF or image extraction
- OCR
- AI-based product enrichment
- Automatic currency conversion
- Multiple Excel worksheet processing
- Advanced product variants
- Automatic category matching
- Direct synchronization with Odoo or Shopify

Larger catalogs must be divided into smaller files. Each completed conversion is billed separately.

### Important import notes

#### Odoo 16

Generated fields include:

- External ID
- Name
- Internal Reference
- Sales Price
- Cost
- Product Category

Product categories should already exist in your Odoo database when importing the corresponding category field.

Stable External IDs can support updates to existing products when the import is configured correctly.

Test the import using a development or backup database before applying changes to production.

#### Shopify

Generated fields include product title, URL handle, description, vendor, type, SKU, default variant, price, cost, publication status, and other supported import values.

**Products are exported with:**

- `Status = draft`
- `Published on online store = false`

The converter does not publish products or directly modify your Shopify store.

Product `Type` uses the source category text; official Shopify taxonomy categories are not automatically assigned.

Always inspect the import preview and test with a development store before importing into a live store.

### Privacy and data handling

NEZU Catalog Converter processes supplier files within the Apify platform.

The Actor does not require external AI services or direct access to your Odoo or Shopify accounts.

- Uploaded files are handled through Apify storage.
- Generated files are saved to the run's Key-value store.
- Completed runs may include a short Dataset summary containing processing counts and generated file names.
- The summary does not need to contain individual product names, SKUs, or prices.
- Files and run records are subject to Apify's applicable storage and retention policies.

Users are responsible for ensuring they have permission to process their supplier catalogs.

Avoid sharing confidential catalogs through publicly accessible URLs. Signed download links should also be treated as sensitive.

### Frequently asked questions

#### Can I upload Excel files?

Yes. CSV and XLSX files are supported. For Excel, only the first worksheet is processed.

#### Why do I need to select Catalog storage?

When an uploaded file belongs to a private Apify Key-value store, the Actor needs explicit permission to read it.

Select the storage containing your uploaded file under **Catalog storage (read only)**.

This protects your other Apify resources from unnecessary access.

#### Why does my file download return HTTP 403?

HTTP 403 usually means access to the source file was denied.

Check that the selected Key-value store matches the storage ID contained in your file URL and that the Actor has read permission.

#### Why is a product missing from the output?

The product may contain an invalid or missing sale price, or it may have been identified as a duplicate.

Review `pending_products.csv` and `validation_report.json`.

#### Why are Shopify products created as drafts?

To prevent accidental publication before you verify prices, descriptions, and other product information.

#### Does this Actor modify my Odoo or Shopify account?

No. It generates import files only. You decide when and where to import them.

#### Can it convert currencies?

No. Values are normalized for import, but currency exchange rates are not applied.

#### Can I process more than 1,000 products?

Yes, by splitting the catalog into multiple files of up to 1,000 product rows each.

Each completed conversion is billed separately.

#### What happens if no products have valid prices?

No importable products are produced. The Actor is designed not to trigger the `catalog-converted` event in this situation.

Review the pending products and validation report, correct the source file, and run it again.

#### Why are missing SKUs reported?

Missing SKUs reduce the reliability of identifying existing products during future imports.

Providing unique and consistent SKUs is strongly recommended.

#### How can I report a problem?

Open an issue from the Actor's Apify Store page and include the relevant run link and a description of the problem.

Do not post confidential catalog data, access tokens, or private download links in public issues.

***

**Developed by NEZU SAS — Ecuador**

*Soluciones que integran y protegen.*

Supplier catalog conversion for more efficient product data management.

# Actor input Schema

## `catalog_file` (type: `string`):

Upload the file or provide a public HTTPS URL. If it is saved in a restricted Apify Key-value store, also select that SAME store in the field below.

## `catalog_store` (type: `string`):

For files uploaded into a restricted Apify Key-value store: select that exact store so the Actor has READ permission. Not needed for public or signed HTTPS URLs.

## `target` (type: `string`):

Which system should receive the generated catalog?

## Actor input object example

```json
{
  "target": "both"
}
```

# Actor output Schema

## `odooCsv` (type: `string`):

No description

## `odooXlsx` (type: `string`):

No description

## `shopifyCsv` (type: `string`):

No description

## `pendingProducts` (type: `string`):

No description

## `normalizedJson` (type: `string`):

No description

## `validationReport` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nezucloud/nezu-catalog-converter").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nezucloud/nezu-catalog-converter").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 '{}' |
apify call nezucloud/nezu-catalog-converter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nezucloud/nezu-catalog-converter"
        }
    }
}
```

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/S5Xe3VKEXLkVdZ45P/builds/qKZBreORVFukbw9TF/openapi.json