How to Import an Excel File Without Writing a Script

The spreadsheet that arrives the same way every month

Finance gets a billing spreadsheet from a vendor every month. It's always roughly the same shape — order details, a status column, a revenue figure — but never quite identical: sometimes it's .xls, sometimes .xlsx, sometimes there's a second sheet with a summary tab nobody asked for, and at least one column always has a formula result instead of a plain number, which behaves differently depending on which program opens it.

Someone re-does the same fixes every month: strip the summary tab, convert the formula column to values, check that the status column still says what it said last month. Then the "cleaned" file gets used for whatever it was needed for, and next month starts over.

Why this keeps happening

Vendor and partner spreadsheets are built for whoever built them, not for whoever receives them next. The format is consistent enough to recognize but not consistent enough to trust blindly — which means every arrival gets the same manual once-over, because skipping it is how a formula artifact or a stray tab ends up in a number someone reports upward. It's the same reason ETL treats "extract" as its own deliberate stage rather than assuming a source file arrives ready to use.

The manual approach

1. Open the file — check whether it opened as .xls or .xlsx, since that's affected which formulas rendered correctly before.
2. Delete or ignore any extra sheet that isn't the actual data.
3. Copy the "formula" column and paste it back in as values, so a #REF! doesn't silently show up somewhere downstream.
4. Scroll the status column to make sure nothing unexpected snuck in.
5. Save a cleaned copy, use it, repeat next month.

Why the manual version breaks

• The fixes aren't written down anywhere. Whoever does this each month is doing it from memory, not a checklist — which means the checklist changes slightly depending on who's doing it.
• Format quirks are invisible until they aren't. A formula-as-value paste that gets missed doesn't show up as an error; it shows up three steps later as a number that's quietly wrong.
• A "cleaned copy" isn't a record. There's no trace of what was actually different about this month's file compared to last month's.

Importing it once, properly

Here's the same monthly spreadsheet brought in through DataQloo's Import Wizard — the same four-step flow as a CSV import, with the parts that actually differ for Excel called out.

Step 1 — upload, XLS or XLSX

Both legacy .xls and current .xlsx formats work through the same upload step — no need to check or convert the format first. That question that usually comes up before opening the file ("wait, which version is this") stops mattering.

Step 2 — preview what actually parsed

The row preview shows what the Import Wizard actually read from the sheet — including, critically, what a formula cell resolved to. If a formula produced an error or an unexpected blank, it's visible here, in the preview, rather than discovered later.

Step 3 — profile before trusting it

The same column-level profile as a CSV import — fill rate, unique count, null percentage, inferred type — runs regardless of the source format. A column that's supposed to be numeric but imported as text (a common symptom of a formula artifact or inconsistent formatting) shows up here as a type mismatch, not a mystery three steps downstream.

Step 4 — save it as a dataset

One name, one saved dataset — Sales Orders — regardless of whether next month's file is .xls or .xlsx, one sheet or three. The Import Wizard reads the data; what to do with an extra sheet or a stray column is a decision made once, at import, not re-made from memory every month.

What comes out the other side

Before: a monthly attachment that needs the same undocumented fixes applied by hand, with no way to check what was actually different this time.

After: a dataset with a profile attached to it — the same fill-rate, type, and uniqueness information every time, regardless of who ran the import or which file format the vendor happened to send.

Key takeaways

• .xls and .xlsx both import through the same flow — no manual format-checking step.
• The profiling step catches formula-artifact and type-mismatch issues that a quick scroll wouldn't reliably surface.
• The fixes that used to live in one person's memory become a fixed, repeatable step instead — which is the same underlying idea behind turning a one-off CSV into a reusable dataset, just for a workbook instead of a plain file.

Next

Once a file is imported, the natural next step is checking whether it's actually trustworthy before building on it — see a field guide to reading a data profile report. (For the same Import Wizard flow starting from a CSV instead, see how to import a CSV file into a reusable dataset.)