If you want a number you can log every week and compare, you need a check that is repeatable. The YouTube Data API gives you one, with two catches that most tutorials skip: search is the most expensive call in the whole API, and the results are tied to a market. This post builds a small rank tracker that respects both. About 90 lines of Python, requests plus the standard library's sqlite3.

The quota math comes first

Every Google Cloud project gets a default of 10,000 quota units per day for the YouTube Data API, and the counter resets at midnight Pacific Time. Calls are not priced equally:

So one search page costs as much as one hundred channel lookups. With the default quota you get 100 search requests a day. That sounds like plenty until you multiply it out:

• 10 keywords
• 3 markets (for example US English, Pakistan Urdu, India Hindi)
• 2 pages deep (top 100) instead of 1 (top 50)

That is 60 requests, or 6,000 units, for a single run. Run it daily and you have almost nothing left for anything else. The design decision that follows: track the top 50 only, and run weekly. Ranking positions don't move enough day to day to justify the cost, and a video sitting at position 70 needs a different keyword, not a daily log of how stuck it is.

What "rank" means in this tracker

Before writing code, pin down the definition, because it decides the parameters:

• Query: the exact keyword, sent as q.
• Type: videos only (type=video). The real search page mixes in Shorts shelves, channels and playlists, which push results down the screen without changing the order among videos. We only care about the order among videos.
• Market: regionCode (a two-letter country code like PK) plus relevanceLanguage (a two-letter language code like ur). Leave either out and you are measuring a different market.
• Order: relevance, which is the API default.
• Depth: maxResults=50, the maximum per page.

A rank is then "position of my video in the un-personalised relevance order for this keyword, this country and this language, within the top 50". Anything stated more precisely than that is a guess.

Step 1: Setup

Create a project in the Google Cloud console, enable YouTube Data API v3, and create an API key. Then:

pip install requests
export YT_API_KEY="your-key-here"

Step 2: Resolve the channel once

We match results by channel ID, so the tracker catches any of your videos ranking for a term, not only the one you expected. Handles are what people know, so resolve the handle once and cache it. channels.list accepts a forHandle parameter and costs 1 unit.

import os, sqlite3, datetime, requests

API = "https://www.googleapis.com/youtube/v3"
KEY = os.environ["YT_API_KEY"]

def channel_id_for(handle: str) -> str:
    r = requests.get(f"{API}/channels", params={
        "part": "id",
        "forHandle": handle.lstrip("@"),
        "key": KEY,
    }, timeout=20)
    r.raise_for_status()
    items = r.json().get("items", [])
    if not items:
        raise ValueError(f"No channel found for {handle}")
    return items[0]["id"]

Step 3: One search, one market

The fields parameter trims the response to what we need. It does not reduce the quota cost (that stays at 100), but it makes responses smaller and easier to store.

def search_top50(keyword: str, region: str, lang: str) -> list[dict]:
    r = requests.get(f"{API}/search", params={
        "part": "snippet",
        "q": keyword,
        "type": "video",
        "regionCode": region,
        "relevanceLanguage": lang,
        "maxResults": 50,
        "fields": "items(id/videoId,snippet/channelId,snippet/title)",
        "key": KEY,
    }, timeout=20)
    r.raise_for_status()
    return [
        {
            "position": i + 1,
            "video_id": it["id"]["videoId"],
            "channel_id": it["snippet"]["channelId"],
            "title": it["snippet"]["title"],
        }
        for i, it in enumerate(r.json().get("items", []))
    ]

Step 4: A budget guard

The worst failure mode for a tracker is silently burning the whole day's quota halfway through, then failing every other script on the same project. A tiny guard fixes that: estimate the cost before running and refuse if it is over budget.

SEARCH_COST = 100

def plan_cost(keywords, markets, pages=1) -> int:
    return len(keywords) * len(markets) * pages * SEARCH_COST + 1

def check_budget(cost: int, budget: int = 5000):
    if cost > budget:
        raise SystemExit(
            f"Planned run costs {cost} units, budget is {budget}. "
            "Cut keywords or markets."
        )

The budget defaults to half the daily quota so other jobs on the project still have room.

Step 5: Store every observation

A rank tracker is just a table of observations over time. SQLite is enough.

def db():
    con = sqlite3.connect("ranks.db")
    con.execute("""
        CREATE TABLE IF NOT EXISTS ranks (
            checked_on TEXT,
            keyword    TEXT,
            region     TEXT,
            lang       TEXT,
            position   INTEGER,   -- NULL means not in top 50
            video_id   TEXT,
            title      TEXT
        )""")
    return con

Storing NULL for "not found" matters. If you skip the row instead, you cannot tell the difference between "dropped out" and "never checked".

Step 6: The run

KEYWORDS = ["youtube rpm pakistan", "faceless channel ideas", "outlier score"]
MARKETS = [("US", "en"), ("PK", "ur"), ("IN", "hi")]
HANDLE = "@yourchannel"

def run():
    cost = plan_cost(KEYWORDS, MARKETS)
    check_budget(cost)
    me = channel_id_for(HANDLE)
    con = db()
    today = datetime.date.today().isoformat()

    for kw in KEYWORDS:
        for region, lang in MARKETS:
            results = search_top50(kw, region, lang)
            mine = [x for x in results if x["channel_id"] == me]
            if mine:
                best = mine[0]
                con.execute("INSERT INTO ranks VALUES (?,?,?,?,?,?,?)",
                    (today, kw, region, lang, best["position"],
                     best["video_id"], best["title"]))
                print(f"{kw:28} {region}/{lang}  #{best['position']:<3} {best['title'][:40]}")
            else:
                con.execute("INSERT INTO ranks VALUES (?,?,?,?,NULL,NULL,NULL)",
                    (today, kw, region, lang))
                print(f"{kw:28} {region}/{lang}  >50")
    con.commit()
    print(f"Used about {cost} units.")

if __name__ == "__main__":
    run()

Three keywords across three markets costs 901 units. Run it every Monday from cron:

0 6 * * 1 cd /home/me/rank-tracker && /usr/bin/python3 tracker.py >> run.log 2>&1

Step 7: Ask the data a useful question

Raw positions are less interesting than movement. This query compares each keyword and market with its previous check:

SELECT keyword, region, lang, checked_on, position,
       LAG(position) OVER (
         PARTITION BY keyword, region, lang ORDER BY checked_on
       ) AS previous
FROM ranks
ORDER BY keyword, region, checked_on DESC;

Window functions need SQLite 3.25 or later, which almost every current Python install already includes. Positive previous - position means the video moved up.

Mistakes worth avoiding

Checking one market and assuming it is global. Leave out relevanceLanguage and the API picks a language for you. A Urdu-language video can rank well for a Roman Urdu query in Pakistan and not at all for the same query with hi in India. Both results are true, which is exactly why the market belongs in every row you store.

Paging deeper to "find" the video. It is tempting to request page 2 and page 3 with pageToken when a video is missing. Each page is another 100 units, and a video at position 120 is not going to be helped by knowing that precisely. Treat "not in top 50" as the signal: the keyword is too broad, and a narrower phrase is the fix.

Comparing tracker numbers with the phone. They will disagree. The tracker shows the un-personalised relevance order for one market; the phone shows one viewer's personalised feed. Neither is wrong. They answer different questions, and only the tracker's answer is repeatable next week.

Matching by video ID only. Channels often have two or three videos on the same topic. Matching on channel ID shows you when an older upload is outranking the new one you are trying to push, and that changes what you should optimise.

Where the numbers come from on the creator side

The API tells you where you rank. It does not tell you which keywords are worth tracking. For that, YouTube Studio already has the best list: Analytics, then Reach, then the "Traffic source: YouTube Search" card shows the exact terms that sent you viewers. Feed those into KEYWORDS instead of guessing.

If you want the full picture of the three ways to check a ranking (Studio's search terms report, a signed-out manual search, and an API based check) and why they never agree, this walkthrough on how to check where your YouTube video ranks compares them side by side, including a weekly routine and the ranking factors YouTube itself lists.

Ideas to extend it

• Add context, cheaply. One videos.list call with up to 50 IDs costs 1 unit and returns view counts and publish dates for every result. That tells you whether the videos above you are fresh or years old, which changes how beatable they are.
• Track competitors. Store all 50 results, not just yours, and you can see which channels own a keyword over time.
• Alert on drops. Wrap the SQL above in a check that posts to a webhook when a keyword falls more than 10 positions in one week.

The whole thing fits in one file, costs nothing to run, and replaces the scroll-and-guess habit with a log you can actually reason about.

Disclosure: I work on TubeMind, a YouTube analytics and research tool. The code in this post is standalone and does not need it.