# iShares ETF Holdings Tracker: Daily Changes (`thatmike1/ishares-holdings-changes`) Actor Full holdings of iShares US funds with up to 5,000 rows from their public CSV, with count and date reconciliation and changes since the last accepted snapshot. - **URL**: https://apify.com/thatmike1/ishares-holdings-changes.md - **Developed by:** [Michal PΕ‘enčík](https://apify.com/thatmike1) (community) - **Categories:** Business, Automation - **Security:** Limited permissions - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.00005 / actor start This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## iShares ETF Holdings Tracker: Daily Changes Get the full published holdings of iShares US funds with up to **5,000 CSV rows**, straight from ishares.com: every asset class (equities, bonds, cash, money market, futures, FX), every original column, exact decimals and the issuer's holdings date. Each fund check reconciles the file against the official holdings count printed on the same fund page, and with a watch name it reports which disclosed records were added, dropped or changed since the last accepted check. You pay one flat fee per accepted fund check. Larger funds such as AGG return a free `source_limit` diagnostic: the first 5,000 factual rows and raw CSV are retained, but no complete fund check is delivered or billed and watch state is not advanced. The normal start fee still applies. Use it to keep a dated, auditable copy of a fund's portfolio, to get notified when weights or quantities move, or to feed holdings into your own analysis without scraping or cleaning the CSV yourself. ### Input ```json { "funds": [ { "productUrl": "https://www.ishares.com/us/products/239726/ishares-core-sp-500-etf" }, { "productUrl": "https://www.ishares.com/us/products/239454/ishares-20%20-year-treasury-bond-etf" } ], "watchName": "my-funds", "maxChecks": 20, "minWeightDeltaPp": "0.05", "maxAgeCalendarDays": 7, "requestIntervalMs": 2000 } ``` | Field | What it does | | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `funds` | 1 to 100 iShares US product pages (`https://www.ishares.com/us/products//`), copied from the fund's page. Funds with up to 5,000 CSV rows are supported, not only the examples. Duplicates run once. | | `watchName` | Empty for a one-off check. Set a name to remember the last accepted snapshot of each fund and report changes on the next run with the same name. Run one watch at a time. | | `maxChecks` | Distinct funds attempted per run, 1 to 20 (default 20). The rest get a free `not_attempted_cap` status. | | `minWeightDeltaPp` | Weight moves of at least this many percentage points count as notable in the change counters (default 0.05). Every raw change is still in the diff. | | `maxAgeCalendarDays` | A holdings file older than this many days gets a free `source_stale` status (default 7). | | `requestIntervalMs` | Pause between requests to ishares.com, 2,000 to 10,000 ms (default 2,000). One request at a time. | The Console prefills IVV and TLT for a one-off check. API callers must supply `funds` explicitly; missing or empty funds are rejected before any source request. ### Output **Default dataset: one item per accepted fund check.** Only checks that passed every validation land here, and each one is billed. An item (abbreviated) looks like this: ```json { "type": "fund_check", "checkId": "aBcD1234-239454", "status": "checked", "productId": "239454", "fundName": "iShares 20+ Year Treasury Bond ETF", "ticker": "TLT", "holdingsAsOf": "2026-10-15", "observedAt": "2026-10-16T22:06:35.749Z", "countAsOf": "2026-10-15", "officialCount": 47, "receivedRows": 49, "receivedByClass": { "Fixed Income": 47, "Money Market": 1, "Cash": 1 }, "countIncludedRows": 47, "countExcludedRows": 2, "coverage": { "receivedCsvFullyParsed": true, "receivedRowsPersisted": true, "countReconciled": true }, "positionDatasetName": "ishares-aBcD1234-positions", "positionItemOffset": 0, "positionItemCount": 1, "positionCount": 49, "snapshotKey": "snapshot-aBcD1234-239454", "diffKey": null, "snapshotHash": "36b10d70...", "previous": null, "comparison": { "mode": "untracked", "counters": null } } ``` `status` is one of `checked` (no watch), `baseline` (first check of a watch), `migration_baseline` (a new parser version restarted the watch), `unchanged` or `changed`. **Positions dataset (free).** Every safely received holding, from accepted and diagnostic checks alike, in a named dataset `ishares--positions`. Items are chunks of up to 256 positions; the fund check gives the offset and count of its chunks. Each position keeps the original row (`rawFields`), exact decimals with their raw text (`numericFields`), `quantity` (issuer-reported shares, units or contracts), `parValue` (kept separate, never treated as shares), source identifiers (CUSIP, ISIN, SEDOL as published, leading zeros and `-` placeholders included), a `positionKey` and the issuer's date. Each chunk's `chunkSha256` is the SHA-256 of its `positions` as JSON with every object's keys sorted and no whitespace: the dataset API can return keys in another order than the CSV's columns (it moves names containing a dot, such as `Mod. Duration`, to the end), so verify against sorted keys. **Status dataset (free).** One final status per fund and per duplicate or invalid input in `ishares--status`, with every issue found, the official count evidence, source URLs, hashes, byte sizes and timings. **Key-value store (free).** `SUMMARY` lists every input entry with its status and the IDs and API URLs of all three datasets. `snapshot--` holds the full normalized snapshot of an accepted check and `diff--` the record-level changes of a `changed` check. A file that could not be parsed is kept as `raw---csv`. `` is a short id of the container start, so a run that Apify migrates never overwrites a record an earlier start of it wrote; each fund check and status row names its own keys. \#Malformed CSV captures retain the exact received bytes. A non-UTF-8 capture is stored as a binary record; its byte hash still matches the source evidence. ### Statuses that are not billed Problems are reported as statuses, never as empty successes: `download_link_missing`, `download_link_ambiguous`, `source_http_error`, `source_challenge`, `source_timeout`, `source_limit`, `csv_parse_error`, `schema_unrecognized`, `fund_identity_mismatch`, `holdings_date_missing`, `holdings_date_invalid`, `numeric_invalid`, `official_count_missing`, `official_count_ambiguous`, `official_count_invalid`, `count_definition_unsupported`, `count_filter_uncertain`, `count_date_mismatch`, `count_mismatch`, `identifier_unsupported`, `identity_ambiguous`, `source_date_future`, `source_stale`, `source_date_regressed`, `state_invalid`, `state_overlap`, `delivery_failed`, `budget_exhausted`, plus `input_invalid`, `duplicate` and the `not_attempted_*` statuses for funds the run did not reach. The holdings received for a diagnostic check are still stored in the positions dataset. `state_write_failed` is the one billed exception: the check was delivered, but the watch kept its previous baseline. #### What the count check proves, and what it does not iShares prints a holdings count that excludes cash and derivatives. A check is accepted only when the CSV's Equity and Fixed Income rows match that count and both carry the same date. Cash, money market, collateral, futures and FX rows are returned but cannot be verified against that count, and an equal-count swap of two securities would not show up in it. The count comes from the same issuer, so it is a consistency check, not an independent audit. #### What a change means Changes are differences between two published files: `record_newly_disclosed`, `record_no_longer_disclosed` and `record_values_changed` with exact before, after and delta values. They are not trades. A renamed security or a new identifier shows up as one record dropped and one added. Activity between two checks is not reconstructed, and a gap after a failed check is named, not filled in. `comparison.failureGap` reports the recorded failure count and last failure since the previous accepted checkpoint, independently of calendar-day distance. Failure markers live separately from accepted state; an unavailable watch store can prevent recording a marker, which is reported in SUMMARY. Checkpoints use immutable, ordered generations and a fenced lookup mirror. A rejected candidate cannot replace a later accepted generation even if its storage write completes after a timeout. After both delivery and the candidate are verified, an unacknowledged immutable publication is reported in SUMMARY and may repeat the comparison. All checkpoint fields, including record keys, carry an integrity hash; corrupted v2 records require manual recovery. Fully validated older v1 records get an explicit migration baseline; their old record identities are never compared or copied. Failure markers are scoped to their accepted checkpoint. ### Pricing Pay per event: - **Actor start: $0.00005** per run. - **Fund check: $0.005** per accepted fund check stored in the default dataset, including baseline and unchanged checks. Positions, statuses, snapshots, diffs and SUMMARY are free. One fund costs $0.00505 per run, eight funds $0.04005, and a daily single-fund watch about $0.15 a month. A run where every fund fails costs only the start event. Platform usage is included in these prices. ### Limits - iShares US product pages only (`www.ishares.com/us/products/...`). Other issuers, other iShares regional sites, history and backfill are out of scope. - Up to 20 funds per run, one at a time, at least 2 seconds between requests. Source and storage work share a 90-second budget per fund and stop before 290 seconds, keeping the final 10 seconds for statuses and SUMMARY; funds it did not reach get a free `not_attempted_deadline` status. - Per fund: CSV up to 16 MiB, product page up to 8 MiB, 5,000 rows (including cash and derivatives), snapshot and diff bundles up to 32 MiB. CSV allocation also stops at 128 fields per record, 8,192 characters per cell, 32,768 characters per record, one million total cells, and 100,128 total records including blanks. Larger files get `source_limit` with a bounded partial prefix. JSON parsing caps nesting at 64 and nodes at one million; product page facts, attributes and JSON-LD have additional allocation bounds. Diagnostics are shortened to fit the 256 KiB SUMMARY. Numeric cells support at most 128 source characters. Canonical hashing processes at most 32 MiB of expanded row JSON, so long column names cannot amplify a small download into unbounded work. - A 403 or challenge page from ishares.com stops further requests for the run. The actor uses no proxy, browser, cookies or other workaround. - The positions and status datasets are named datasets, so they stay in your account until you delete them. - Watch journals and leases are retained in the named watch store. Each prefix is limited to 10,000 records; archive an old watch and use a new watch name when that limit is reached. No automatic deletion is performed. - Run one watch at a time. A second run of the same watch while one is in progress gets `state_overlap`. ### Source and data notes Data comes from BlackRock's public iShares US product pages and the `latest-holdings.csv` file each page links to, fetched without login, key or proxy. BlackRock publishes and controls this data. Public access does not grant a licence to redistribute it; check BlackRock's terms for your use. Holdings are as the issuer publishes them, usually as of the previous business day, and may be revised. ### Support Open an issue on the actor's Issues tab with the run ID and the fund URL. To find a fund's URL, open the fund from [the iShares US product list](https://www.ishares.com/us/products/etf-investments) and copy the address. # Actor input Schema ## `funds` (type: `array`): 1 to 100 iShares US product pages, each as {"productUrl": "https://www.ishares.com/us/products//"}. Copy the URL from the fund's page on ishares.com. The product ID in the URL identifies the fund; duplicates are checked once. Complete checks support up to 5,000 CSV rows including cash and derivatives. Larger funds return a free source_limit diagnostic and retain the raw CSV and a bounded prefix without advancing watch state. ## `watchName` (type: `string`): Leave empty for a one-off check. Set a name (letters, digits, \_ or -, up to 80) to keep the last accepted snapshot per fund and report source-record changes on the next run with the same name. Run one watch at a time. ## `maxChecks` (type: `integer`): Distinct funds attempted in this run (1-20). Funds beyond it get a free not_attempted_cap status. ## `minWeightDeltaPp` (type: `string`): Only weight changes of at least this many percentage points count as notable in the change counters (0-100). All raw changes stay in the diff bundle; holdings and snapshot hashes are never filtered. ## `maxAgeCalendarDays` (type: `integer`): A holdings file dated more than this many days before the UTC run day gets a free source_stale status (0-30). ## `requestIntervalMs` (type: `integer`): Idle time between one ishares.com response and the next request (2000-10000). One request at a time. ## Actor input object example ```json { "funds": [ { "productUrl": "https://www.ishares.com/us/products/239726/ishares-core-sp-500-etf" }, { "productUrl": "https://www.ishares.com/us/products/239454/ishares-20%20-year-treasury-bond-etf" } ], "maxChecks": 20, "minWeightDeltaPp": "0.05", "maxAgeCalendarDays": 7, "requestIntervalMs": 2000 } ``` # Actor output Schema ## `fundChecks` (type: `string`): No description ## `summary` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "funds": [ { "productUrl": "https://www.ishares.com/us/products/239726/ishares-core-sp-500-etf" }, { "productUrl": "https://www.ishares.com/us/products/239454/ishares-20%20-year-treasury-bond-etf" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("thatmike1/ishares-holdings-changes").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`πŸ’Ύ Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // πŸ“š Want to learn more πŸ“–? Go to β†’ https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "funds": [ { "productUrl": "https://www.ishares.com/us/products/239726/ishares-core-sp-500-etf" }, { "productUrl": "https://www.ishares.com/us/products/239454/ishares-20%20-year-treasury-bond-etf" }, ] } # Run the Actor and wait for it to finish run = client.actor("thatmike1/ishares-holdings-changes").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"πŸ’Ύ Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # πŸ“š Want to learn more πŸ“–? Go to β†’ https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "funds": [ { "productUrl": "https://www.ishares.com/us/products/239726/ishares-core-sp-500-etf" }, { "productUrl": "https://www.ishares.com/us/products/239454/ishares-20%20-year-treasury-bond-etf" } ] }' | apify call thatmike1/ishares-holdings-changes --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,thatmike1/ishares-holdings-changes" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/bwbmyezy0ramFjnrU/builds/h0rODKjLOwPqhTKlE/openapi.json