> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wisepim.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Classification (ETIM & GS1 GPC)
> Adopt ETIM classes and GS1 GPC bricks: map your families and attributes to the standards your partners use and score every product against them.
Wholesalers, marketplaces, and trading partners don't read your custom attribute names. They read **standards**: ETIM for technical products (electrical, HVAC, plumbing), and GS1 GPC for global retail categories. Classification is where you connect your catalog to those standards, so your data exports in the format your partners' systems already expect.
You'll find it under **Products → Classification** in the main menu. The section has three tabs:
* **ETIM classes**: browse the imported ETIM release and adopt classes into your project.
* **Mapping review**: review the engine's proposed links between your families/attributes and the standard.
* **GS1 GPC**: drill through the GPC hierarchy and turn bricks into categories.
ETIM class data is loaded per release by an administrator. Once a release is imported, the full catalog appears here and you can start adopting classes. WISEPIM always browses the newest fully imported release, and shows class names in your app language when the release carries it (ETIM's international file is English; national files add more languages as they are imported).
## Browse the ETIM catalog
The hub shows your current **ETIM release**, its **languages**, how many classes you've **adopted**, and any **pending mapping suggestions**. Below that, two shelves: your adopted classes, and the full release catalog.
Finding the right class is fast:
* **Your groups**: chips for the ETIM product groups your project actually works in, most-used first. Click one to filter to it.
* **Search**: find classes by name, code (like `EC000034`), or trade synonym (like "MCB"). Search spans the whole release.
* **Filters**: narrow by product group, adoption status (**Adopted** / **Not yet adopted**), and sort by code order or feature count.
Each class card shows the class name, its EC code, product group, synonyms, and how many features it defines. Adopted classes carry a green **Adopted** chip.
## Class detail: see what the standard defines
Click **View class** on any card to see everything the standard defines for it, in ETIM's own order. Each feature row shows:
* The **EF feature code** and name, with a **Required** chip on mandatory features
* The feature **type**: **A** (text/select), **N** (numeric), **L** (yes/no), or **R** (range)
* The **unit** ETIM prescribes for numeric features
* The **permitted values** for select features - expand a row to see every value with its EV code
This is worth a look before you adopt: it tells you exactly which attributes your products will need to fill.
## Adopt a class
Click **Adopt class** and WISEPIM builds a ready-to-use [product family](/en/products/product-families) from the ETIM definition. The dialog shows exactly what gets created before anything is written:
* A product family `ETIM_{CODE}` named after the class
* One attribute per ETIM feature, mapped to its feature code
* Value lists for select-type features
* The units of measurement the class prescribes
Nothing is overwritten - you can edit everything afterwards. Assign products to the family and they get the standard's attributes immediately.
Already adopted a class and a newer release arrived? Open the class and click **Re-sync family**. The family is refreshed against the imported release, and existing attributes keep their data.
Adopted families show an ETIM chip in the [product families](/en/products/product-families) list that links straight back to the class, and every materialised attribute shows a quiet `ETIM EF…` reference in the product editor. Click it to see what ETIM says about that feature: its type, prescribed unit, whether the class requires it, and its permitted values.
## Mapping review: let the engine do the matching
If you already have families and attributes, you don't have to link them to the standard by hand. On the **Mapping review** tab, click **Run mapping** and the engine compares everything you own against ETIM and proposes the matches. You just confirm them.
Every suggestion carries a tier chip that tells you how it was found, and how much scrutiny it deserves:
| Tier | What it means |
| ---------- | --------------------------------------------------------------------------------------------------- |
| **Memory** | You confirmed this same match before. Safe to accept. |
| **Exact** | The names (and units) line up exactly with the standard. Safe to accept. |
| **Fuzzy** | The names are close but not identical - worth a glance before you accept. |
| **AI** | An AI model picked this when the cheaper tiers found nothing. Read the reasoning before you accept. |
**Run mapping** runs the memory, exact, and fuzzy tiers - they finish in seconds. **Run AI mapping** sends the leftovers to the AI tier; it's slower, so save it for when the cheap tiers are exhausted.
### Reviewing a suggestion
Each card puts your family or attribute next to the proposed ETIM class or feature, with a confidence percentage and a plain-English rationale ("Matched on the name and the unit", "Matched on a listed synonym"). AI suggestions include the model's reasoning. The card also spells out what adopting does - for example, adopting a family→class match links the family to the class and creates its standard attributes on your products.
* **Adopt** confirms the match. Runner-up candidates appear as **close alternatives** with their own **Adopt this instead** button; adopting any candidate settles the whole suggestion and clears the siblings automatically.
* **Dismiss** hides a suggestion for good - the engine won't propose it again.
* **Pick a different class… / Pick a different feature…** lets you search the standard yourself when the engine's proposal is wrong but you know the right code. Your correction is learned by the memory tier, so the engine gets it right next time.
### Work through the queue in bulk
For a large backlog, use the bulk bar: **Select safe matches** ticks every suggestion the engine is at least 90% confident about - the ones that are almost always right, and then one click adopts or dismisses the whole selection.
A good rhythm: run mapping, bulk-adopt the safe matches, then hand-review the fuzzy and AI tiers. Ten minutes of review typically links most of an existing catalog to the standard.
## GS1 GPC: turn bricks into categories
The **GS1 GPC** tab is a browser for the Global Product Classification, four levels deep:
| Level | What it is | Example |
| ----------- | -------------------------------------------------------------------------------------- | ------------------------- |
| **Segment** | The broadest industry grouping - the aisle your products sit in | Food/Beverage/Tobacco |
| **Family** | A product area within a segment | Beverages |
| **Class** | A group of closely related product types | Coffee/Coffee Substitutes |
| **Brick** | The actual product type you classify against - the level your products get assigned to | Coffee – Ready to Drink |
Drill down by clicking rows, or search the whole release by name. Clicking a brick shows GS1's official definition, so you can check you have the right one before importing.
### Import into your categories
* On a **brick**, click **Add as category** to create the brick and its full parent path as [categories](/en/other-features/managing-categories) in your project.
* On any level above, **Import all** creates that node and every brick beneath it.
Nothing is written blind: a review modal first shows the exact category path that gets built, how many categories are new versus already there, and flags any bricks GS1 has deprecated. Turn off **Include everything below this node** to create just the structure without the bricks. Confirm with **Create categories**.
Because the whole path is created, imported bricks always sit in the right place in your category tree, and any channel that reads GPC recognises them as that exact product type.
### Switch release or language
Click **Release & language** in the header to move to another GPC publication or rewrite your category names in a different language. Before committing, WISEPIM shows exactly what changes: which bricks carry over, which categories get renamed (old → new), and which bricks aren't in the new release. Categories keep their identity through the switch, so every product stays attached, and nothing is ever deleted.
## ETIM conformance in the product editor
Once a product's family is linked to an ETIM class, the product editor (and Quick Edit) gains an **ETIM** tab that scores the product against the standard:
* A **conformance score** showing how many of the class's features are valid on this product
* A per-feature checklist with a plain-English reason for anything that isn't: "No value yet", "Add a unit", "Value isn't in the permitted list", "Unit isn't an ETIM unit", and so on
* A **Fix** jump on every failing row that takes you straight to that attribute
### Auto-fill with AI
When features are missing or invalid, an **Auto-fill with AI** button appears. It fills the missing features and corrects the invalid ones, then re-scores instantly - fixed rows flash green. It costs **1 credit** per run, and the button only shows when there is actually something to fix, so a conformant product never triggers a paid no-op. Anything the AI can't determine confidently is skipped and annotated, never guessed.
ETIM conformance also feeds into the product's [Data Quality](/en/analytics/data-quality) breakdown as an additional domain next to the [four standard ones](/en/settings/data-quality#domain-weights), measuring feature coverage and value validity, because buyers and technical marketplaces filter on exactly these features. It appears only for products whose family is linked to an ETIM class.
## Classification works across WISEPIM
Adopting standards pays off beyond this page:
* **Scraped imports classify themselves.** With [auto-classification](/en/essentials/web-scraping-import) enabled, imported products that match an adopted ETIM class get that class's family the moment they land, and scraped breadcrumbs file into your adopted GPC categories instead of creating a duplicate tree.
* **BMEcat exports need no mapping.** A [Feed Hub](/en/essentials/feed-hub) BMEcat feed exports your ETIM classes and their features directly - what ends up in the catalog is decided by the class each family is linked to.
* **Enrichment respects the standard.** AI enrichment and web research fill ETIM-bound attributes with the class's permitted values and prescribed units.
ETIM classification © ETIM International, licensed under ODC-By 1.0.
## Related
Adopted ETIM classes become product families with the standard's attributes.
GPC bricks import as categories in your project tree.
Export a BMEcat catalog straight from your adopted ETIM classes.
ETIM conformance scores as a quality domain across your catalog.