How to Generate Pick-and-Place/Centroid Files from Altium Designer: A Complete Guide

If you’ve ever sent your PCB design to an assembly house only to get an email asking for “the centroid file,” you’re not alone. I’ve been designing boards for over 15 years, and this step still trips up many engineers, especially those transitioning from prototyping to production. The pick-and-place file—sometimes called a centroid file, XY data, or component placement list (CPL)—is absolutely essential for automated SMT assembly. Without it, the pick-and-place machine has no idea where to put your components.

In this guide, I’ll walk you through everything you need to know about generating these files in Altium Designer, from the basic quick method to advanced Output Job configurations that’ll save you hours on future projects.

What is a Pick-and-Place File in PCB Assembly?

A pick-and-place file (also known as a centroid file) provides the exact coordinates and orientation information that automated assembly machines need to place surface mount components onto your PCB. Think of it as GPS coordinates for every component on your board.

When the assembly machine runs, it reads this file to determine exactly where each component sits relative to a reference point (usually the board origin), which side of the board it belongs on, and how it should be rotated.

Essential Data in a Centroid File

Every proper centroid file must include specific information for the assembly machine to work correctly:

Data Field	Description	Example
Designator	Reference designator matching your schematic and silkscreen	C1, R15, U3
Mid X / Center X	Horizontal position of component center	25.400 mm
Mid Y / Center Y	Vertical position of component center	12.700 mm
Layer	Board side where component is placed	Top or Bottom
Rotation	Component orientation in degrees	0, 90, 180, 270
Footprint	Package type (optional but helpful)	0603, SOIC-8, QFP-48
Comment/Value	Component value (optional)	10uF, 10K, LM7805

The coordinates are typically measured in millimeters or mils from the board origin, and rotation values follow counter-clockwise convention with pin 1 as the reference.

Why Your Assembly House Needs This File

When I first started getting boards professionally assembled, I made the mistake of thinking Gerbers alone were enough. They’re not. Here’s what happens behind the scenes at an assembly facility:

The pick-and-place machine uses your centroid data to program its placement head movements. Without accurate XY coordinates, the machine operator would need to manually measure and input every single component location—a process that’s time-consuming, expensive, and error-prone for complex boards with hundreds of components.

Most assembly houses can generate centroid data from your Gerber files, but they’ll charge you for this service (typically $50-$150), and there’s always risk of misinterpretation. Providing your own accurate centroid file eliminates these problems entirely.

Quick Method: Generating Pick-and-Place Files Directly from Altium

This is the fastest approach when you just need to generate the file once and get your design out the door. It takes about 30 seconds.

Step-by-Step Process for Direct Generation

First, open your PCB document (.PcbDoc) in Altium Designer. Make sure you’ve compiled your project recently so everything is synchronized between your schematic and layout.

Navigate to File → Assembly Outputs → Generates pick and place files. This opens the Pick and Place Setup dialog where you’ll configure your output settings.

In the dialog, you’ll see a preview grid showing all components that will be included in the output. The columns displayed correspond to the data fields that will appear in your generated file.

Configuring Output Settings

Under the settings area, you’ll need to make a few decisions:

Format Selection: Choose between CSV and/or Text output. I recommend CSV since it opens cleanly in Excel and most assembly houses prefer it. You can select both if your manufacturer has specific requirements.

Units: Select either Imperial (mils/inches) or Metric (millimeters). Metric is generally safer since it’s the international standard, but check with your assembly house. Most can handle either.

Column Selection: Use the “All Columns” list to enable or disable specific parameters. At minimum, you need Designator, Center X, Center Y, Layer, and Rotation. Additional fields like Comment and Footprint can help the assembly house but aren’t strictly required.

Click OK, and Altium generates your file in the project folder under Generated\Text Documents.

Professional Method: Using Output Job Files for Pick-and-Place Generation

If you’re doing this more than once—and trust me, you will—setting up an Output Job file (.OutJob) saves enormous time on future projects. This approach also lets you generate all your manufacturing outputs (Gerbers, drill files, BOMs, pick-and-place) in one click.

Creating an Output Job Configuration File

Right-click your project in the Projects panel and select Add New to Project → Output Job File. A new OutJob document opens with various output categories.

In the Assembly Outputs section, click Add New Assembly Output and select Generates pick and place files → [Your PCB Document]. This links the pick-and-place generator to your specific PCB file.

Double-click the newly added entry to open the Pick and Place Setup dialog. Configure your settings as described above.

Mapping Outputs to Containers

On the right side of the OutJob editor, you’ll see Output Containers. These determine where your generated files end up. You can output to a folder structure, PDF, or even directly to your company’s version control system.

For most workflows, select Folder Structure and click the radio button next to your pick-and-place output in the Enabled column. This maps the output to the designated folder.

To generate all outputs, click the Generate Content button near your selected container. Altium produces all configured outputs and places them in your project’s output directory.

Output Job File Benefits for Production Workflows

Feature	Direct Generation	Output Job Method
Setup time	None	5-10 minutes initially
Repeat generation	Reconfigure each time	One click
Multiple outputs	Generate separately	All at once
Settings persistence	Stored in project	Stored in OutJob file
Version control	Manual tracking	OutJob file versioned
Team consistency	Varies by engineer	Standardized

Understanding How Altium Calculates Component Centers

This is where things get interesting—and where many engineers encounter unexpected results. Altium doesn’t simply use the footprint’s geometric center for pick-and-place coordinates.

The Centroid Calculation Method

Altium calculates the component center by finding the midpoint between the two outermost pads in a footprint. It does not consider mechanical layers, copper pours, or the visual outline—only pad primitives.

This means for symmetric footprints like 0603 resistors or SOIC packages, you’ll get expected results. But for asymmetric footprints—connectors with mounting pins, or custom packages with unusual pad arrangements—the calculated center might appear offset from where you’d visually expect it.

Coordinate Reference Points Available in Altium

Altium provides three different coordinate reference methods for pick-and-place data:

Reference Type	Description	Best Use Case
Center X/Y	Calculated center between outermost pads	Standard SMT components
Ref X/Y	Footprint reference point as defined in library	Custom footprints
Pad-1 X/Y	Location of pad number 1	When pin 1 position matters more than center

You can include all three in your output by enabling the respective columns. This gives your assembly house options if their machine programming requires a specific reference method.

Dealing with Origin and Coordinate Systems

The pick-and-place file calculates coordinates from the absolute minimum of your PCB design sheet (lower left corner). If you’ve set a custom origin using Edit → Origin → Set, the coordinates reflect the offset from that point.

For best results, place your origin at the lower-left corner of your board outline. This makes coordinates intuitive and reduces confusion when operators review the data.

Customizing Your Pick-and-Place Output for Different Manufacturers

Different assembly houses have different requirements. Some want specific column orders, particular headers, or custom formatting. Altium gives you considerable flexibility here.

Filtering Components from Output

Not everything on your board needs to appear in the pick-and-place file. Fiducials, mounting holes, and mechanical components typically shouldn’t be included since the pick-and-place machine won’t be placing them.

In the Pick and Place Setup dialog, click the filter icon in any column header. This opens a dropdown where you can exclude specific values. For example, filter the Footprint column to exclude “Fiducial” or filter Comments to exclude “MountingHole.”

Enable the Exclude Filter Parameters checkbox to remove the filtered columns from the output entirely, keeping your file clean.

Working with Design Variants

If your project uses variants (different component populations for different product configurations), enable Include Variation Components in the setup dialog. This includes components marked as “Not Fitted” in your variants, which can be useful for documenting all possible assembly configurations.

Bottom-Side Component Handling

For boards with components on both sides, check the Y-Flip Bottom Side Components option. This mirrors the Y-axis coordinates for bottom-side components, which some assembly machines require for proper placement when the board is flipped.

Pick-and-Place File Format Specifications

Understanding the actual file format helps when troubleshooting issues or when you need to manually edit the data.

Standard CSV Format Structure

A typical Altium-generated pick-and-place CSV looks like this:

Designator,Mid X,Mid Y,Layer,Rotation,Comment,FootprintC1,25.4mm,12.7mm,TopLayer,0,10uF,0805C2,30.0mm,12.7mm,TopLayer,0,100nF,0603R1,25.4mm,20.0mm,TopLayer,90,10K,0402U1,50.0mm,50.0mm,TopLayer,0,STM32F103,LQFP-48

The header row identifies each column, and subsequent rows contain component data. Coordinates include units when the “Show Units” option is enabled.

Common Format Requirements by Manufacturer

Manufacturer	Preferred Format	Special Requirements
JLCPCB	CSV with LCSC part numbers	Specific column headers required
PCBWay	CSV, TXT, or Excel	Metric units preferred
Seeed Studio	CSV	Standard format accepted
MacroFab	CSV	Requires MPN column
Advanced Assembly	CSV or Excel	Accepts standard Altium output

Always check your specific manufacturer’s documentation, as requirements can change.

Integrating JLCPCB Part Numbers into Your Pick-and-Place File

If you’re using JLCPCB’s assembly service—and many engineers do because of their competitive pricing—you’ll need to include their LCSC part numbers in your output files.

Adding LCSC Part Numbers to Component Libraries

Open your schematic library (.SchLib) containing the component you want to update. Select the component and double-click to open its properties.

In the Parameters section, click Add to create a new parameter. Name it LCSC Part # (this exact naming matters) and enter the part number value from JLCPCB’s parts database.

Save your library and update your schematic to pull in the new parameter. When you generate pick-and-place files, include the “LCSC Part #” column for a file that’s ready for JLCPCB upload.

Where to Find LCSC Part Numbers

JLCPCB maintains a parts library with over 30,000 components available for assembly. You can access this through their website or download the complete parts database spreadsheet for offline searching.

Troubleshooting Common Pick-and-Place File Issues

After generating hundreds of these files, I’ve encountered most of the problems that can occur. Here are the most common issues and their solutions.

Components Missing from Output

If components aren’t appearing in your pick-and-place file, check these common causes:

The component might not have pads. Altium only includes components with pad primitives in the pick-and-place calculation. Components using only mechanical primitives won’t generate coordinate data.

Filters might be excluding components. Review any active filters in the Pick and Place Setup dialog and ensure they’re not inadvertently hiding valid components.

The component might be marked as “No BOM” or “Standard” item. Check component properties and enable Include Standard (No BOM) Items if needed.

Incorrect Rotation Values

Rotation discrepancies between your centroid file and actual assembly usually trace back to footprint library definitions. The rotation value depends on how pin 1 was oriented when the footprint was created.

Check your footprint library and ensure pin 1 is positioned according to standard conventions: top-left for ICs and QFPs, cathode marking position for diodes, positive terminal for polarized capacitors.

Coordinate Offset Problems

If your coordinates seem shifted from expected positions, verify your board origin setting. Go to Edit → Origin → Reset to return to the default (lower-left sheet corner), or set a specific origin at your board’s lower-left corner.

Best Practices for Production-Ready Pick-and-Place Files

Drawing from years of sending boards to assembly, here are practices that prevent problems:

Always verify coordinates visually. Open your generated file in Excel and spot-check several components against their positions in the PCB layout. A quick sanity check catches most errors before they cause expensive assembly mistakes.

Include footprint information. Even if not strictly required, footprint data helps assembly operators verify they’re placing the right component types.

Use metric units. While imperial works, metric is the international standard and eliminates conversion errors.

Generate fresh files before each production order. Don’t reuse old files if you’ve made any design changes, even seemingly minor ones like component repositioning.

Document your coordinate reference. Include a note specifying whether coordinates reference component centers, pin 1, or pad centers. This prevents ambiguity during machine programming.

Useful Resources for PCB Assembly Files

Here are resources I regularly use when preparing assembly documentation:

Official Documentation and Tools

Altium’s official documentation for pick-and-place setup provides version-specific details: https://www.altium.com/documentation/altium-designer/preparing-manufacturing-data-with-output-jobs

Parts Databases and Component Libraries

The JLCPCB parts database contains component information for their assembly service: https://jlcpcb.com/parts

Assembly File Format References

PCBWay’s assembly file requirements documentation: https://www.pcbway.com/assembly-file-requirements.html

Bittele Electronics’ centroid file guide: https://www.7pcb.com/blog/procedure-creating-centroid-file

Frequently Asked Questions

What is the difference between a centroid file and a pick-and-place file?

These terms are interchangeable in the PCB industry. Both refer to the same file containing component XY coordinates, rotation, and layer information for automated assembly. Other synonymous terms include XY data file, component placement list (CPL), and insertion file. The terminology varies by region and manufacturer, but the content and purpose are identical.

Can Altium generate separate pick-and-place files for top and bottom layers?

Yes, though not as a direct option in the setup dialog. The standard output includes a “Layer” column identifying each component’s side. If your assembly house requires separate files, you can either filter the output in Excel or create two Output Job configurations with layer-specific filters applied.

What units should I use for pick-and-place coordinates—metric or imperial?

Metric (millimeters) is generally preferred and considered the international standard for PCB manufacturing. Most modern assembly equipment works natively in metric, and using millimeters reduces potential conversion errors. However, some US-based assembly houses still prefer imperial units (mils or inches), so confirm with your manufacturer.

How do I include part numbers in my Altium pick-and-place file for JLCPCB?

Add a parameter called “LCSC Part #” to each component in your schematic library. Enter the corresponding part number from JLCPCB’s parts database. When generating pick-and-place files, enable the “LCSC Part #” column in the output settings. The generated file will then include part numbers that JLCPCB’s system can automatically match to their inventory.

Why are some components showing incorrect center coordinates?

Altium calculates component centers by finding the midpoint between outermost pads. For asymmetric footprints, this calculated center may not align with the visual center. To resolve this, you can modify the footprint reference point in your PCB library, or provide your assembly house with both Center X/Y and Ref X/Y data so they can choose the appropriate reference.

Final Thoughts on Pick-and-Place File Generation

Generating accurate pick-and-place files from Altium Designer is straightforward once you understand the process. The key is choosing between the quick direct method for one-off prototypes and the Output Job approach for production workflows where you’ll be regenerating files multiple times.

Take a few minutes to set up your Output Job file correctly, include the parameters your assembly house needs, and always do a quick visual verification before submitting. These small investments in preparation pay off significantly in reduced assembly issues and faster turnaround times.

The difference between a smooth assembly run and a frustrating back-and-forth with your manufacturer often comes down to the quality of your manufacturing documentation—and the pick-and-place file is a critical piece of that puzzle.