ETF Data in Google Sheets: FundXLS, MarketXLS Formulas, and GOOGLEFINANCE Side by Side

ETF data in Google Sheets is a workflow most self-directed investors and financial advisors hit a wall on by lunchtime. GOOGLEFINANCE is good enough for the last price and a basic history pull, but the moment you try to compare two ETFs on expense ratio, look up an AUM figure, scan the top holdings of a sector fund, or check the inception date of a niche thematic ETF, the formula returns nothing useful. This guide walks through how to pull every one of those data points directly into Google Sheets using FundXLS, the MarketXLS Google Sheets add-on, and a handful of verified formulas, with a sample workbook and a live template you can download at the bottom.

The angle here is deliberately practical. You will see exactly which functions to type into a Google Sheets cell, which ETF-specific calls are MarketXLS or FundXLS only, and how to stitch the live formulas into a dashboard that respects the way Google Sheets handles spill arrays, references, and recalculation.

ETF Data in Google Sheets: What GOOGLEFINANCE Covers vs What It Skips

Before we layer MarketXLS on top, it is worth seeing the gap clearly. Here is a side-by-side capability table that mirrors the "GOOGLEFINANCE vs MarketXLS" sheet inside the workbook you can download below.

The pattern is clear. GOOGLEFINANCE handles the time-series and the single-stock fundamentals layer at a shallow level. ETF-specific data points, the things that actually drive a fund decision, sit one tier deeper. That is the layer FundXLS and MarketXLS expose.

ETF Data in Google Sheets: Why FundXLS Matters

FundXLS is the ETF and mutual fund data layer inside MarketXLS. It is the same engine that powers our ETF research tools and shows up in Excel and Google Sheets as a family of Fund* functions. The functions that matter for most ETF dashboards are short, predictable, and they accept a ticker string directly.

=FundNetAssets("SPY")          // ETF net assets in dollars (AUM)
=FundTotalAssets("SPY")        // ETF total assets
=FundExpenseRatio("SPY")       // Annual expense ratio %
=FundFamily("SPY")             // Issuer / fund family
=FundInceptionDate("SPY")      // Inception date
=FundHoldings("SPY")           // Top holdings as a spill array
=FundReportPeriodEndDate("SPY")// Reporting period end date

In Google Sheets you call them exactly the same way once the MarketXLS add-on is installed and authenticated. The function returns the value into the cell, and spill functions like FundHoldings flow into the cells below and to the right just like a QUERY or IMPORTRANGE result would.

The rest of this guide assumes you have one ETF watchlist in a Google Sheets workbook, want to enrich it with FundXLS metrics, and would like the file to behave the same way it would in Excel.

ETF Data in Google Sheets: Build the Watchlist

Start with a tab called Main Dashboard and a 25-row watchlist of widely held funds. The columns mirror the downloadable workbook so you can swap between this guide and the file without losing your place.

Column O is intentional. Keeping the GOOGLEFINANCE price next to the MarketXLS price makes it visually obvious which data points are duplicated across both engines and which ones only exist on the MarketXLS side. Once you scroll past the price column there is no GOOGLEFINANCE equivalent for AUM, expense ratio, or any of the FundXLS data points, and the empty cells make the case better than any marketing line could.

A starter universe to seed the dashboard with:

• US broad market: SPY, IVV, VOO, VTI, QQQ, DIA, IWM
• Factor tilts: VTV, VUG, SCHD
• Sectors: XLE, XLK, XLF, XLV, XLY, XLI, XLU, XLP
• International: VXUS, EFA, VWO
• Bonds: AGG, TLT, HYG
• Commodity: GLD

These 25 names cover most of the choices a financial advisor or self-directed investor will compare in a routine planning session, and the asset class column at the front feeds the rollup tab later in the workbook.

ETF Data in Google Sheets: Cost-Quality Score in a Single Formula

A useful side effect of having every metric live in the same row is that you can score ETFs on multiple axes in one formula. The downloadable workbook ships with a Cost-Quality Score that blends four buckets, each worth 25 points:

• Expense ratio (lower is better; below 0.05% scores 25, 0.5% or above scores 0)
• 1-year return (capped at 20% upside, floored at -10%)
• AUM (above 50 billion scores 25, below 1 billion scores 0)
• Dividend yield (each percentage point worth 12.5 points up to the cap)

The formula sitting in column M of the dashboard reads:

=ROUND(
  MAX(0, MIN(25, 25 * (1 - F2/0.5)))
  + MAX(0, MIN(25, 25 * ((I2 + 10)/30)))
  + MAX(0, MIN(25, 25 * (E2/50)))
  + MAX(0, MIN(25, 12.5 * G2))
, 0)

Reading the score is intuitive. A composite of 70 or higher means the fund is large, inexpensive, has delivered, and pays something. A score below 30 means at least two of those four legs are missing. The verdict column wraps the score in an IF ladder that prints "Strong", "Solid", "Watch", or "Weak", which is the kind of label that survives a quick share to a colleague.

This is one of those analyses that is technically possible in Google Sheets alone, except that without FundXLS you have to type the expense ratio, AUM, and yield by hand from the ETF sponsor's web page. With the add-on installed those four numbers are formulas, so the score updates when the underlying data updates.

ETF Data in Google Sheets: The MarketXLS Google Sheets Add-On

The bridge that makes all of this work inside Google Sheets is the MarketXLS Google Sheets add-on. Once installed and authenticated against your MarketXLS account, the same family of functions you would type into Excel desktop becomes available in any Google Sheets workbook you own. That includes QM_Last, FundExpenseRatio, FundNetAssets, FundHoldings, Beta, DividendYield, and the rest of the 1,100-plus function library that you can browse on the Excel function reference.

A few behaviors are worth knowing before you build a heavy dashboard:

• Google Sheets caches results aggressively. If a function returns a stale value, force a recalculation by editing and re-entering the cell, or by toggling a refresh helper cell that every formula references.
• Spill functions like FundHoldings(A2) and QM_GetHistory(A2) flow downward and to the right. Reserve clear space below them so the spill is not blocked.
• For Excel desktop you have access to streaming functions like Stream_Last("SPY"). Google Sheets does not stream ticks; the polling cadence is set by Sheets itself.
• Sheet-to-sheet references (='Main Dashboard'!G13) behave the same way they do in Excel, which keeps the allocation builder and the asset class rollup portable across the two platforms.

If your workflow is entirely cloud-first, the Google Sheets add-on is the right choice. If you mix desktop and cloud, the same MarketXLS account works in both places and the formulas are interchangeable.

ETF Data in Google Sheets: Holdings, Overlap, and the Drilldown Sheet

For ETF data the single most valuable thing you can pull, beyond AUM and expense ratio, is the live top holdings spill. The reason is that the moment you start combining two or three funds in a portfolio, you start double-counting names. SPY and QQQ share Apple, Microsoft, NVIDIA, Amazon, Meta, and Alphabet at non-trivial weights. Adding both funds to an account is not as diversifying as the ticker list suggests, and a top-of-portfolio holdings overlap check is the fastest sanity check you can run.

In the workbook the Holdings Drilldown sheet works like this:

B4 = SPY              (input cell, yellow)
B5 = QQQ              (input cell, yellow)
B6 = =FundFamily(B4)
B7 = =FundInceptionDate(B4)
B8 = =FundNetAssets(B4)
B9 = =FundExpenseRatio(B4)

A12 = =FundHoldings(B4)   // spills the SPY top holdings
A25 = =FundHoldings(B5)   // spills the QQQ top holdings

Once both spills are in place, you can compare them. Inside Google Sheets the cleanest way is an XLOOKUP from the ticker column of one spill against the other, returning the weight if matched and 0 if not, then summing the lower of the two weights row by row to produce an overlap score in percent. The sample version of the workbook ships with the overlap pre-built using static snapshots of SPY and QQQ holdings so you can see the structure before you type a single formula yourself.

Used this way, the Holdings Drilldown becomes the answer to the question "do these two funds give me real diversification or am I just paying two expense ratios for the same megacap basket?" That question is impossible to answer in Google Sheets without the FundXLS holdings spill.

ETF Data in Google Sheets: Allocation Builder With Live Yield and Fees

The Allocation Builder sheet turns the watchlist into three sized portfolios. The portfolio size is a single input cell that the user changes, and the rest of the sheet references it. Three models ship in the workbook:

• Conservative: 45% bonds and gold, around 30% defensive equity, around 25% growth and international. Built for capital preservation.
• Balanced: 60/30/10 equity, bond, alternative. Diversified across factors and regions.
• Aggressive: roughly 95% equity tilt with growth, small caps, and emerging markets. Highest expected volatility.

Each row in a model uses the same pattern:

A: Model name
B: Ticker
C: Name (looked up)
D: Weight % (typed; sums to the model's stated weight)
E: =$B$4*D7/100             // dollar allocation
F: ='Main Dashboard'!G13    // live yield from the dashboard row
G: =E7*F7/100               // projected annual income
H: ='Main Dashboard'!F13    // live expense ratio from the dashboard
I: =E7*H7/100               // annual fund fee in dollars

The model totals row at the bottom uses SUM on the dollar columns and a weighted average on the yield and expense columns. With live formulas in place, you change a single dashboard input ("portfolio size") and every model's projected annual income, total fund fees, and dollar allocation update in real time. The same workbook in a static Google Sheets file would require manual entry on three to four columns per model and would silently go stale.

ETF Data in Google Sheets: Asset Class Rollup

The final analytical sheet is an asset class rollup using AVERAGEIFS against the asset class column on the dashboard. The buckets are Equity, Sector, International, Bond, and Commodity, and the table averages expense ratio, yield, YTD return, 1-year return, beta, and the Cost-Quality Score within each bucket.

=COUNTIF('Main Dashboard'!$C$13:$C$37, A5)
=IFERROR(AVERAGEIFS('Main Dashboard'!$F$13:$F$37, 'Main Dashboard'!$C$13:$C$37, A5), 0)
=IFERROR(AVERAGEIFS('Main Dashboard'!$G$13:$G$37, 'Main Dashboard'!$C$13:$C$37, A5), 0)

Reading the asset class rollup is a top-down exercise. Broad equity funds usually have the lowest expense ratios in the table. Sector ETFs cluster in the 0.10 to 0.40% expense band and can carry higher single-bucket volatility. International ETFs trade off geographic diversification for currency volatility. Bond ETFs anchor yield but long-duration ones swing with rate expectations. Commodity ETFs like GLD often act as a portfolio diversifier when stocks and bonds correlate.

None of this analysis is possible inside a GOOGLEFINANCE-only sheet. Every aggregation depends on the expense ratio and yield columns being live numbers, and those columns are MarketXLS / FundXLS only.

ETF Data in Google Sheets: Verified Formula Reference

Every formula listed below was verified against the live MarketXLS function catalog before publication. Where a function name is similar to one that looks plausible but does not exist (for example "ETFExpense" or "SMA"), the correct name is shown.

Reading list: if you are coming from Excel and want a refresher on which Google Sheets behaviors differ, the MarketXLS Excel function reference is the catalog the FundXLS family lives inside, and the ETF research hub covers the broader product surface that the Google Sheets add-on connects to.

Download the Templates

Download the templates:

• - Pre-filled with snapshot data so you can see what the dashboard looks like before you connect MarketXLS or the Google Sheets add-on.
• - Live formulas in every data cell, ready to refresh once the MarketXLS Google Sheets add-on or Excel desktop is connected.

Both files are built in Excel for portability. The exact same formulas work inside Google Sheets via the MarketXLS Google Sheets add-on. Open the file in Sheets, allow the formulas to recalculate, and the watchlist, holdings, allocations, and rollup all rehydrate with live data.

FAQ: ETF Data in Google Sheets

Can GOOGLEFINANCE return ETF expense ratios or AUM?

No. GOOGLEFINANCE exposes about a dozen attributes for stocks and ETFs, all centered on price, volume, and a handful of basic fundamentals. ETF AUM (net assets) and expense ratios are not in the list. For those you need FundXLS / MarketXLS formulas like =FundNetAssets("SPY") and =FundExpenseRatio("SPY").

How do I pull the top holdings of an ETF into Google Sheets?

Use the MarketXLS Google Sheets add-on and call =FundHoldings("SPY"). The function returns the top holdings as a spill array, with ticker, name, and weight columns. Make sure the cells below the formula are empty so the spill has room.

Does the MarketXLS Google Sheets add-on require Excel?

No. The Google Sheets add-on connects directly to your MarketXLS account and runs natively inside Sheets. If you also use Excel desktop, the same MarketXLS account works there, and the formulas are identical, which makes moving a workbook between the two platforms straightforward.

Will the formulas refresh automatically in Google Sheets?

Google Sheets recalculates spreadsheet formulas when inputs change and on a polling cadence that Sheets itself controls. For ETF data that does not move tick by tick (expense ratio, AUM, inception date, fund family) the cadence is plenty. For prices the values update on the standard Sheets refresh; for live tick streaming you would use the Excel desktop side of MarketXLS with Stream_Last.

How do I check if two ETFs overlap in their holdings?

Pull =FundHoldings(ETF1) and =FundHoldings(ETF2) into two spill ranges. Join them on ticker using XLOOKUP or FILTER, take the minimum weight of each shared ticker, and sum those minimums. The result is the percentage of each portfolio that is duplicated across the two funds. The downloadable workbook ships with this overlap pre-built for SPY and QQQ so you can study the structure.

Is this enough data to do real ETF research in Google Sheets?

The 1,100-plus MarketXLS functions, including the FundXLS family, cover the data points most advisors and self-directed investors reach for: price, AUM, expense ratio, holdings, yield, return, beta, volatility, sector, inception date, fund family, option chains, and historical pricing. For most ETF research workflows that is sufficient inside Google Sheets. Areas where you might still want Excel desktop are streaming prices and very large historical data pulls.

The Bottom Line

ETF data in Google Sheets is a workable workflow if you are willing to limit yourself to price and a couple of basic attributes. GOOGLEFINANCE is genuinely good at the things it covers. The friction shows up the moment your analysis crosses into ETF-specific territory: AUM, expense ratio, top holdings, inception date, option chains. Those data points are the entire reason FundXLS exists, and the MarketXLS Google Sheets add-on is how you get them into a Sheets workbook without copy-paste.

The pattern that produces a working dashboard is simple. Keep one row per ticker, use QM_Last and the Fund* family for the ETF-specific columns, layer GOOGLEFINANCE alongside as a visible reminder of where the native ceiling is, and build the secondary sheets (holdings, allocation, rollup) on references back to the dashboard so a single input change cascades through the file. The downloadable workbook is the starting point. Pricing and account options live on the MarketXLS pricing page. To see the Google Sheets add-on and the FundXLS function family in action against your own watchlist, book a demo and we will walk through the workbook live.

This template is educational only and not a recommendation to buy or sell any security. Past performance does not guarantee future results.