# Taiwan ADR Premium Tracker (`quiet_dictionary/taiwan-adr-premium-tracker`) Actor

Track real-time premium and discount between Taiwan ADRs (NYSE/NASDAQ) and their underlying TWSE shares with FX normalization.

- **URL**: https://apify.com/quiet\_dictionary/taiwan-adr-premium-tracker.md
- **Developed by:** [Steven C](https://apify.com/quiet_dictionary) (community)
- **Categories:** Other, Automation, Open source
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / adr data fetched

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Taiwan ADR Premium Tracker

Track real-time price premiums and discounts between Taiwan ADRs listed on NYSE/NASDAQ and their underlying Taiwan Stock Exchange (TWSE) shares — with full USD/TWD currency normalization.

### What This Actor Does

Taiwan has more cross-listed ADRs than almost any other Asian market. When a stock trades on both NYSE and TWSE simultaneously, the price difference (the "ADR premium") can be significant — TSMC's ADR premium hit a **25% historic high in 2025**, representing a major signal for cross-market traders, fund managers, and quantitative researchers.

This actor fetches live prices for all major Taiwan ADRs and computes the exact premium or discount in USD terms, accounting for:

- **ADS ratio** — e.g. 1 TSM ADR = 5 shares of 2330.TW
- **FX normalization** — USD/TWD exchange rate applied automatically
- **6 Taiwan ADRs** tracked: TSM, UMC, CHT, ASX, HIMX, IMOS

#### Covered Ticker Pairs

| ADR (NYSE/NASDAQ) | TW Share (TWSE) | ADS Ratio | Company |
|---|---|---|---|
| TSM | 2330.TW | 1:5 | Taiwan Semiconductor Mfg (TSMC) |
| UMC | 2303.TW | 1:2 | United Microelectronics |
| CHT | 2412.TW | 1:10 | Chunghwa Telecom |
| ASX | 3711.TW | 1:1 | ASE Technology Holding |
| HIMX | 3324.TW | 1:2 | Himax Technologies |
| IMOS | 8150.TW | 1:20 | ChipMOS Technologies |

### Tutorial — How to Run

1. Open the actor on Apify Store and click **Try for free**.
2. In the Input tab, set the `tickers` field to the ADR symbols you want to track (or leave blank for all six).
3. Click **Start** and wait ~10–20 seconds for prices to be fetched.
4. View results in the **Output** tab — each run produces one dataset row with all premiums.

**Example input:**
```json
{
  "tickers": ["TSM", "UMC", "CHT"]
}
````

**Example output:**

```json
{
  "scraped_at": "2026-03-27T10:00:00Z",
  "fx_rate_usd_twd": 32.45,
  "tickers_requested": 3,
  "tickers_computed": 3,
  "results": [
    {
      "adr_ticker": "TSM",
      "tw_ticker": "2330.TW",
      "company_name": "Taiwan Semiconductor Mfg (TSMC)",
      "exchange": "NYSE",
      "adr_ratio": 5,
      "adr_price_usd": 175.50,
      "tw_price_twd": 1050.0,
      "tw_equivalent_usd": 161.77,
      "premium_pct": 8.49,
      "premium_label": "ADR at 8.49% premium to TW shares",
      "error": null
    }
  ],
  "errors": []
}
```

### Pricing

**Flat $0.05 per run**, regardless of how many tickers you track. Track all 6 ADRs or just 1 — same price.

Typical usage scenarios:

| Use case | Runs/month | Monthly cost |
|---|---|---|
| Daily monitoring | 30 | $1.50 |
| Hourly alerts (market hours) | 150 | $7.50 |
| Research / backfill | 5 | $0.25 |

Prices shown are what you are charged. No hidden per-ticker or per-result fees.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `tickers` | array | All 6 | List of ADR symbols to track. Supported: TSM, UMC, CHT, ASX, HIMX, IMOS |

### Output Fields

Each run produces one dataset row:

| Field | Type | Description |
|---|---|---|
| `scraped_at` | string | UTC timestamp of the fetch (ISO 8601) |
| `fx_rate_usd_twd` | number | USD/TWD exchange rate at time of fetch |
| `tickers_requested` | integer | Number of ADRs requested |
| `tickers_computed` | integer | Number of premiums successfully computed |
| `results` | array | Per-ticker results (see below) |
| `errors` | array | Tickers that failed with reason |

**Per-ticker result fields:**

| Field | Type | Description |
|---|---|---|
| `adr_ticker` | string | ADR symbol (e.g. TSM) |
| `tw_ticker` | string | TWSE symbol (e.g. 2330.TW) |
| `company_name` | string | Full company name |
| `exchange` | string | NYSE or NASDAQ |
| `adr_ratio` | integer | Number of TW shares per 1 ADR |
| `adr_price_usd` | number | Live ADR price in USD |
| `tw_price_twd` | number | Live TW share price in TWD |
| `tw_equivalent_usd` | number | USD cost of TW shares equivalent to 1 ADR |
| `premium_pct` | number | Premium (+) or discount (-) percentage |
| `premium_label` | string | Human-readable summary |
| `error` | string|null | Error reason if computation failed, null otherwise |

### Other Actors by This Developer

- **[Taiwan Gold Card Stats Tracker](https://apify.com/quiet_dictionary/taiwan-gold-card-stats-tracker)** — Monthly Employment Gold Card issuance statistics from Taiwan's National Development Council.

### FAQ

**Why might a premium or discount exist?**
Cross-listed shares trade in different markets with different hours, liquidity, and investor bases. Foreign investor demand, market sentiment differences between NYSE and TWSE, and capital flow restrictions can all cause persistent premiums. The TSMC ADR premium is especially well-studied.

**Are prices real-time?**
Prices are sourced from Yahoo Finance via yfinance. During market hours, prices are live or near-live. Outside market hours, the most recent closing prices are used. TWSE closes at 13:30 TST (UTC+8); NYSE closes at 16:00 EST (UTC-5).

**What if a price is unavailable?**
If any price cannot be fetched (delisted ticker, network issue, Yahoo Finance outage), the affected ticker row will have a non-null `error` field. Other tickers in the same run are not affected. You are still charged the flat $0.05 for the run.

**Which ADS ratios are used?**
Ratios are based on public SEC Form F-6 filings. Issuers can adjust ratios via tender offers — check the actor's CHANGELOG or the issuer's most recent 20-F if you suspect a ratio has changed.

**Can I schedule this to run automatically?**
Yes — use Apify's built-in scheduler to run the actor on any cron schedule. For daily monitoring, set it to run once per day after both TWSE and NYSE have closed for clean closing-price comparisons.

### Support

Open an issue on the actor's Issues tab for bugs or feature requests.

# Actor input Schema

## `tickers` (type: `array`):

List of Taiwan ADR ticker symbols to include. Supported: TSM, UMC, CHT, ASX, HIMX, IMOS. Leave blank to track all six.

## Actor input object example

```json
{
  "tickers": [
    "TSM",
    "UMC",
    "CHT",
    "ASX",
    "HIMX",
    "IMOS"
  ]
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "tickers": [
        "TSM",
        "UMC",
        "CHT",
        "ASX",
        "HIMX",
        "IMOS"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("quiet_dictionary/taiwan-adr-premium-tracker").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "tickers": [
        "TSM",
        "UMC",
        "CHT",
        "ASX",
        "HIMX",
        "IMOS",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("quiet_dictionary/taiwan-adr-premium-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "tickers": [
    "TSM",
    "UMC",
    "CHT",
    "ASX",
    "HIMX",
    "IMOS"
  ]
}' |
apify call quiet_dictionary/taiwan-adr-premium-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=quiet_dictionary/taiwan-adr-premium-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Taiwan ADR Premium Tracker",
        "description": "Track real-time premium and discount between Taiwan ADRs (NYSE/NASDAQ) and their underlying TWSE shares with FX normalization.",
        "version": "0.1",
        "x-build-id": "TwMGybN4ZHcXyLa3F"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/quiet_dictionary~taiwan-adr-premium-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-quiet_dictionary-taiwan-adr-premium-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/quiet_dictionary~taiwan-adr-premium-tracker/runs": {
            "post": {
                "operationId": "runs-sync-quiet_dictionary-taiwan-adr-premium-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/quiet_dictionary~taiwan-adr-premium-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-quiet_dictionary-taiwan-adr-premium-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "tickers": {
                        "title": "ADR tickers to track",
                        "type": "array",
                        "description": "List of Taiwan ADR ticker symbols to include. Supported: TSM, UMC, CHT, ASX, HIMX, IMOS. Leave blank to track all six.",
                        "default": [
                            "TSM",
                            "UMC",
                            "CHT",
                            "ASX",
                            "HIMX",
                            "IMOS"
                        ]
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```