How to Generate Pick-and-Place Files from Eagle: Complete Guide for PCB Assembly

If you’ve been using Autodesk Eagle for your PCB designs and just received a request from your assembly house for a “centroid file” or “pick-and-place file,” you’re probably wondering where that option is hiding. Unlike some other EDA tools, Eagle doesn’t have a big obvious button for this. The functionality exists, but it’s tucked away in User Language Programs (ULPs) and export menus that aren’t immediately intuitive.

I’ve been using Eagle since the CadSoft days, and I still remember the first time an assembly house asked me for pick-and-place data. It took some digging to figure out the workflow. This guide covers everything you need to know about generating these files from Eagle—from the built-in Mount SMD export to custom ULPs that format output specifically for services like JLCPCB and PCBWay.

What is a Pick-and-Place File and Why Does Eagle Handle It Differently?

A pick-and-place file (also called a centroid file, XY data, or component placement list) provides the exact coordinates and rotation angles that automated assembly machines need to place surface mount components on your PCB. Every SMT assembly line depends on this data to program their placement equipment.

Eagle’s approach to generating these files differs from tools like Altium or KiCad. Rather than having a dedicated “Generate Pick and Place” command in the main menu, Eagle relies primarily on ULPs—small scripts that extract data from your design and format it for various purposes. This architecture gives Eagle enormous flexibility, but it also means you need to know which ULP to run for which purpose.

Essential Data in a Pick-and-Place File

Every proper centroid file needs these core data fields for the assembly machine:

Data Field	Description	Example
Reference Designator	Component identifier matching schematic	C1, R15, U3
X Position	Horizontal coordinate from origin	25.400
Y Position	Vertical coordinate from origin	12.700
Rotation	Component angle in degrees	0, 90, 180, 270
Layer/Side	Which board surface	Top or Bottom
Package	Footprint name (optional but helpful)	0805, SOIC-8
Value	Component value (optional)	10uF, 4.7K

The coordinates are typically measured in mils (thousandths of an inch) or millimeters from the board origin. Rotation follows counter-clockwise convention, though this varies between manufacturers.

Method 1: Using the Built-In Mount SMD Export

Eagle includes a built-in export function specifically for SMD placement data. This is the simplest method and works in all recent versions of Eagle.

Step-by-Step Mount SMD Export Process

Open your board layout file (.brd) in Eagle’s Board Editor. This is critical—the export only works from the board view, not the schematic.

Navigate to File → Export → Mount SMD from the menu bar. Eagle will prompt you twice to save files: first for the top side components, then for the bottom side components.

Save the first file with a descriptive name like projectname_top.mnt. When prompted again, save the second file as projectname_bot.mnb. The .mnt extension indicates “mount top” and .mnb indicates “mount bottom.”

Understanding the Mount SMD Output Format

The files Eagle generates are text files with semicolon-separated values. Opening one in a text editor shows data like this:

C1       15.24   7.62  180  0805C2       20.32   7.62    0  0805R1       10.16  12.70   90  0402U1       30.48  25.40    0  TQFP44

The columns are: Reference Designator, X Position (mils), Y Position (mils), Rotation (degrees), and Package name. Notice there’s no header row and no explicit layer column—the layer is implied by which file you’re looking at.

Reformatting Mount SMD Output for Assembly Houses

Most assembly services won’t accept Eagle’s raw Mount SMD output directly. You’ll need to reformat it. Here’s the typical process:

Open the .mnt file in Excel or Google Sheets. Use “Text to Columns” or “Split text to columns” to separate the data using spaces as delimiters. You may need to clean up extra whitespace first—in Google Sheets, select your data and go to Data → Trim whitespace.

Add a header row with proper column names: Designator, Mid X, Mid Y, Rotation, Package. Insert a “Layer” column and fill it with “Top” for all rows (or “Bottom” if you’re working with the .mnb file).

Export as CSV and you’ll have a file that most assembly houses can accept.

Method 2: Using the mountsmd.ulp User Language Program

Eagle’s ULP system provides more flexible output than the built-in export. The mountsmd.ulp script has been a standard tool for years and comes included with Eagle installations.

Running mountsmd.ulp

Open your board layout in the Board Editor. Click the ULP button in the toolbar (it looks like a running person icon) or go to File → Run ULP.

Navigate to find mountsmd.ulp. In newer Eagle versions, it’s typically located in your Eagle installation’s ulp folder. On Windows, this might be something like C:\EAGLE 9.6.2\ulp\mountsmd.ulp.

Select the file and click Open. The script runs immediately and prompts you to save output files—one for top side SMD components and one for bottom side.

mountsmd.ulp Output Characteristics

The output from mountsmd.ulp is similar to the built-in Mount SMD export but formatted slightly differently. The script focuses exclusively on surface mount components, ignoring through-hole parts.

The generated files use the .mnt and .mnb extensions and contain semicolon-separated data with component name, X coordinate, Y coordinate, rotation angle, and package information.

Method 3: Using Screaming Circuits Centroid ULP

Screaming Circuits, a well-known assembly house, created their own ULP specifically formatted for their requirements. This ULP has become widely used because it produces clean, well-organized output that many assembly services accept.

Installing and Running the Screaming Circuits ULP

Download centroid-screamingcircuits-smd.ulp from GitHub or the Screaming Circuits website. Place it in your Eagle ulp folder—typically Documents/EAGLE/ulps/ on Windows or ~/EAGLE/ulps/ on Mac and Linux.

Open your board layout and run the ULP via File → Run ULP or the ULP toolbar button. Select centroid-screamingcircuits-smd.ulp from your ulps folder.

The script generates a single CSV file with all SMD components, including a layer column that indicates whether each part is on the top or bottom side. This combined format is often more convenient than separate files.

Output Format Comparison

Here’s how the Screaming Circuits ULP output compares to the standard Mount SMD:

Feature	Mount SMD Export	Screaming Circuits ULP
File format	Semicolon-separated text	CSV
Header row	No	Yes
Layer column	Implied by filename	Explicit column
Output files	Separate top/bottom	Single combined file
Through-hole	Not included	Not included
Units	Mils	Inches

Method 4: JLCPCB Assembly ULP for Automated Export

If you’re using JLCPCB’s assembly service—and many hobbyists and professionals do because of their pricing—there’s a dedicated ULP that generates files in exactly the format JLCPCB expects. This eliminates the reformatting step entirely.

Installing the JLCPCB Eagle ULP

Download the jlcpcb-eagle package from GitHub (search for “jlcpcb-eagle” or visit the oxullo repository). Extract the archive and copy jlcpcb_smta_exporter.ulp to your Eagle ulps folder.

The file location depends on your operating system. On Windows, copy to Users\YourUsername\Documents\EAGLE\ulps\. On Mac and Linux, copy to /home/YourUsername/EAGLE/ulps/.

Running the JLCPCB ULP

Open your board layout in the Board Editor. Run the ULP via File → Run ULP and select jlcpcb_smta_exporter.ulp.

A dialog appears asking which layer to process—select Top or Bottom depending on which side you’re assembling. Then choose an output folder (I recommend creating a dedicated “smt-files” folder within your project directory).

The ULP generates two files: a BOM file (projectname_top_bom.csv) and a CPL/centroid file (projectname_top_cpl.csv). These are formatted exactly as JLCPCB expects, so you can upload them directly without modification.

Adding LCSC Part Numbers to Your Design

The JLCPCB ULP can automatically include LCSC part numbers if you’ve added them to your components. In your schematic, add an attribute named “LCSC_PART” to each component and enter the LCSC part code (like C25804).

When you run the ULP, it extracts these attributes and includes them in the BOM output. This dramatically speeds up the ordering process on JLCPCB’s website since their system can automatically match components.

Understanding Eagle’s Coordinate System and Origin

Getting coordinates right is essential for proper component placement. Eagle uses the board origin as the reference point for all coordinate data.

How Eagle Calculates Component Positions

Eagle measures coordinates from the lower-left corner of your board outline by default. The X-axis increases to the right, and the Y-axis increases upward. All component positions reference the center of each footprint.

If your board outline doesn’t start at the origin, your coordinates will include an offset. This isn’t necessarily a problem, but it can make verification more difficult.

Setting a Custom Origin

If you need to reference coordinates from a specific point (like a tooling hole or board corner), you can set a custom origin in Eagle. Go to Options → Set Origin or use the MARK command to place a reference point.

Some ULPs respect custom origins while others always use the absolute sheet origin. Test your specific workflow to ensure coordinates align with your expectations.

Handling Through-Hole Components

Most pick-and-place files focus on SMD components because automated placement machines primarily handle surface mount parts. Through-hole components are typically hand-soldered or placed by separate insertion equipment.

When to Include Through-Hole Parts

Some assembly houses offer through-hole insertion services and need coordinate data for those components too. Eagle’s mount.ulp (as opposed to mountsmd.ulp) includes through-hole components in its output.

If your assembly house requests through-hole placement data, run mount.ulp instead of mountsmd.ulp. Alternatively, some custom ULPs can generate combined files with both SMD and through-hole parts labeled appropriately.

Excluding Components from Output

Components disabled in your schematic are automatically excluded from pick-and-place output. If you need to exclude specific parts (like test points or fiducials that the assembler shouldn’t place), disable them in the schematic before generating the placement file.

Dealing with Rotation Issues

Rotation discrepancies are the most common problem when using pick-and-place files from any EDA tool, including Eagle. A component that looks correct in your layout might show up rotated 90 or 180 degrees in the assembly preview.

Why Rotation Problems Occur

Different library creators define component orientations differently. A 0-degree rotation in one library might place pin 1 at a different position than another library. Additionally, assembly houses and component manufacturers may use different reference orientations.

Eagle reports rotation based on how the component was placed relative to its library definition. If the library defines pin 1 at the top-left at 0 degrees, but the manufacturer orients the part differently in the tape reel, you’ll get a mismatch.

Correcting Rotation in Your Pick-and-Place File

The most straightforward fix is editing your exported CSV file. Open it in Excel, find the components with incorrect rotation, and adjust their rotation values. JLCPCB’s preview shows you exactly how each component will be placed, so you can verify and correct before ordering.

If you consistently have rotation issues with specific footprints, you can modify the library definition to change the package’s default orientation. This fixes the problem at the source for future designs.

Common Eagle Rotation Corrections

Based on typical library definitions and assembly house expectations:

Component Type	Common Issue	Typical Fix
SOT-23 transistors	180° rotated	Add/subtract 180°
Chip LEDs	Polarity reversed	Add/subtract 180°
Tantalum capacitors	Polarity reversed	Add/subtract 180°
QFN packages	90° rotated	Add/subtract 90°
USB connectors	Various	Check preview carefully

Best Practices for Eagle Pick-and-Place Generation

After generating dozens of these files over the years, here are practices that prevent problems:

Always generate from a finalized design. Any changes to component positions after generating the pick-and-place file will create mismatches. Regenerate the file after every layout change.

Verify coordinates against your layout. Spot-check several components by measuring their positions in Eagle and comparing to the exported file. Catching a coordinate system mismatch early saves expensive rework.

Keep units consistent. If your Gerbers are in millimeters, your pick-and-place file should be too. Unit mismatches cause components to be placed at wildly wrong positions.

Include package information. Even if not strictly required, package data helps the assembly house verify they’re placing the right physical component.

Use your assembly house’s preview. JLCPCB, PCBWay, and others show rendered previews of component placement. Take time to examine every component—especially polarized parts and ICs.

Useful Resources for Eagle Pick-and-Place Files

Here are tools and references that help with Eagle pick-and-place workflows:

Official Autodesk Eagle Resources Autodesk Eagle Support Documentation: https://www.autodesk.com/products/eagle/

ULP Downloads and Scripts JLCPCB Eagle ULP (oxullo): https://github.com/oxullo/jlcpcb-eagle Screaming Circuits Centroid ULP: Available through element14 forums

Parts Databases JLCPCB/LCSC Parts Library: https://jlcpcb.com/parts

Assembly House Documentation JLCPCB BOM/CPL Guide: https://jlcpcb.com/help/article/How-to-generate-BOM-and-CPL-from-Eagle-CAD-automatically PCBWay Assembly Requirements: https://www.pcbway.com/assembly-file-requirements.html

Frequently Asked Questions

Does Eagle have a built-in pick-and-place export function?

Yes, Eagle includes a built-in export through File → Export → Mount SMD in the Board Editor. This generates separate files for top and bottom SMD components. However, the output format often needs reformatting to match assembly house requirements. Most users find that ULPs like mountsmd.ulp or custom scripts like the JLCPCB exporter produce more immediately usable output.

What file extensions does Eagle use for pick-and-place files?

Eagle’s built-in Mount SMD export and the standard mountsmd.ulp create files with .mnt (mount top) and .mnb (mount bottom) extensions. These are plain text files that can be opened in any text editor. Custom ULPs like the JLCPCB exporter typically generate .csv files that open directly in spreadsheet programs and are accepted by most assembly services.

Why are my components showing rotated incorrectly in the assembly preview?

Rotation discrepancies occur because Eagle reports rotation relative to how the footprint was defined in the library, which may differ from the assembly house’s reference orientation. Different library creators use different conventions for pin 1 location at 0-degree rotation. The fix is to adjust rotation values in your exported CSV file—add or subtract 90 or 180 degrees as needed—until the preview shows correct orientation.

Can I generate pick-and-place data for through-hole components in Eagle?

Yes, use mount.ulp instead of mountsmd.ulp to include through-hole components in your output. The standard mountsmd.ulp and Mount SMD export only include surface mount components. If your assembly house offers through-hole insertion services, they’ll need the through-hole placement data in a separate file or combined with your SMD data.

How do I add LCSC part numbers to my Eagle design for JLCPCB assembly?

Add a user-defined attribute named “LCSC_PART” to each component in your schematic. Set the attribute value to the LCSC part number (like C25804) from JLCPCB’s parts database. When you run the jlcpcb_smta_exporter.ulp, it extracts these attributes and includes them in the generated BOM file. This allows JLCPCB’s system to automatically match components during ordering.

Wrapping Up Eagle Pick-and-Place Generation

Generating pick-and-place files from Eagle requires understanding the tool’s ULP-centric approach to manufacturing outputs. While the built-in Mount SMD export works, most practical workflows involve ULPs—whether it’s the standard mountsmd.ulp, the Screaming Circuits centroid script, or manufacturer-specific tools like the JLCPCB exporter.

The key steps are consistent regardless of which method you choose: work from your finalized board layout, generate separate or combined files for top and bottom components, reformat as needed for your specific assembly house, and carefully verify the preview before ordering.

Eagle’s flexibility with ULPs means you can customize output for virtually any assembly house’s requirements. Once you’ve set up your workflow with the right ULPs and understand how to handle rotation corrections, generating pick-and-place files becomes a quick, routine part of preparing your design for manufacturing.

Take the time to verify your first few files carefully against the assembly preview. After you’ve confirmed your process works correctly, future designs using the same libraries and workflow will produce reliable results with minimal effort.