Turbo Excel Column and Row Extractor

Almost every office ends up with the same problem eventually. Data arrives as separate files — one workbook per branch, per month, per client, per supplier, per machine, per survey batch — and each of those workbooks holds far more than anybody needs. Somebody then has to open each file, find the four columns that matter, copy them, paste them into a master sheet, and repeat that until the folder is empty. With twenty files it is tedious. With four hundred files it is a week of work and a guaranteed source of mistakes.

Turbo Excel Column and Row Extractor removes that entire loop. You describe the extraction once — which folder, which sheets, which columns, which rows, which conditions — and the app applies that description to every file it finds. It is an Excel column extractor and a row extractor in the same window, and you can use either half on its own or both together.

In practice there are three shapes of job it handles, and they cover almost everything people need:

• Narrow many files down to a few columns. Keep every row, but discard the columns you do not care about. This is the classic answer to how to copy columns from multiple Excel files — select the headers you want and let the app read the rest.
• Pull out only the rows that matter. Keep every column, but return only the first fifty rows, or the last twenty, or every row where the status column says "Open". This is the answer to how to copy rows from multiple Excel files when the files are large but the interesting part is small.
• Do both at once. Take four columns, but only for rows where the region is South and the amount is greater than 10,000. The result is a compact table assembled from hundreds of sources.

The scanner recognises four input types, and each one has its own checkbox so you can include or exclude it per job. Select All and Clear All buttons sit next to the checkboxes for when you want to switch the whole set quickly.

Type	What it is	Notes
.xlsx	The standard modern Excel workbook.	Read through openpyxl. Multi-sheet workbooks are fully supported, and every sheet is addressable.
.xlsm	A macro-enabled Excel workbook.	Handled exactly like .xlsx. Macros are never executed — only the cell data is read, which also makes it a safer way to open files from outside sources.
.xls	The legacy Excel 97–2003 binary format.	Read through the xlrd engine, which ships with the app. Off by default in the file-type checkboxes, so tick it when your folder contains older files.
.csv	Plain comma-separated text.	Treated as a single-sheet file. The worksheet setting is ignored for CSV input because there is only one table to read.

You can mix all four types in the same folder and the same run. A folder holding last year's .xls exports, this year's .xlsx workbooks and a handful of .csv dumps from a reporting system can be extracted in one pass, as long as the columns you are asking for exist in each of them.

Output is written as either a modern Excel workbook or a CSV file, and the choice is a single dropdown. The extension is appended for you, so you type a name like Consolidated_Sales and the app produces Consolidated_Sales.xlsx or Consolidated_Sales.csv depending on the format you picked.

The app opens on a single scrollable window divided into eight numbered sections, arranged in the order you would naturally think about the job. You work down the window from top to bottom: where the files are, which sheets to read, what kind of extraction you want, which columns, which rows, which conditions, what cleaning to apply, and where the output should go. Below the sections sits an action bar with Preview, EXTRACT DATA, Stop and Open Output Folder, then a progress area and an activity log. There is no project to create, no wizard to click through and no account to register.

What happens when you press EXTRACT DATA

Understanding the order of operations makes the settings much easier to reason about, and it explains a few behaviours that would otherwise look surprising. For each file the app finds, it does the following:

1. Resolve the sheets. The worksheet mode is applied to that specific file, so a workbook with four tabs and a workbook with one tab are both handled correctly under the same setting.
2. Read the sheet into memory using the header row you specified, with every value read as text so that IDs with leading zeros, mixed-type columns and long numbers survive intact.
3. Record the original row number for every row, before any filtering happens. This is what allows the Source Row column to stay accurate no matter how much you filter afterwards.
4. Apply the positional row rule — first N, last N, a range, specific rows or skip first N — while all original columns are still present.
5. Apply the filter conditions, again with every original column still available. This is why a condition can reference a column you are not keeping.
6. Narrow to the chosen columns. Only now does the app discard the columns you did not select.
7. Insert the tracking columns — Source File, Source Sheet and Source Row — at the front of the table, in that order, for whichever ones you enabled.
8. Run the cleaning pass, trimming whitespace and dropping blank rows if you asked for it.
9. Write or hold the result. In per-file mode the trimmed table is written immediately. In combined mode it is held until every file is done, then concatenated, de-duplicated and written once.

This is the question the app was built to answer. If you have been doing it by hand — open a workbook, select a column, copy, switch to the master sheet, paste, close, repeat — the process below replaces all of it with a single configured run. Here is how to copy columns from multiple Excel files from start to finish.

1. Put the files somewhere sensible. They do not have to be in one flat folder, because the scanner can recurse, but they do need to sit under a common parent. If the files are scattered across a network share, point the app at the top-level folder and let it walk down.
2. Select the folder in section 1. Click Browse and pick the parent folder. Leave Include subfolders ticked if the files are nested. If the folder also contains files you do not want, add a filename pattern such as Sales_*.xlsx. Tick the file types present in the folder, then click Scan Files. The label next to the button reports the match count — check it looks right before going further.
3. Decide which worksheets to read in section 2. If every file has its data on the first tab, choose First Worksheet. If each workbook holds several tabs that all need extracting, choose All Worksheets. If only specific tab names matter, choose Selected Worksheets, click Load Sheet Names From First File, and tick the ones you want.
4. Set the extraction mode to Columns in section 3. The row settings grey out immediately, which confirms that every data row will be kept and only your column choice will be applied.
5. Load the column list in section 4. Click Load Columns From First File. The app reads the header row of the first matching file and turns every header into a checkbox, laid out four across. Click Clear All, then tick just the columns you need. If your headers are not on row 1 — because the file starts with a report title and a date — set Header row is row # first, then load the columns again.
6. Or select by column letters instead. Switch the selection method to By Column Letters and type a spec such as A,C,F:H. This is the better option when the header text varies slightly between files but the layout is identical, because letters refer to position rather than to a name that has to match.
7. Configure the output in section 8. Choose Combine into One File to get a single consolidated workbook. Pick xlsx or csv, browse to an output folder, and give the combined file a name. Leave Add Source File column and Add Source Sheet column ticked so you can tell which workbook each row came from.
8. Preview. Click Preview. The app runs your settings against the first matching file and shows the resulting table. Confirm the columns are the ones you wanted and that the values look sensible. If the preview is empty or wrong, the settings are wrong — fix them here rather than after a long run.
9. Extract. Click EXTRACT DATA. The progress bar fills, the speed and ETA update live, and the activity log records the result. When it finishes, Open Output Folder becomes available and takes you straight to the file.

Header name or column letter — which should you use?

Both approaches produce the same kind of result, but they fail in different ways, and picking the right one for your folder saves trouble.

Situation	Better choice	Why
Files come from the same template, headers spelled identically	Header name	Readable, self-documenting, and unaffected by someone inserting a column in the middle of the sheet.
Column order is fixed but header text varies (“Amount” vs “Amount (USD)”)	Column letters	Position is stable even when the wording is not, so nothing is silently skipped because a name did not match.
Files have no header row at all	Column letters	There is no name to match against, so position is the only reliable reference.
You need a wide contiguous block, for example B through to M	Column letters	A range like B:M is far quicker to type than ticking twelve boxes.
Different files have the same columns in different orders	Header name	Names follow the data. Letters would pull the wrong column out of the odd file.

Row extraction is the mirror image of column extraction, and the app treats it with the same weight. The question of how to copy rows from multiple Excel files usually breaks down into two quite different problems: rows identified by position, and rows identified by content. The app handles both, and it handles them together when you need it.

Copying rows by position

Positional extraction is the right approach when the structure of every file is predictable. Set the extraction mode to Rows in section 3, then choose a row mode in section 5:

Row mode	What it returns	Typical use
All Rows	Every data row below the header.	The default. Use it when your filtering will come from conditions rather than position.
First N Rows	The first N rows of each sheet.	Sampling a large archive, or grabbing the top entries from files that are already sorted by rank or date.
Last N Rows	The final N rows of each sheet.	Pulling the most recent entries from append-only logs, where new records are added at the bottom.
Row Range	Rows from a start position to an end position, inclusive.	Fixed-layout reports where the section you want always occupies the same block of lines.
Specific Rows	Only the row numbers you list, for example 1,5,10,25.	Extracting particular summary or total lines that always land in the same places.
Skip First N Rows	Everything except the first N rows.	Files with title blocks, notes or merged banner rows sitting above the real table.

Row numbers here refer to data rows below the header, in the order they appear in the sheet. If you need to know the true spreadsheet line number for each extracted record, switch on the Add Source Row column in section 8 — it reports the original position, calculated before any filtering.

Copying rows by content

Far more often, the rows you want are defined by what they contain. That is what section 6 is for. Click + Add Condition and you get a rule builder: a column, an operator, and a value. Add another condition and a logic dropdown appears in front of it so you can join the two with AND or OR.

A few examples of what that looks like in practice:

• Status Equals Open — every unresolved record across every file.
• Invoice Total Greater Than 10000 AND Region Equals South — large southern invoices only.
• Email Contains @example.com OR Email Contains @example.org — contacts from either domain.
• Notes Is Not Blank — only rows where somebody actually wrote something.
• Customer ID Starts With ACME- — one client's records pulled out of a shared archive.

Text comparisons are case-insensitive and ignore surrounding spaces, so Sales, sales and  Sales  all match the same condition. That is deliberate: real spreadsheets are inconsistent, and a filter that only matched exact casing would quietly drop rows you meant to keep. The four numeric operators convert the column to numbers first and simply do not match rows where the value is not numeric, which means a stray text note in a numeric column cannot break the comparison.

Putting position and content together

The two systems stack. The positional rule runs first, then the conditions run on whatever survived. So Skip First N Rows set to 3, combined with a condition of Amount Greater Than 500, means: ignore the three-line title block at the top of every file, then keep only the rows above 500. This combination is what makes messy real-world exports workable, because it lets you deal with layout junk and content filtering as two separate concerns instead of one tangled rule.

There is a real difference between a tool that can handle twenty files and one that can handle two thousand. The moment you need to copy columns from 100s of Excel files, three things start to matter that simply do not matter at small scale: throughput, traceability, and the ability to recover when a few files are broken. The app is built around all three.

A concrete example

Consider a finance team that receives a monthly workbook from each of 240 retail locations. Every workbook holds around 4,000 transaction rows across 30 columns, but head office only needs six of those columns for its reporting cube. Done manually at three minutes per file — open, find the columns, copy, paste, verify, close — that is twelve hours of work, and the error rate on the two-hundredth file is not the same as on the first.

Configured once in this app, the same job is a folder path, six ticked checkboxes and one button press. The output is a single workbook of roughly 960,000 rows and eight columns — the six requested plus Source File and Source Sheet — and it is reproducible next month by loading the saved configuration and changing nothing but the folder.

The need to copy rows from 100s of Excel files tends to arrive as a question rather than as a task. Somebody asks which orders are still open, which sites reported a fault last quarter, or which of the survey responses mentioned a particular product. The data exists, but it is spread across hundreds of workbooks, and answering the question by hand is not realistic.

Treated as a batch job, that question becomes a filter. Set the extraction mode to Rows or Columns + Rows, add the condition that describes what you are looking for, and run the folder. What comes back is a single table containing every matching row from every file, each one labelled with its origin. The search that would have taken a day takes a few minutes, and it can be re-run tomorrow when the answer needs updating.

Why this scales better than a search

Windows search and similar tools can tell you which files contain a term. That is a genuinely different thing from telling you which rows contain it, and it leaves you with a shorter list of files to open by hand rather than with an answer. Conditional row extraction skips that middle step entirely: instead of a list of two hundred candidate workbooks, you get the eleven thousand matching records, already assembled into one table, already carrying the file and sheet they came from.

It also composes in a way that manual searching does not. Once the extraction is configured, tightening the question is a matter of adding one more condition and pressing the button again. Widening it is a matter of switching an AND to an OR. Each iteration costs a few minutes rather than another full day of opening files, which changes what it is reasonable to ask of the data.

Keeping large row extractions manageable

• Filter early and specifically. A tight condition produces a smaller output that is faster to write and far easier to work with afterwards. It is usually better to run twice with a precise filter than once with a loose one.
• Switch on Source Row when you may need to go back to the original file and look at the record in context. Source File tells you which workbook; Source Row tells you exactly which line in it.
• Use CSV output for very large results and import it wherever the analysis is actually happening.
• De-duplicate on a key column such as an order ID or a record number if the same row legitimately appears in more than one source file.
• Save the configuration as soon as a run produces what you wanted, so that the same question can be answered again next month without rebuilding the filter from memory.

Everything starts with deciding which files are in the batch. Section 1 gives you four independent controls for that, and they combine, so a file has to satisfy all of them to be picked up.

Useful filename patterns

Pattern	Matches
*	Every file of a ticked type. The default.
Sales_*	Any file whose name begins with Sales_.
*_2026.xlsx	Only 2026 XLSX files, whatever comes before the year.
*North*	Any file with North anywhere in the name.
Report_??.csv	Report_01.csv through Report_99.csv, but not Report_100.csv.
2026-0?-*.xlsx	Workbooks dated in the first nine months of 2026, given an ISO-style naming convention.

Get into the habit of pressing Scan Files after changing any of these four controls. It costs a second and tells you immediately whether the pattern you typed does what you assumed. A count of zero, or a count far higher than expected, is much better discovered now than after configuring the other seven sections.

Excel files rarely hold just one sheet, and which sheets you read has a direct effect on what comes out. Section 2 offers four modes, each resolved separately for every file in the batch, so workbooks with different tab counts are all handled correctly under one setting.

Section 3 is a single choice with three options, and it determines which of the sections below it actually apply. Getting this right first makes everything after it simpler, because the window will visibly disable whatever is no longer relevant.

Mode	Columns	Rows	Use it when
Columns	Filtered by your selection	All kept	You want fewer columns but every record. The standard answer to how to copy columns from multiple Excel files.
Rows	All kept	Filtered by your rules	You want fewer records but the full width of the table. The standard answer to how to copy rows from multiple Excel files.
Columns + Rows	Filtered	Filtered	You want a specific slice of the data in both directions. The default, and the most flexible.

The greying-out behaviour is worth relying on rather than working around. If you select Rows and notice that the column checkboxes are still ticked, they are not being applied — the mode wins. This prevents the most common confusion in tools of this kind, where a leftover setting from an earlier job silently changes the result of the current one.

One consequence worth knowing: filter conditions in section 6 apply in every mode, including Columns-only mode. They are treated as part of what the extraction means rather than as part of the row selection, so a condition will still narrow your results even when the positional row settings are disabled.

Section 4 offers two selection methods, a header row setting, and the tools to work with wide tables quickly.

By header name

Click Load Columns From First File and the app reads the header row of the first matching file, then renders every header as a checkbox in a four-column grid. All boxes start ticked, so the fastest route to a small selection is usually Clear All followed by ticking the handful you want. The names come from your actual data, which means there is no typing and no risk of a spelling mismatch.

Matching is by exact header text. A column called Order Date in one file and Order date in another will not both be captured by a single tick, because they are genuinely different strings. If your files vary in that way, either standardise the headers first or switch to column letters.

By column letters

Switch the selection method to By Column Letters and a text box appears. Type spreadsheet-style references separated by commas, and use a colon for a range:

Spec	Selects
A,C,E	The first, third and fifth columns.
A:D	The first four columns as a contiguous block.
A,C,F:H	Columns A and C, plus the block F through H.
B:D,M,AA:AC	Mixed ranges and singles, including two-letter references beyond column Z.

Letters refer to position in the sheet, which makes this method immune to header wording but sensitive to layout changes. If somebody inserts a column at the front of one file, every letter after it shifts. Header names have the opposite trade-off. Neither is universally better — pick the one that matches how your files actually vary.

The header row setting

The Header row is row # spinner tells the app which line holds the column names. It defaults to 1. Set it to 4 and the app treats row 4 as the header and everything below it as data, which is exactly what you need for exports that open with a report title, a company name, a date stamp and a blank line before the real table begins.

Change this setting before loading the column list. The checkboxes are built from whichever row the setting points at, so loading first and adjusting afterwards leaves you ticking the wrong values — usually the contents of a data row rather than a set of headers.

Section 5 holds the positional row rule and the value mode. The dropdown at the top selects the rule, and the controls beneath it change to match whichever one you picked, so you only ever see the parameters that are relevant.

Values Only or Formulas as text

Two radio buttons at the bottom of section 5 control what is read out of each cell. Values Only is the default and is the right choice for essentially every consolidation job: it reads the value the cell displays, so a cell containing =B2*C2 comes through as the number it evaluates to. That is what you want when the output feeds a report, a pivot table or an import.

Formulas (as text) exists for the rarer case where the formula itself is the thing you are auditing rather than its result. It reads cached values through the underlying engine rather than re-evaluating formulas, so treat it as a diagnostic option rather than a replacement for opening the workbook in Excel.

Section 6 is optional and empty by default, which means every row passes. Click + Add Condition to build a rule. The first condition is prefixed with the word Where; every one after it gets an AND / OR dropdown so you can control how it joins to the rules before it. A small × button removes any individual condition, and Clear All Conditions empties the section entirely.

The twelve operators

Operator	Behaviour	Example
Equals	Exact match, case-insensitive, surrounding spaces ignored.	Region Equals South
Does Not Equal	Everything except an exact match, under the same rules.	Status Does Not Equal Closed
Contains	The value appears anywhere in the cell. Case-insensitive, treated as plain text rather than a pattern.	Product Contains Widget
Does Not Contain	The value appears nowhere in the cell.	Notes Does Not Contain draft
Starts With	The cell begins with the value.	Code Starts With ACME-
Ends With	The cell ends with the value.	File Ends With _final
Greater Than	Numeric comparison. Non-numeric cells never match.	Amount Greater Than 10000
Less Than	Numeric comparison.	Stock Less Than 5
Greater Than or Equal	Numeric comparison, inclusive.	Score Greater Than or Equal 60
Less Than or Equal	Numeric comparison, inclusive.	Days Less Than or Equal 30
Is Blank	The cell is empty, or contains only spaces. No value needed.	Approved By Is Blank
Is Not Blank	The cell contains something other than spaces. No value needed.	Comment Is Not Blank

How AND and OR combine

Conditions are evaluated in the order they appear on screen, each one joining to the accumulated result of everything above it. There is no bracketing, so the practical rule is to keep condition sets simple and readable. If you find yourself wanting parentheses, it is usually cleaner to run two extractions with different filters than to try to express a complex nested rule in a flat list.

Section 7 holds two optional checkboxes. Both are off by default, on the principle that the app should not alter your data unless you explicitly ask it to. When you do want them, they solve two problems that show up constantly in consolidated data.

These are deliberately narrow, predictable operations. If you need heavier work — deduplicating fuzzy text, splitting columns, standardising dates, removing special characters, normalising case across dozens of rules — that is a different job, and Turbo Excel Cleaner is the tool built for it. Extract first with this app, then clean the consolidated result.

Section 8 decides what the run produces. The first choice is the most consequential one, and the rest follow from it.

Setting	What it controls
Output format	xlsx or csv. The extension is added automatically, so you never type it.
Output folder	Where results are written. Created automatically if it does not exist. Keep it separate from the input folder so outputs are never picked up as inputs on a later run.
Combined output filename	The base name for the merged file, defaulting to Extracted_Data. Ignored in per-file mode.
Duplicate handling	Keep everything, remove exact duplicates, or remove duplicates by chosen key columns.
If a file fails	Skip it and continue, or stop the whole run at the first error.

Always choose an output folder that sits outside the folder being scanned. If the output lands inside the input tree and you re-run the job with sub-folder scanning enabled, the app will find its own previous output and extract from it as well.

Three checkboxes add provenance columns to the front of the output. They are one of the most useful things about batch extraction, and they cost nothing to enable.

Column	Contains	Default
Source File	The file name the row came from, such as Branch_04_March.xlsx.	On
Source Sheet	The worksheet name within that file. Shows CSV for CSV inputs.	On
Source Row	The original row number in the source sheet, calculated before any filtering.	Off

They are inserted in that order at the left of the table, ahead of your extracted data, so the output reads naturally from origin to content. If you enable all three you get a complete address for every record: which file, which tab, which line.

Beyond traceability, these columns are genuinely useful as analysis dimensions. Source File is often a stand-in for branch, month, client or region, depending on how your files are named — which means a consolidated extract can be pivoted by source without anyone having added a category column to the original data. Source Sheet does the same job for workbooks organised one tab per period.

Merging many files reliably produces duplicates. The same customer appears in two regional lists, a record is carried forward from one month's file into the next, or an export was run twice. The duplicate dropdown in section 8 offers three ways to deal with it, applied to the combined result after every file has been read.

There is also a sequencing detail worth knowing: whitespace trimming happens before duplicates are assessed. Two rows that differ only by a trailing space will therefore be recognised as duplicates when trimming is on, and treated as distinct when it is off. If de-duplication is missing obvious matches, switching on whitespace trimming is the first thing to try.

The Preview button in the action bar runs your current settings against the first matching file only and shows you the result. It is the single most useful habit to build when working with this app, and it takes a couple of seconds.

The preview window shows up to 25 rows of output, exactly as the real run would produce them, including the source tracking columns and any cleaning you enabled. Above the table sits a status line naming the file used and reporting how many rows matched in total — so even though you only see 25, you learn whether the filter caught eleven rows or eleven thousand.

Three outcomes are all informative:

• A table that looks right. Your settings are correct. Run the batch.
• A table with the wrong columns or odd values. Usually the header row setting, or column letters pointing at the wrong positions. Fix it and preview again.
• No rows at all. Either your conditions match nothing in that particular file, or a condition references a column that does not exist under that name. The activity log will say which file was used, so you can open it and check.

Preview only ever reads one file, so it stays fast regardless of how large the batch is. Running it on a folder of two thousand workbooks costs the same as running it on a folder of five — which is precisely why it is worth doing before every long job.

Batch work happens on a background thread, so the window stays responsive throughout. You can scroll the settings, read the log and resize the window while a batch of several thousand files is running.

One behaviour worth anticipating: in Combine into One File mode, the combined workbook is written after every file has been read, so the final few seconds of a large job are spent building and saving one big output. The progress bar will sit at full while that happens. It has not stalled — it is writing.

Under the File menu, Save Configuration... writes every setting on the window to a .json file, and Load Configuration... restores them. It sounds like a minor convenience and turns out to be one of the most valuable features in the app for anybody doing recurring work.

A monthly consolidation configured once becomes a thirty-second task from then on: open the app, load monthly_sales_extract.json, point section 1 at this month's folder, press EXTRACT DATA. Nothing is rebuilt from memory, so the extraction is identical every month and produces output with an identical shape — which matters enormously when the result feeds a downstream report or import that expects specific columns in a specific order.

Saved configurations are also the practical way to share an extraction with a colleague. The file is plain JSON, small enough to email, and loading it reproduces the exact set of columns, conditions, cleaning options and output settings on their machine. It is a far more reliable handover than a written list of instructions, and it removes the class of problem where two people run "the same" extraction and get different results.

Give configuration files descriptive names and keep them alongside your input folders. config.json tells you nothing in six months; open_tickets_by_region_2026.json tells you everything.

The pattern that makes this app worth having is always the same: data arrives as many files, but the question you need to answer needs one table. Here is how that shows up across different kinds of work.

Four complete jobs, with the exact settings that produce them. Each one is a template you can adapt.

Consolidate 300 monthly branch workbooks into one sheet

Section 1: the parent folder, subfolders on, pattern *.xlsx. Section 2: First Worksheet. Section 3: Columns. Section 4: load columns, Clear All, tick Date, Branch, Account, Amount. Section 7: trim whitespace on. Section 8: Combine into One File, xlsx, Source File and Source Sheet on, Keep Everything. Result: one workbook with six columns and every transaction from all 300 branches, each row labelled with its origin.

Pull every open ticket from a year of weekly logs

Section 1: the log archive, subfolders on. Section 2: All Worksheets, since each workbook holds one tab per week. Section 3: Columns + Rows. Section 4: tick Ticket ID, Opened, Owner, Summary. Section 6: Status Equals Open. Section 8: Combine into One File, all three tracking columns on, Remove Duplicates by Selected Columns keyed on Ticket ID. Result: one row per genuinely open ticket, with the week and file it was last seen in.

Strip 500 reports down to a fixed column set, one file each

Section 1: the reports folder. Section 3: Columns. Section 4: By Column Letters, spec A,B,E:G, header row set to 4 because every report opens with a three-line title block. Section 7: drop blank rows on. Section 8: Separate File per Input, csv. Result: 500 slim CSV files, each named after its original with an _extracted suffix, ready for a bulk import.

Find every high-value southern order across a mixed archive

Section 1: the archive root, subfolders on, all four file types ticked because the folder holds a decade of .xls, .xlsx and .csv files. Section 2: All Worksheets. Section 3: Columns + Rows. Section 5: All Rows. Section 6: Region Equals South, AND Order Total Greater Than 10000. Section 8: Combine into One File, csv, all tracking columns on. Result: one table of every matching order in the archive, each traceable to its exact source line.

Batch processing runs across a fixed pool of 128 worker threads. There is no slider, and that is a deliberate design decision rather than a missing feature.

Reading a workbook is dominated by waiting — waiting for the disk, waiting for the file system, waiting for a network share to respond. While one worker waits, another can be doing useful work. Running many reads concurrently therefore produces a genuine reduction in wall-clock time, and the effect is most pronounced on exactly the batches where it matters: folders with hundreds or thousands of files.

Exposing that number as a setting would mean asking every user to tune something that has one sensible answer for almost every job. Worse, a badly chosen value produces slow runs that look like a fault in the app. Fixing it at 128 removes a decision that adds no value.

What actually determines your speed

Factor	Effect
Storage type	The single biggest factor. An NVMe SSD will process a large batch several times faster than a mechanical drive, and local storage beats a network share by a wide margin.
File size	A folder of 2,000 small files usually completes faster than 200 very large ones. Total data read matters more than file count.
Sheets per workbook	All Worksheets on a file with 20 tabs means 20 reads for that file. Restricting to First Worksheet is a large saving when the other tabs are irrelevant.
Available RAM	Matters most in Combine mode, where results are held in memory until the end. More RAM means comfortably larger consolidated outputs.
Output format	CSV writes noticeably faster than XLSX for very large results, because there is no workbook structure to construct.
Legacy .xls files	The older binary format is slower to parse than modern XLSX. A batch that is mostly .xls will run slower than an equivalent batch of .xlsx.

If a batch is slower than you expect, the productive question is almost never "can I add more threads?" It is usually one of: are the files on a network share, am I reading every sheet when I only need one, and is my output format right for the size of the result?

In any large folder, some files will not read. They may be corrupt, open in Excel on another machine, password-protected, or saved with an extension that does not match their actual contents. The If a file fails dropdown decides what happens then.

Either way, the failure count is displayed live during the run and the activity log keeps the record. If a batch reports failures, the log is the place to find out which files and why. Common causes, in rough order of frequency: the file is currently open elsewhere, the file is password-protected, the file is a .xls saved with an .xlsx extension, or the file is genuinely damaged.

It is worth noting what does not count as a failure. A file that reads successfully but produces no matching rows is a success with zero rows, not an error — which is correct, because "no rows in this file matched your filter" is a normal outcome, not a fault.

It is worth being honest about when a tool like this is not needed. If you have five files and a one-off request, opening them and copying the columns by hand is perfectly reasonable and will take less time than configuring anything. The calculation changes when the work repeats or the folder grows.

Aspect	Manual copy-paste	Batch extraction
Time for 300 files	Hours to days, entirely dependent on attention span	Minutes, mostly spent configuring the first time
Consistency	Drifts as fatigue sets in — a wrong column here, a skipped file there	Identical rules applied to every file, every run
Traceability	Lost unless someone adds a source column by hand	Automatic, per row, at no extra effort
Repeatability	The whole job again next month	Load a saved configuration and press one button
Error recovery	Start again, or try to find where it went wrong	Change a setting, re-run, get a fresh clean output
Nested folders	Manual navigation, easy to miss a folder	Recursive scan, nothing skipped
Handling broken files	Stops you and needs a decision each time	Skipped and counted, batch continues
Setup cost	None	A few minutes the first time, near zero afterwards

The honest summary: below roughly ten files, manual work wins. Between ten and fifty it is close, and the deciding factor is whether you will ever do it again. Above fifty files, or for anything recurring, batch extraction is not just faster but meaningfully more accurate — because a rule applied by software does not get tired on the two-hundredth file.

Spreadsheets tend to hold exactly the material an organisation is most careful about: payroll, customer records, financial detail, medical or research data. That shaped how this app handles your files.

• All processing is local. Files are read from your disk and written back to your disk. Nothing is uploaded, and there is no cloud component to the extraction at all.
• No telemetry on your data. The app does not transmit file names, column names, cell values, row counts or folder paths anywhere.
• One network request, ever. The only time the app contacts the internet is the one-time license activation, which carries your license key and purchase email and nothing else.
• Works offline afterwards. Once activated, verification is cached locally, so the app runs on machines with no internet connection and in restricted or air-gapped environments.
• Source files are never modified. The app only ever reads input files. Results go to the output folder you nominate, so the originals stay exactly as they were.
• Macros are never executed. Macro-enabled .xlsm files have their cell data read without their code running, which makes bulk-reading files from outside sources safer than opening them in Excel.

In practice this means the app is usable in environments where a web-based converter or an online merge tool would be prohibited outright. Data that cannot leave the building does not have to.

Operating system	64-bit Windows 10 or Windows 11
Processor	64-bit x86 processor, dual core
Memory	4 GB RAM
Disk space	300 MB for the application, plus room for your output files
Display	1280 × 720 or higher
Internet	Required once for license activation only
Excel	Not required — the app reads and writes files directly

Operating system	64-bit Windows 11
Processor	Modern quad-core or better
Memory	16 GB RAM or more for very large combined outputs
Storage	NVMe SSD, with input files stored locally rather than on a network share
Display	1920 × 1080 so all eight sections are comfortable to work with

The recommendations matter most for one specific case: combining hundreds of large files into a single output, where every extracted row is held in memory until the final write. For per-file output, or for moderate batches, the minimum specification is genuinely sufficient.

Application	Turbo Excel Column and Row Extractor
Publisher	TurboSoft
Category	Excel column extractor / batch data extraction
Platform	Windows 10 and Windows 11, 64-bit
Input types	.xlsx, .xlsm, .xls, .csv
Output types	.xlsx, .csv
Worker threads	128, fixed
Licensing	One-time purchase through Gumroad
Trial	None — a valid license key is required to run extractions
Internet required	Once, for activation
Installer	Standalone Windows executable

1. Purchase the license. Use the Buy Now button on this page. The purchase goes through Gumroad and your license key is issued immediately, along with a receipt sent to the email address you used.
2. Download and install. Run the installer on any 64-bit Windows 10 or Windows 11 machine. Excel does not need to be installed — the app reads and writes spreadsheet files directly.
3. Activate on first launch. The activation dialog appears automatically the first time you open the app. Enter the email address you purchased with and your license key, then click Activate.
4. Work offline from then on. Verification is cached locally after a successful activation, so the app continues to run with no internet connection at all.

If activation fails, the two things to check first are that the email exactly matches the one used for the purchase, and that the key has been pasted in full with no trailing space. Full step-by-step guidance is on the how to activate TurboSoft apps page, and if you are still stuck, support can help directly.

Being clear about what the app does not do is as useful as listing what it does. These are the current boundaries in version 1.

Symptom	Likely cause and fix
Scan Files reports zero files	The filename pattern or the file-type checkboxes are excluding everything. Reset the pattern to *, tick all four types, and scan again to confirm the folder itself is right.
Columns loaded look like data, not headers	The header row setting does not match your files. Set Header row is row # to the correct line, then click Load Columns From First File again.
Output has more columns than expected	Column selection is either untouched (all boxes ticked by default) or the extraction mode is set to Rows, which keeps every column. Check section 3 first, then section 4.
Output is empty	A condition matches nothing, or references a column name that does not exist in your files. Use Preview and check the activity log for which file it tested.
Some files produced no rows	Normal when filtering. Those files simply contain no matching records. Confirm by checking whether the total row count looks plausible for the filter you applied.
A few files failed	Usually open in Excel elsewhere, password-protected, or damaged. The activity log names them. Close them, remove protection, or accept the skip.
Duplicates were not removed	The Source File column makes rows from different files distinct, so exact-duplicate matching finds nothing. Switch to key-column de-duplication, or turn the tracking columns off for that run.
Progress sits at 100% without finishing	In Combine mode the app is building and writing the merged output after all reads complete. Large results take time to write. Let it finish.
Numbers arrive as text in the output	Values are read as text to protect IDs with leading zeros and long reference numbers. Convert the relevant columns after import if you need them typed as numbers.
.xls files are being ignored	The .xls checkbox is off by default. Tick it in section 1 and rescan.
The run picked up its own output	The output folder sits inside the input folder and sub-folder scanning is on. Move the output somewhere outside the scanned tree.
Activation is refused	Check the email matches the purchase exactly and that the key was pasted in full with no trailing space. See the activation guide if it persists.

• Always preview before a long run. It reads one file and takes seconds, and it catches the great majority of configuration mistakes before they cost you a full batch.
• Scan after every filter change. The match count is the quickest confirmation that your folder, pattern and type settings mean what you think they mean.
• Keep output outside the input tree. This single habit prevents the app from finding its own results on a later run.
• Set the header row before loading columns. The checkbox list is built from whichever row the setting points at, so the order matters.
• Leave the tracking columns on. They cost two columns and answer every "where did this come from?" question you will be asked afterwards.
• Prefer First Worksheet when it is sufficient. Reading every tab of every workbook is significantly slower and often adds nothing.
• Use CSV for very large consolidated outputs and XLSX when a person is going to open the file directly.
• Turn on whitespace trimming before de-duplicating. Trailing spaces are the most common reason duplicates are not detected.
• Test on a copied subfolder first when you are working with an unfamiliar archive. Ten files will tell you whether the settings are right.
• Save the configuration the moment a run works. Recurring jobs then take thirty seconds instead of ten minutes.
• Filter on columns you do not keep when the filter column is only needed for the decision, not for the output.
• Close the source files in Excel first. Files open elsewhere are the most common cause of read failures in a batch.

Excel column extractor

A tool that pulls selected columns out of one or more spreadsheets and writes them to a new file. This app is a batch column extractor, meaning it applies one column selection to an entire folder of workbooks rather than to a single file.

Batch extraction

Applying the same extraction rules to many files automatically, rather than repeating the work by hand for each one. The defining feature is that configuration happens once and execution happens many times.

Header row

The line in a sheet that holds column names rather than data. Usually row 1, but frequently lower in generated reports that open with a title block. The app lets you specify which row it is.

Column letters

Spreadsheet-style position references — A, B, C, and onward to AA, AB and beyond. Used as an alternative to header names when position is more reliable than wording.

Positional row selection

Choosing rows by where they sit in the sheet: the first N, the last N, a range, or a specific list of line numbers. Contrasts with conditional selection.

Conditional row selection

Choosing rows by what they contain, using rules such as Amount Greater Than 1000. In this app, conditions are built in section 6 and combined with AND or OR.

AND / OR logic

How multiple conditions combine. AND requires both to be true; OR requires either. Conditions are evaluated in the order they appear, without bracketing.

Source tracking

Adding columns that record which file, sheet and row each extracted record came from, so a consolidated table remains traceable back to its origins.

Combine mode

Writing all extracted rows from all files into a single output file. The alternative is per-file mode, which produces one output per input.

De-duplication

Removing repeated records from the combined result, either by exact match across all columns or by matching on chosen key columns such as an ID.

Key column

The column whose value identifies a record uniquely — an employee ID, an invoice number, an email address. Used as the basis for de-duplication.

Recursive scanning

Walking every sub-folder beneath a chosen folder, at any depth, so that nested archives are processed without manual navigation.

Filename pattern

A wildcard expression such as Sales_*.xlsx that limits which files enter the batch, where * matches any sequence of characters and ? matches exactly one.

Worker thread

One of the parallel units of work the app uses to process several files at the same time. This app uses a fixed pool of 128, which suits the I/O-bound nature of reading spreadsheets.

Values Only

Reading the value a cell displays rather than the formula behind it. The default, and the correct choice for almost all consolidation work.

Activity log

The scrolling record at the bottom of the window that reports scans, loads, previews and run results. The first place to look when a batch does not do what you expected.

TurboSoft's data tools each solve a different problem, and they are designed to be used together. This one is about pulling a subset out of many files.

Tool	Its job	Reach for it when
Turbo Excel Column and Row Extractor	Extract chosen columns and rows from many files into one output.	You need a subset of many workbooks consolidated into a single table.
Turbo Excel Cleaner	Clean and standardise messy spreadsheet data.	The data you have is already in one place but needs tidying.
Turbo Excel Lookup	Match and enrich records across files.	You need to join two datasets on a shared key.
Turbo CSV Splitter	Split large CSV files into smaller pieces.	You have the opposite problem — one file that is too big.
Turbo Large Data Splitter	Split very large datasets across many formats.	You need to break up a large dataset for distribution or processing.
Turbo Excel Image Extractor and Inserter	Pull images out of workbooks, or put them in.	The thing you need is pictures rather than cell data.

A common pairing: use the extractor to consolidate a folder into one table, then run the cleaner over the result to standardise the values before it goes anywhere else. Extraction narrows; cleaning normalises. Doing them in that order means the cleaner works on one file instead of four hundred.