How to Monitor ICO Coin Launches with Screenshots

To monitor ICO and token launches reliably, discover candidates in a calendar, verify each important date against official project and exchange announcements, and save timestamped screenshots alongside the source URLs. Treat calendars and alerts as leads: a screenshot records what a page displayed at a particular moment, but it does not prove that an offering is genuine, safe, or legally compliant.

This guide builds a repeatable monitoring record for developers and researchers. It covers discovery, evidence checks, browser-based captures, an automated Python workflow, alerts, troubleshooting, and ways to keep the record useful when dates change. For each observation, preserve the project, chain, sale stage, relevant dates, URLs, and capture time.

1. Find candidate launches

Start with the CoinMarketCap ICO calendar. Its calendar presents offerings by status and can show fields such as project, chain, stage, start and end dates, goal, ICO price, and launchpad. Use it to discover candidates and make an initial record; do not treat a calendar entry as project verification or an endorsement. The calendar changes over time. For example, its page showed 1,266 ended ICOs when captured on September 29, 2026; that is a live page count, not a fixed industry statistic.

Use the calendar to find a candidate, then preserve official date evidence with the capture time and source URL.

A calendar date may describe the start or end of a fundraising stage. It may not be the date a token is generated or begins trading. Keep those events distinct in your notes:

Sale start/end: when a fundraising or token-sale stage is scheduled to open or close.
TGE: the token generation event, where the project says the token will be generated or distributed.
First trading: the time a named exchange says trading is expected to begin.

CoinGecko’s preview-listing guidance calls for a clear TGE date and time supported by verifiable official announcements, and requests exchange details for the expected trading date. That makes it a useful evidence checklist even if you are not submitting a listing request. See CoinGecko’s preview-listing requirements.

2. Create a monitoring record

Keep one row per project and append an observation whenever a relevant field changes. Store the source URL with each screenshot rather than relying on a filename or a calendar page alone.

Field	What to record
Identity	Project name, token symbol, chain/network, and the exact project URL.
Sale details	Stage, scheduled start and end, funding goal, launchpad, and ICO price if provided.
Launch evidence	TGE date and time with timezone, expected first-trading date and time, named exchange, and links to official announcements.
Observation	Capture timestamp in UTC, page URL, image path, and a concise note describing what changed.
Confidence	Mark each date as calendar-reported, project-announced, or exchange-confirmed. Note missing or conflicting evidence.

Do not silently replace an old date. Keep the previous value, its observation time, and the new evidence. This makes schedule changes visible and helps distinguish a revised announcement from a data-entry error. A minimal CSV can start like this:

project,token,chain,stage,start_utc,end_utc,tge_utc,exchange,trade_utc,official_url,announcement_url,observed_utc,screenshot,note
Example,EXM,Ethereum,ICO,,,,,,,https://example.invalid,2026-09-29T12:00:00Z,captures/example-ico-20260929-1200-UTC.png,Initial calendar observation

The example URL is a placeholder. Replace it with a real official page before using the record. Keep timestamps in ISO 8601 UTC (the trailing Z means UTC); if a source announces a local time, record that original timezone as well as your normalized UTC value.

3. Verify the event and its source

Open the project’s own announcement. Navigate from the project’s established official site or social account. Record the announcement URL and its stated date, time, and timezone. A calendar entry that links to a third party is not itself an official project statement.
Check the exchange announcement. When a project says the token will trade, look for the exchange’s own notice and verify the token identity and trading start time. If the exchange or time is not confirmed, label it as unconfirmed rather than filling the gap with a guess.
Compare the TGE and trade times. These are related but distinct events. Preserve both when available, including the sources that support each.
Resolve conflicts explicitly. If the calendar, project, and exchange differ, retain each claim with its source and observation time. Do not pick the most convenient date without evidence.
Recheck near the event. A scheduled date can change. Capture a fresh observation when an official source updates, and again near a deadline if timing matters to your work.

If a token is preview-listed, CoinGecko says activation requires official links stating the exact date and time trading starts; its process also asks for verifiable links and exchange details. Retain these links and any relevant listing-request status, but do not infer approval or activation from a preview entry alone. See CoinGecko’s guidance.

4. Capture useful, timestamped screenshots

A useful evidence capture shows the relevant project name and date or stage, while retaining enough page context to identify what you viewed. Save the original image, the exact source URL, and the capture time together. For example, use a stable name such as project-stage-YYYYMMDD-HHMM-UTC.png, and record a short note such as “project announcement revised TGE from 14:00 to 16:00 UTC.”

Manual browser capture

Open the source page directly and confirm the address bar shows the expected domain.
Wait for the page to finish loading; expand any relevant announcement details or date disclosures.
Capture the page or a clear crop. Include browser context where practical, and avoid cropping away the source identity or the date’s surrounding wording.
Record the UTC capture time immediately. A filename timestamp is useful, but keep the source URL and timestamp in the log as well.
Save the original file and note what changed from the prior capture.

For a long page, use a full-page capture if it keeps the relevant content legible. For a short announcement, a focused capture may be clearer. A screenshot can document what a browser rendered, but it cannot independently authenticate the publisher, prove a token contract is safe, or establish legal compliance.

Automate repeated captures with Python and Playwright

For a small watchlist, a script can capture known URLs on a schedule. This example saves a full-page PNG and a JSON sidecar containing the URL and UTC timestamp. Install Playwright and its Chromium browser first (python -m pip install playwright, then python -m playwright install chromium). Save the code as capture_watchlist.py, replace the placeholder URL, then run python capture_watchlist.py.

import asyncio
import json
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlparse
from playwright.async_api import async_playwright

WATCHLIST = [
    {"project": "example-project", "url": "https://example.org/announcements"},
]
OUT = Path("captures")

async def main():
    OUT.mkdir(exist_ok=True)
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page(viewport={"width": 1440, "height": 1000},
                                      device_scale_factor=1)
        for item in WATCHLIST:
            observed = datetime.now(timezone.utc)
            stamp = observed.strftime("%Y%m%d-%H%M-UTC")
            safe_name = "".join(c if c.isalnum() or c in "-_" else "-"
                                for c in item["project"])
            try:
                response = await page.goto(item["url"], wait_until="domcontentloaded",
                                           timeout=45000)
                # Give client-rendered text a short chance to appear.
                await page.wait_for_timeout(1500)
                image_path = OUT / f"{safe_name}-{stamp}.png"
                await page.screenshot(path=str(image_path), full_page=True)
                record = {
                    "project": item["project"], "url": page.url,
                    "host": urlparse(page.url).netloc,
                    "http_status": response.status if response else None,
                    "observed_utc": observed.isoformat(),
                    "screenshot": str(image_path),
                }
                (OUT / f"{safe_name}-{stamp}.json").write_text(
                    json.dumps(record, indent=2), encoding="utf-8")
            except Exception as exc:
                # Keep the failed observation visible; do not label it a capture.
                failure = {"project": item["project"], "url": item["url"],
                           "observed_utc": observed.isoformat(), "error": str(exc)}
                (OUT / f"{safe_name}-{stamp}-error.json").write_text(
                    json.dumps(failure, indent=2), encoding="utf-8")
        await browser.close()

asyncio.run(main())

For production use, add your own retention policy, schedule, and retry handling. A successful navigation does not guarantee that the important text rendered or that the date was understood correctly. Review captures, and store failed attempts separately so they are not mistaken for evidence.

5. Add deadline alerts and a review loop

Alerts help you notice a deadline or changed listing, but an alert is a prompt to investigate, not authoritative evidence. ICOAlarm advertises an ICO database with funding targets, tokenomics, team members, deadlines, whitepapers, multiple alarms, push notifications, and exchange-listing alerts. Check its current operation and terms before relying on it; the alert itself still needs confirmation against official announcements and another source. See ICOAlarm.

A practical review loop is:

Set reminders for the sale start/end and expected TGE/trading times, with timezone included in the reminder title.
When an alert arrives, open the official project or exchange source rather than capturing the alert as if it were the announcement.
Compare the source with your last observation and note any change.
Capture the revised source, preserve the earlier record, and update the status of the date and evidence.
After the scheduled window, record whether the event was confirmed, postponed, canceled, or remains unknown based on available evidence.

6. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server for developers. One GET request can return a PNG, JPEG, WebP, or PDF. For a one-off capture of a source page, request a screenshot and save the response. Keep the source URL and observation time in your own monitoring record. See the ScreenshotNeo API documentation for options and setup.

A clean capture removes common overlays, while the monitoring record still needs the source URL and timestamp.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Replace the example target with the page you are monitoring and keep your API key private. ScreenshotNeo removes cookie and consent banners, newsletter popups, and chat widgets before capture; each cleanup step can be turned off. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and response headers report the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients.

The free plan includes 1,000 screenshots each month with no card. Paid plans start at $5 for 3,000 screenshots; every feature is available on every plan. For ICO monitoring, save ScreenshotNeo’s image beside your timestamped record and independently verify dates through official announcements. Sign up for 1,000 free screenshots a month, no card required.

7. Troubleshooting, reliability, and cost

Problem	Likely cause	What to do
Calendar and project dates disagree	The calendar may be stale, or the project revised its schedule.	Keep both observations and timestamps; follow the official announcement and record the conflict until clarified.
TGE date exists but no trading time	TGE and exchange trading are separate events, or exchange details have not been announced.	Leave trading time unconfirmed. Do not infer it from the TGE date.
Screenshot is blank or incomplete	Client-side rendering, a slow page, a blocked resource, or a failed load.	Retry after a reasonable wait, inspect the page manually, and mark the attempt as failed or incomplete rather than evidence of page content.
Capture shows a challenge or consent overlay	The site is presenting a bot check or consent prompt.	Do not claim that the underlying announcement was captured. Use a legitimate manual review or retry later; preserve the failed attempt distinctly.
Date appears without timezone	The announcement omitted timezone context or the page localizes dates.	Record the wording as shown and mark timezone unknown. Seek an official clarification rather than assuming UTC or local time.
Automated job times out	Slow navigation or dependent resources can exceed a short timeout.	Use a longer navigation timeout, save the error and attempt time, and retry with a bounded policy. Avoid creating repeated captures that look like independent confirmations.
Screenshot and note are separated	Files were renamed or moved without updating the log.	Use a stable project-and-time filename, retain a sidecar record, and periodically check that each log row points to an existing image.

Performance: For a handful of projects, manual checks are simple and avoid maintaining browser automation. For a larger watchlist, capture only at useful intervals and when alerts indicate a change; frequent polling wastes time and can produce many near-duplicate files. Full-page images can be large, so choose a consistent viewport and capture scope that keeps the evidence readable.

Reliability: A screenshot is a record of one browser observation, not a durable source of truth. Pages can be edited, localized, or temporarily unavailable. Preserve the original URL, observation timestamp, and announcement links, and keep prior captures when a date changes. For important records, make a second observation from an independent official channel, such as the named exchange’s own notice.

Cost: A local Playwright workflow has no per-capture API charge, but you supply and maintain the machine, browser, schedule, storage, and review process. A hosted screenshot API trades that setup for API usage and its plan limits. ScreenshotNeo offers 1,000 monthly shots free without a card; paid tiers are $5 for 3,000, $15 for 15,000, $39 for 60,000, $99 for 250,000, and $249 for 1,000,000. Yearly billing gives two months free. Match capture frequency to the value of the record rather than treating more screenshots as stronger verification.

8. Risk and legal context

Do not write that a calendar entry or screenshot proves an ICO is legitimate. A captured announcement establishes only that a browser displayed particular content at the recorded time. It does not authenticate who controlled the page, validate a smart contract, establish that tokens will be delivered, or determine whether the offering meets legal requirements.

The SEC explains that whether a token is a security depends on the facts and circumstances; if tokens are securities, their offer and sale in an ICO are subject to federal securities laws. Review the SEC’s DAO investigative report and investor bulletin notice and current applicable guidance. Before publishing a launch notice, link to project disclosures, avoid promises of returns, and distinguish a scheduled sale from a completed or verified offering. Legal obligations vary with the facts and jurisdiction; a monitoring log is not legal advice.

FAQ

Is an ICO calendar enough to confirm a launch?

No. Use calendars to find candidates, then look for dated, verifiable announcements from the project and the exchange named for trading.

What should a screenshot prove?

It can show what a browser displayed at a recorded time. It cannot, by itself, prove the project’s identity, safety, or legal status.

Should I use the sale date or TGE date in alerts?

Track both when available, and also track the first-trading time separately. They describe different events and may have different evidence.

What if no official date is published?

Mark the date as unconfirmed and note when you checked. Do not convert a rumor, countdown, or third-party calendar estimate into a confirmed date.

How often should I capture a project page?

Capture when a source changes, when a meaningful milestone approaches, or at a cadence appropriate to your monitoring needs. Preserve distinct observations instead of generating redundant images.