Building

How to Configure WooCommerce for Automotive Parts with Year-Make-Model Filtering

How to build a WooCommerce vehicle parts finder: fitment data in attributes or an indexed table, ACES and PIES feeds, a year make model selector, VIN lookup and large-catalog speed.

·13 min read
Year, make and model selector showing 2018 Ford F-150 with a green fits your vehicle confirmation

The fastest way to build a WooCommerce vehicle parts finder is to store which vehicles each product fits in an indexed table (or, for a small catalog, in product attributes), then add three dependent drop-downs for year, make and model that filter the shop to matching products. A ready-made plugin covers simple catalogs; a custom fitment table is the better route once you need engine or trim, supplier fitment feeds or tens of thousands of parts. We checked every plugin, standard and API mentioned below on 15 November 2026.

Fitment is the one thing an auto parts store cannot get wrong. A brake rotor that fits a 2018 Ford F-150 with one engine may not fit the same truck with another, and every wrong order costs you return freight plus a support ticket. This guide covers the data model, the supplier data standards (ACES and PIES), the selector, VIN lookup, speed at large catalog sizes, and the mistakes other store owners keep reporting.

How do I build a WooCommerce vehicle parts finder?

Five pieces make up a working finder, and the order matters because each one depends on the one before it.

  1. Decide which vehicle fields you need. Year, make and model cover most shops. Add engine or trim only if the same part genuinely differs across them, because every extra field multiplies your data work.
  2. Choose where fitment lives. Attributes and taxonomy terms for small catalogs, an indexed fitment table for large ones (compared in the next section).
  3. Load the data. Either type it in, import a CSV, or convert a supplier feed in the ACES format.
  4. Build the selector. Dependent drop-downs, a saved “garage”, and a URL that carries the chosen vehicle.
  5. Show the answer where buyers decide. A “fits your vehicle” message on the product page, a warning in the cart, and a fitment list when no vehicle is chosen.

Skip any piece and the store feels unfinished. A selector with no product-page confirmation leaves buyers guessing, and a fitment table with no import path means someone retypes data forever.

Where should fitment data live: attributes, taxonomy or a custom table?

For a few hundred parts, use product attributes. For thousands of parts that each fit many vehicles, use a custom table with the right indexes. Both work; the cost shows up as the catalog grows.

Barn2, which sells WooCommerce plugins, recommends storing make, model, year and engine as WooCommerce attributes and assigning each fitment year as its own term, and it adds that a plain install struggles at 20,000+ SKUs without good hosting and caching. A Meta Box support thread from December 2021 reached a similar answer for a small build: custom taxonomies on products are enough, and a separate table risks clashing with other plugins and themes.

The catch is multiplication. A part that fits 2015 to 2023 on twelve models carries over a hundred year-and-model combinations. In a term-based design that is over a hundred term relationships per product; at 20,000 products the relationship table holds millions of rows, and you are filtering it through taxonomy queries that were never tuned for fitment. A fitment table stores the same facts as plain integer pairs with a composite primary key.

Approach

Best for

Strength

Watch out for

Product attributes (terms)

Under a few thousand fitment rows

No custom code; works with WooCommerce layered navigation and most themes

Term explosion on parts that fit many years; hard to express engine-level fitment

Post meta (fields on each product)

Almost never

Quick to prototype

Filtering by meta value joins a table that is slow to filter at scale (Webkul, 3 July 2026) and cannot answer “which vehicles does this fit” cheaply

Custom fitment table

Large catalogs, supplier feeds, engine or trim fitment

Indexed integer lookups; reverse lookups in both directions; easy bulk import

You maintain schema, import code and admin screens; other plugins will not see the data

Dedicated search engine (Elasticsearch, OpenSearch)

Very large catalogs with heavy faceted search

Fast faceting beyond what MySQL does comfortably

Extra infrastructure and sync code

We have not benchmarked a cut-over point, and nobody we found has published one for fitment specifically. Seed a copy of your real catalog with realistic fitment rows and time your filter query before you commit to either design. If the filtered shop page takes over a second on staging, it will be worse under traffic.

What is a parts compatibility data feed (ACES and PIES)?

A parts compatibility data feed is a file from your supplier that says which vehicles each part fits. In the automotive aftermarket that file is almost always ACES, and the product details (descriptions, dimensions, images, packaging) come in a companion file called PIES. Both are maintained by the Auto Care Association.

ACES stands for Aftermarket Catalog Exchange Standard and covers application (fitment) data. PIES, the Product Information Exchange Standard, covers detailed information about each part. Neither file contains vehicle names as text: they use codes that point into shared reference databases. According to an industry primer from APA Engineering, those are:

  • VCdb, the Vehicle Configuration Database: makes, models and vehicle attributes.
  • PCdb, the Product Classification Database: the standard part types and hierarchy.
  • PAdb, the Product Attribute Database: standard attributes per part type.
  • Qdb, the Qualifier Database: standard wording for application notes such as “with sport suspension”.
  • Brand Tables: registered brand identifiers.

The standards moved recently. On 2 April 2026 the Auto Care Association released ACES 5.0 and PIES 8.0, with matching schema updates to VCdb 2.0, Qdb 2.0, PCdb 2.0, PAdb 5.0 and the Brand Table 2.0. ACES 5.0 adds support for vehicle- and part-specific digital assets that are not diagrams, and PIES 8.0 adds extended producer responsibility (EPR) packaging data. Some Auto Care pages still list the older ACES 4.2 and PIES 7.2 as current, so check which version your supplier actually sends before you write an importer.

Cost is the other surprise. Auto Care’s ACES page says that using ACES for your products requires an annual paid subscription to the reference databases, and points to a separate page for pricing. Ask your supplier whether they ship the reference data with the feed, and confirm current terms with Auto Care before you budget.

What to do with an ACES file in WooCommerce

Do not try to run the XML through a generic product importer. Write one importer that does three jobs: resolve each supplier part number to a WooCommerce product (the PIES part number works well as the SKU), resolve each VCdb vehicle code to a row in your vehicles table, and insert the pairs into the fitment table. Run it from WP-CLI in chunks so a timeout never leaves half a feed loaded, and keep a log of part numbers that matched no product.

Then spot-check. Pick five parts whose fitment you know cold, run the lookup and compare. Supplier fitment errors are common enough that a wrong model year in the feed will look like a bug in your code.

How do I build the fitment table and the selector?

Keep the schema small. Denormalizing make and model into the vehicles table is fine until your vehicle list runs into the hundreds of thousands, and it keeps the drop-down queries to a single index scan. The two tables below are a starting pattern; in a plugin, create them with dbDelta() on activation.

CREATE TABLE wp_ymm_vehicles (
  id         INT UNSIGNED NOT NULL AUTO_INCREMENT,
  model_year SMALLINT UNSIGNED NOT NULL,
  make       VARCHAR(60) NOT NULL,
  model      VARCHAR(80) NOT NULL,
  PRIMARY KEY (id),
  UNIQUE KEY ymm (model_year, make, model),
  KEY make_model (make, model)
);

CREATE TABLE wp_ymm_fitment (
  product_id BIGINT UNSIGNED NOT NULL,
  vehicle_id INT UNSIGNED NOT NULL,
  PRIMARY KEY (vehicle_id, product_id),
  KEY product_id (product_id)
);

The primary key on the fitment table starts with vehicle_id because the shop query asks “which products fit this vehicle”. The separate product_id index answers the reverse question for the product page.

Dependent drop-downs

Fill each drop-down from a small REST endpoint instead of printing every make and model into the page. The version below returns the makes for a chosen year. The models endpoint follows the same shape with year and make as inputs.

add_action( 'rest_api_init', function () {
	register_rest_route( 'ymm/v1', '/makes', array(
		'methods'             => 'GET',
		'permission_callback' => '__return_true',
		'args'                => array(
			'year' => array(
				'required'          => true,
				'sanitize_callback' => 'absint',
			),
		),
		'callback'            => function ( WP_REST_Request $request ) {
			global $wpdb;
			$year  = (int) $request['year'];
			$key   = 'makes_' . $year;
			$makes = wp_cache_get( $key, 'ymm' );
			if ( false === $makes ) {
				$makes = $wpdb->get_col(
					$wpdb->prepare(
						"SELECT DISTINCT make FROM {$wpdb->prefix}ymm_vehicles WHERE model_year = %d ORDER BY make",
						$year
					)
				);
				wp_cache_set( $key, $makes, 'ymm', DAY_IN_SECONDS );
			}
			return rest_ensure_response( $makes );
		},
	) );
} );

The cache lines only help across requests when the site runs a persistent object cache such as Redis or Memcached. Without one, wp_cache_set() lasts for a single request, which is harmless but pointless. Vehicle data changes rarely, so a long lifetime is fine; clear the group after each import. Our guide to custom WooCommerce REST API endpoints covers permissions and validation in more depth.

Filtering the shop to one vehicle

The mistake we see most in tutorials is fetching the matching product IDs first and passing them to post__in. With a popular vehicle that array holds thousands of IDs and the resulting query gets slower with every one. Let MySQL do the matching inside the main query instead.

add_filter( 'posts_clauses', function ( $clauses, $query ) {
	global $wpdb;

	if ( is_admin() || ! $query->is_main_query() || 'product_query' !== $query->get( 'wc_query' ) ) {
		return $clauses;
	}

	$vehicle_id = isset( $_GET['vehicle'] ) ? absint( $_GET['vehicle'] ) : 0;
	if ( ! $vehicle_id ) {
		return $clauses;
	}

	$clauses['where'] .= $wpdb->prepare(
		" AND EXISTS (
			SELECT 1 FROM {$wpdb->prefix}ymm_fitment f
			WHERE f.product_id = {$wpdb->posts}.ID AND f.vehicle_id = %d
		)",
		$vehicle_id
	);

	return $clauses;
}, 10, 2 );

This is a pattern to adapt, not a drop-in plugin: we wrote it for this refresh from the WordPress and WooCommerce query APIs and did not run it against a live store, so test it on staging with your theme and any filter plugins you use. Carrying a vehicle ID in the URL (rather than three separate names) keeps links short and makes the filtered page shareable.

What is a year make model selector, and how should it behave?

A year make model (YMM) selector is a set of linked drop-downs where each choice narrows the next, so a buyer can only pick a vehicle that exists in your data. The usual order is year, then make, then model, though some stores prefer make first because buyers know their make before their year.

  • Disable the later drop-downs until the earlier one is set. It prevents impossible combinations, which Barn2 also points to as a way to cut wrong-part orders.
  • Remember the vehicle. Save it in a cookie for visitors and in user meta for logged-in customers, and let them keep several vehicles in a “garage” on the My Account page.
  • Confirm the vehicle visibly. A line such as “Showing parts for 2018 Ford F-150” with a change link stops people shopping for the wrong truck for ten minutes.
  • Give search engines one canonical page. Filtered URLs multiply quickly. Point their canonical to the unfiltered category so thousands of vehicle combinations are not indexed as thin duplicates.

The widget is the easy half; the data behind it is the work. If you want the shortest route to a working widget, the next section looks at what already exists.

Is there a year make model search for WooCommerce?

Yes, several, though only one has a track record. We looked at what WordPress.org lists for year make model search on 15 November 2026 and report the listing numbers below. We have not installed or load-tested any of them for this refresh.

Plugin

Rating

Active installs

Last updated

Notes

Year Make Model Search for WooCommerce

5.0 from 34 reviews

1,000+

12 Nov 2026

Fixed make, model, year drop-downs; CSV import and export; vehicle list on the product page

YMM Product Filter for Woo

5.0 from 1 review

100+

20 Oct 2026

Year-make-model or make-model-year order; fitment tab; import and export; caching option for big shops

Newer listings (for example AWC Vehicle Fitment Search, YMM Hero)

No reviews

10 or fewer

Sep to Oct 2026

Too new to judge

Numbers are from the WordPress.org plugin API and listing pages, 15 November 2026. A five-star rating from one review says almost nothing, so treat the second and third rows as unproven.

What users say, and our suggestion

The best-evidenced option is Year Make Model Search for WooCommerce. Its review page shows 34 five-star reviews and none lower; the recent ones, from September 2023 to October 2025, praise how quickly the developer answers support questions and say it simply works. The listing is a small sample, so read it as “no loud complaints” rather than proof.

The support forum tells a more detailed story. Among the 30 most recent threads we saw the same problem reported at least four times (only the first make can be selected), requests to add trim and engine fields, a question about WooCommerce HPOS compatibility from roughly a year ago, and a report of the search failing to redirect on a staging site. The pattern is a good fit for a make, model and year shop and a poor fit for anyone who needs more vehicle detail than that.

Our suggestion: start with a plugin when your fitment is genuinely year, make and model and your catalog is modest, and check it on a staging copy with your real data first. Build a custom fitment table when you need engine or trim, an ACES feed, or fast filtering across tens of thousands of products. We do not sell a fitment plugin, so this advice has no commercial pull either way.

How does VIN lookup work in WooCommerce?

A VIN lookup takes a 17-character vehicle identification number, asks a decoding service what the vehicle is, and sets the selector to the matching year, make and model. In the United States the free option is the NHTSA vPIC API, which accepts a VIN and returns make, model, model year and engine details.

The vPIC API page documents a flat-format DecodeVinValues call and a batch call that takes up to 50 VINs. It also says partial VINs are accepted, the ninth digit is not required, and heavy users are subject to automated rate control without published limits. For a shop that means decoding one VIN per customer action, caching each result and handling a failed request gracefully.

function ymm_decode_vin( string $vin ) {
	$vin = strtoupper( trim( $vin ) );

	// 17 characters; I, O and Q are never used in a VIN.
	if ( ! preg_match( '/^[A-HJ-NPR-Z0-9]{17}$/', $vin ) ) {
		return new WP_Error( 'ymm_bad_vin', 'Enter a 17-character VIN (no I, O or Q).' );
	}

	$key     = 'ymm_vin_' . $vin;
	$vehicle = get_transient( $key );
	if ( false !== $vehicle ) {
		return $vehicle;
	}

	$response = wp_remote_get(
		'https://vpic.nhtsa.dot.gov/api/vehicles/DecodeVinValues/' . rawurlencode( $vin ) . '?format=json',
		array( 'timeout' => 8 )
	);
	if ( is_wp_error( $response ) || 200 !== wp_remote_retrieve_response_code( $response ) ) {
		return new WP_Error( 'ymm_vin_unavailable', 'VIN lookup is unavailable. Pick your vehicle manually.' );
	}

	$row = json_decode( wp_remote_retrieve_body( $response ), true )['Results'][0] ?? array();
	if ( empty( $row['Make'] ) || empty( $row['Model'] ) || empty( $row['ModelYear'] ) ) {
		return new WP_Error( 'ymm_vin_unknown', 'We could not identify that VIN.' );
	}

	$vehicle = array(
		'year'  => (int) $row['ModelYear'],
		'make'  => $row['Make'],
		'model' => $row['Model'],
	);
	set_transient( $key, $vehicle, 30 * DAY_IN_SECONDS );

	return $vehicle;
}

Checked on 15 November 2026: a test call to the DecodeVinValues endpoint returned a Results array with Make, Model, ModelYear, ErrorCode and ErrorText fields, which is what the code reads. Two cautions. NHTSA returns names in upper case (“FORD”) and its model names will not always match your catalog, so match case-insensitively and fall back to the manual selector when nothing matches. And the ninth-position check digit is not used by every market, so we validate the character set and length but leave the check digit result to NHTSA’s own error text rather than rejecting a VIN ourselves.

Common mistakes people report

These come from plugin support forums, store-owner threads and vendor guides, paraphrased and checked on 15 November 2026.

  • Locking in too few vehicle fields. Owners of a make, model and year plugin keep asking the developer to add trim and engine later (WordPress.org support forum). Decide on the fields before you import, because re-keying fitment is the expensive part.
  • Treating post meta as a fitment database. Filtering and sorting on meta values means multiple joins and temporary tables, and Webkul’s July 2026 write-up notes that indexes alone do not fix that architecture.
  • Re-importing the whole catalog in one run. Barn2 suggests a light daily sync for price and stock and a full sync of descriptions and attributes about once a week, so imports finish inside host time limits (Barn2 auto parts guide).
  • Caching sold-out parts as available. The same guide warns that full-page caching can show stale stock, and recommends hiding out-of-stock items so cached pages do not offer parts you cannot ship.
  • Wiring up a selector that breaks on the second search. Forum threads on the ymm-search plugin describe the finder stopping after the first search session and failing to redirect on staging, so test the full repeat-search flow, not only the first click.
  • Assuming a VIN decode is exact. The vPIC documentation accepts partial VINs and treats the ninth digit as optional, which means a “successful” decode can still return incomplete data. Confirm the result with the buyer before you filter on it.

How do I keep a vehicle parts store fast at 20,000+ products?

Keep the fitment lookup indexed, keep results out of PHP arrays, and cache what rarely changes. Those three habits do most of the work, and the rest is ordinary WooCommerce tuning.

  • Index every column you filter or join on. The composite keys in the schema above are the reason the shop query stays a few index lookups instead of a table scan. Run EXPLAIN on your real query before launch.
  • Use EXISTS or a join, never a giant IN list. Passing thousands of product IDs to post__in makes the query slower the more popular the vehicle.
  • Paginate fitment lists. A common brake part can fit hundreds of vehicle rows. Collapse the list on the product page with a “show all vehicles” control.
  • Import in chunks from the command line. Process a few thousand rows per pass, and commit between passes so a failure leaves clean data behind.
  • Cache the drop-down data. Years, makes and models change on import day, not on every visit.

For the broader work (object caching, slow-query hunting, autoload bloat) our WooCommerce performance checklist, database optimization guide and guide to scaling to 100k products go deeper than a fitment article can.

How should a parts store show fitment on product and cart pages?

Say the answer in words next to the price. When a vehicle is selected, show “Fits your 2018 Ford F-150” on a match and a plain warning, such as “Check fitment: this part lists a different engine”, on a partial one. With no vehicle selected, show a paginated fitment table.

Repeat the check in the cart. If the shopper has one vehicle selected and adds a part that fits only a different model year, show a notice but let the purchase go through, because many buyers shop for a vehicle other than the one saved in their garage. Log those mismatches; they point to bad data as often as to confused buyers.

Parts that come in brands, cores and kits

Parts sold in several brands behave well as variable products: the parent is the part (front brake rotor) and each variation is a brand and part number. Fitment is the same across the brands of one part, so attach it to the parent. Our guide to custom WooCommerce product types shows how to give parts their own product type if you need one.

Exchange parts such as alternators and starters usually carry a core charge. Add it as a cart fee on products flagged as needing a core return (WooCommerce’s woocommerce_cart_calculate_fees action is the hook), and refund that amount through a normal partial refund when the old part arrives. Kits and “bought together” suggestions are worth the effort too, as long as suggestions only include parts that fit the selected vehicle, so any ready-made plugin for this needs a fitment check before you trust it.

Oversized parts need freight rates rather than flat shipping. Store a shipping class (standard, oversize, hazmat) on each product and map it to your carrier rules, then quote oversize items with a live freight rate at checkout.

Frequently asked questions

Do I need ACES and PIES data to sell auto parts on WooCommerce?

No. A small shop can enter fitment by hand or by CSV. ACES and PIES matter when you buy from suppliers that publish them and you want fitment and product data loaded automatically instead of retyped.

Can I use WooCommerce attributes for year, make and model?

Yes, and for a small catalog it is the simplest route. It starts to strain when parts fit many years and models, because each combination becomes another term relationship. Test your own data before you decide.

Is the NHTSA VIN decoder free?

The vPIC API is a free public service for decoding VINs, with rate control and no published limits. It is built around vehicles sold in the United States, so a store selling to other markets should check coverage before relying on it.

Which is better, a plugin or a custom fitment table?

A plugin gets you live fastest when you only need year, make and model. A custom table pays off once you need engine or trim, supplier feeds or very large catalogs. Many stores start with a plugin and move to a table later, so keep your fitment data exportable from day one.

Will vehicle filters hurt my SEO?

They can, if every combination becomes an indexable page. Keep the vehicle in a query parameter, point filtered pages to the unfiltered category as their canonical URL, and build a small number of real landing pages for your best-selling vehicles instead.

Part of the Wbcom Designs family

The all-in-one WordPress community stack

Also ours: wbcomdesigns.comvapvarun.combrndle.com