WAIT — Slowing — last commit 11mo ago

• Last commit 11mo ago
• 4 active contributors
• MIT licensed
• ⚠ Slowing — last commit 11mo ago
• ⚠ Small team — 4 contributors active in recent commits
• ⚠ Single-maintainer risk — top contributor 97% of recent commits
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

A curated, continuously-updated list of free ChatGPT mirror websites and alternative AI chat tools, maintained as a community-driven directory. The project aggregates working public ChatGPT proxies, clones, and free alternatives (like Claude, DeepSeek) in a single README.md table, along with helper tooling (convert.py) to validate and format the site list stored in urls.json. Flat structure: ROOT/README.md contains the main table of mirrors with metadata (序号, 网站, 标签, 添加时间, 备注). ROOT/urls.json holds structured mirror data. ROOT/convert.py is a utility script (likely for transforming between README table and JSON formats). Issue templates in .github/ISSUE_TEMPLATE/ guide contributors to report failures or add new sites.

End users searching for free ChatGPT access without signup, and developers/contributors who want to maintain a crowdsourced registry of mirror sites. Contributors report broken links via GitHub Issues and submit new mirror URLs using templated issue forms.

Active and well-maintained: 312 verified websites listed, 985 lines of Python code, recent commits visible in badge metadata, and established contribution workflows (issue templates). The project has clear governance (排序规则 in #80 discussion) and sponsorship integrations. Production-ready as a reference list, though individual mirror sites may be ephemeral.

High operational risk: mirror sites are inherently transient and depend on third-party infrastructure outside the maintainer's control. Single maintainer (LiLittleCat) owns the repo; no visible CI pipeline, automated testing, or bot to validate URLs. The urls.json data could become stale quickly without active monitoring—relies on community Issue reports for dead-link detection rather than automated health checks.

Actively fielding mirror submissions and failure reports via issue templates (反馈站点失效.md, 添加镜像站点.md). The badge shows 312 websites currently tracked. Recent activity indicated by 'last-commit' badge visibility. No visible active development on convert.py or automated tooling—focus is manual curation and community reports.

git clone https://github.com/LiLittleCat/awesome-free-chatgpt.git && cd awesome-free-chatgpt && cat README.md # or python convert.py if you need to regenerate urls.json from the table. No npm/pip install required—this is a data/docs project, not a runnable service.

Daily commands: No runtime to start. To view/edit: open README.md in your editor or browser. To update the JSON export from the table: python convert.py (assuming it parses README.md → urls.json). To contribute: use GitHub web UI to file Issues via the provided templates.

• urls.json — Core data file containing the list of 312 free ChatGPT mirror sites; this is the primary asset that users and scripts consume.
• README.md — Chinese documentation and main entry point that explains the project purpose, disclaimers, and contribution guidelines for the majority of users.
• README_en.md — English translation of documentation enabling international contributors and users to understand the project scope and participation model.
• convert.py — Transformation script that processes raw site data into publishable formats; must be maintained to ensure data consistency and pipeline integrity.
• .github/ISSUE_TEMPLATE/添加镜像站点.md — Issue template that guides contributors on how to propose new mirror sites, directly affecting data quality and submission process.
• .github/ISSUE_TEMPLATE/反馈站点失效.md — Issue template for reporting broken mirror sites, enabling community-driven maintenance and keeping the urls.json list accurate.
• .gitignore — Specifies which files should not be tracked, protecting sensitive data and controlling what gets published to the repository.

• urls.json (JSON) — Single source of truth for all 312+ free ChatGPT mirror sites; stores URL, access model, and optional metadata (language, features, etc.)
  • Failure mode: Corruption or loss of data; incomplete/stale mirror list; inability to distribute to consumers; version control conflicts if concurrent edits occur.
• convert.py (Python) — Transforms urls.json into alternative output formats (CSV, HTML, etc.) for distribution or secondary indexing; validates data structure.
  • Failure mode: Script errors cause conversion failures; stale data if not re-run after updates; no alerting if format changes break downstream consumers.
• GitHub Issue Templates (Markdown + GitHub) — Standardize and guide community submissions (new sites, broken reports) into structured format; reduce ambiguity in contribution metadata.
  • Failure mode: Unclear instructions lead to malformed issues; missing required fields prevent proper validation; templates become out-of-sync with maintainer expectations.
• Maintainer/Human Curator (Manual human review) — Reviews issues, validates submissions, merges valid entries into urls.json, removes defunct sites, ensures data quality and accuracy.
  • Failure mode: Backlog of unreviewed issues; incorrect data entry; delayed response to broken site reports; burnout if volume exceeds capacity; no audit trail for decisions.
• README documentation (Markdown) — Communicates project scope, usage disclaimers, contribution pathways, and available resources in Chinese and English.
  • Failure mode: Outdated disclaimers or missing warnings; users add sensitive data to untrusted mirrors; unclear contribution process reduces participation.

• User/Contributor → GitHub Issue Template — User discovers broken mirror site or new mirror and submits via templated GitHub issue (either add or report flow).
• GitHub Issue → Maintainer — Maintainer is notified of new issue containing site submission or failure report; reviews for validity and metadata completeness.
• Maintainer → urls.json — Validated submissions are manually added (new sites)

Add a New ChatGPT Mirror Site

1. Click 'Issues' and select the '添加镜像站点' (Add Mirror Site) template (.github/ISSUE_TEMPLATE/添加镜像站点.md)
2. Fill in the site URL, access method (free/freemium), availability status, and any special notes (.github/ISSUE_TEMPLATE/添加镜像站点.md)
3. Maintainer reviews submission and adds validated entry to the urls.json dataset with appropriate metadata (urls.json)

Report a Non-Functional Mirror Site

1. Click 'Issues' and select the '反馈站点失效' (Report Site Failure) template (.github/ISSUE_TEMPLATE/反馈站点失效.md)
2. Provide the broken site URL, date discovered non-functional, and any error messages encountered (.github/ISSUE_TEMPLATE/反馈站点失效.md)
3. Maintainer verifies the report and removes or marks the entry as inactive in urls.json (urls.json)

Transform or Export Site Data to Another Format

1. Review the convert.py script to understand current input format (urls.json structure) (convert.py)
2. Modify or extend convert.py to parse urls.json and output to desired format (CSV, XML, HTML, etc.) (convert.py)
3. Run the script locally: python convert.py and verify output matches expectations (convert.py)

Update or Improve Multilingual Documentation

1. Edit README.md for Chinese language updates or new sections explaining the project (README.md)
2. Simultaneously update README_en.md with corresponding English translation to maintain parity (README_en.md)
3. Verify both files render correctly on GitHub and that contribution links direct to the correct issue templates (README.md)

• JSON (urls.json) — Lightweight, human-readable structured format for storing heterogeneous site metadata; easily parsed by scripts and consumed by web frontends without database overhead.
• Python (convert.py) — Simple scripting language for data transformation tasks; enables quick format conversion and validation without complex build tooling.
• GitHub Issues & Issue Templates — Decentralized community contribution model leveraging GitHub's native tools; reduces barrier to entry for non-technical users to report or propose additions.
• Markdown (README files) — Platform-native documentation format rendering directly in GitHub; supports multiple languages and clear visibility of project scope and disclaimers.

• Use GitHub Issues as primary contribution mechanism rather than pull requests

  • Why: Lower technical friction for non-developers; allows maintainers to curate and validate before database update.
  • Consequence: Slower workflow and potential bottleneck if contributor volume exceeds maintainer capacity; no direct community peer review before merge.

• Centralize data in single urls.json file rather than database

  • Why: Zero infrastructure cost, version control history, transparency for all contributors, simple CI/CD integration.
  • Consequence: Does not scale to real-time updates or personalized filtering; no granular access control; manual conflict resolution if concurrent edits occur.

• Provide no authentication, rate-limiting, or usage tracking on mirror sites

  • Why: Project acts as passive aggregator; reduces liability and maintenance burden.
  • Consequence: Cannot detect when sites become defunct until user reports; no visibility into which mirrors are most popular or reliable.

• Maintain separate Chinese and English README files instead of single i18n template

  • Why: Markdown simplicity; easy for contributors to update without build steps.
  • Consequence: Documentation drift risk; requires manual synchronization of changes across language versions.

• Does not provide authentication, account management, or login for mirror sites
• Does not perform uptime monitoring, health checks, or real-time status tracking of listed mirrors
• Does not operate or host any ChatGPT mirror sites itself—purely an aggregation and curation project
• Does not offer programmatic API endpoints—data is consumed via static JSON file only
• Does not handle personal data, analytics, or user behavior tracking
• Does not provide legal guidance; explicitly disclaims responsibility for third-party mirror site practices

convert.py likely requires the README.md table structure to remain consistent (HTML structure, column order, tag format) or it will fail silently. No obvious Makefile or package.json—don't assume pip/npm workflows. The urls.json format is not documented in the README, so you must reverse-engineer from convert.py or examine an existing urls.json file. Tag format (🆓🔓🔒🔑💰👀💪🧰🌎🏆) is regex-sensitive and easy to break if manually editing. International content (Chinese UI) may confuse non-CN contributors; no English-only contribution guide visible.

• Mirror/Proxy Pattern — Understanding how HTTP proxies and reverse proxies work is essential to evaluate why mirrors exist, their latency/reliability tradeoffs, and legal/TOS risks in THIS repo's domain.
• API Rate Limiting & Quota Management — Most free mirrors implement rate limits (reflected in tags like 🔓free credits); understanding token buckets, sliding windows, and quota allocation explains why many sites have daily/hourly caps.
• Web Scraping & Data Extraction — convert.py likely uses regex or HTML parsing (BeautifulSoup) to extract mirror data from the README table; understanding DOM structure and CSS selectors is key to modifying or debugging the conversion logic.
• Community Governance & Issue Triage — This repo relies entirely on GitHub Issues (templated) and PR review for quality control; understanding how to write clear issue templates and triage duplicate/invalid reports is critical to scaling the project.
• Data Freshness & Staleness Problem — Mirror sites appear and vanish frequently; this repo faces the classic 'stale data' problem. Understanding TTL, caching invalidation, and eventual consistency helps explain why automated health checks (missing) are needed.
• Structured Data Formats (Markdown + JSON) — The project maintains parallel Markdown (human-readable) and JSON (machine-readable) representations; understanding bidirectional serialization and format drift is essential to contribute without breaking convert.py.

• xxjwxc/gpt-web — Self-hosted ChatGPT web UI alternative; complements this repo by letting users build their own mirror rather than just listing existing ones.
• liyupi/free-api — Another curated list of free APIs (including ChatGPT/LLM endpoints); overlaps problem space and shares similar community-driven curation model.
• Yidadaa/ChatGPT-Next-Web — Popular open-source ChatGPT UI project that many mirror operators fork/deploy; users of this repo often want to self-host using that template.
• acheong08/ChatGPT — Reverse-engineered ChatGPT API wrapper; enables building custom mirrors that this repo lists, providing the technical foundation for many free mirrors.
• transitive-bullshit/chatgpt-api — Node.js ChatGPT API client; developers building mirrors often use this or similar libraries to interface with OpenAI or proxy services.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add automated URL validation workflow in GitHub Actions

The repo maintains a urls.json file with 312+ websites but lacks automated validation. A GitHub Actions workflow should periodically check if listed mirror sites are still accessible (HTTP status checks) and auto-create issues for dead links. This prevents stale entries and improves data quality without manual effort.

• [ ] Create .github/workflows/validate-urls.yml with a scheduled job (cron: daily or weekly)
• [ ] Add Python script (or use existing convert.py) to parse urls.json and perform HEAD/GET requests with timeout
• [ ] Generate report comparing against previous runs to identify newly dead sites
• [ ] Auto-create GitHub issues with 'site-down' label for failures, referencing the反馈站点失效 template
• [ ] Document the workflow in README.md with maintenance expectations

Enhance convert.py to validate and auto-format urls.json entries

convert.py exists but its exact purpose is unclear. Formalize it as a pre-commit validator that enforces urls.json schema consistency (required fields: url, name, description, status), checks for duplicates, validates URL format, and auto-fixes common issues. This prevents malformed PRs from being accepted.

• [ ] Document the expected JSON schema for urls.json entries at the top of convert.py with examples
• [ ] Add validation functions: check required fields, validate URL format (http/https), detect duplicates by URL
• [ ] Create .github/workflows/lint-urls.yml that runs convert.py on every PR to validate urls.json changes
• [ ] Add pre-commit hook configuration (.pre-commit-config.yaml) for local contributor validation
• [ ] Update CONTRIBUTING section in README.md with: 'Run python convert.py --validate urls.json before submitting'

Add multi-language issue template selection in GitHub Actions

The repo has both .github/ISSUE_TEMPLATE/反馈站点失效.md and .github/ISSUE_TEMPLATE/添加镜像站点.md (Chinese) but README_en.md exists alongside README.md. English contributors see Chinese templates only. Create English versions of both templates and add a GitHub Actions workflow that detects issue language preference and routes to appropriate template.

• [ ] Create .github/ISSUE_TEMPLATE/report-broken-site.md (English version of 反馈站点失效.md)
• [ ] Create .github/ISSUE_TEMPLATE/add-mirror-site.md (English version of 添加镜像站点.md)
• [ ] Update README_en.md with links pointing to English templates
• [ ] Add contribution guidelines section to README_en.md explaining the submission process
• [ ] Create CONTRIBUTING.md with dual-language sections for both Chinese and English workflows

• Add an automated URL health-check script (e.g., using requests.get() with timeout) to validate all mirrors in urls.json weekly and auto-generate a report of dead sites. Store results in a GitHub Actions workflow.
• Enhance convert.py to support bidirectional conversion: currently README → urls.json likely works, but reversing (urls.json → README table HTML) would allow programmatic table updates and reduce manual editing errors.
• Create a simple 'stats.json' output (mirrors by region, tag distribution, average uptime) by extending convert.py; expose in README badges or a stats/ folder for transparency and to help users pick reliable mirrors.

This repository presents moderate-to-high security risks due to its core function of aggregating unverified third-party ChatGPT mirror websites. The primary concerns are: (1) lack of validation for submitted URLs allowing potential injection of phishing/malware sites, (2) insufficient user warnings about security risks, (3) no verification of HTTPS/security headers on listed sites, and (4) vulnerability to supply chain attacks via the urls.json file. While the repository provides a legitimate service, it requires substantial security improvements including URL validation pipelines, stronger warnings, code signing, and automated abuse prevention. Users should be cautioned that official ChatGPT channels remain the safest option.

• High · User-Supplied Data Without Validation — urls.json, GitHub Issues workflow. The repository collects and lists third-party ChatGPT mirror websites submitted by users through GitHub issues. There is no apparent validation or vetting mechanism for URLs before they are added to the urls.json file. Malicious actors could submit phishing sites, malware distribution points, or credential-harvesting websites that would then be recommended to users. Fix: Implement a validation process for submitted URLs including: domain reputation checks, SSL certificate validation, content scanning, and manual review before adding to the list. Add warnings in README about verifying sites before use.
• High · Lack of Security Warnings for Sensitive Data — README.md, README_en.md. While the README contains a brief warning about not inputting personal information on these sites, the warning is insufficient. Users may not fully understand the risks of using unverified third-party mirror sites, including potential credential theft, session hijacking, and data interception. Fix: Add prominent security warnings explaining the risks, recommend using only official OpenAI endpoints, and provide guidance on identifying legitimate vs. fraudulent sites. Consider adding a security risk disclosure statement.
• Medium · No HTTPS Enforcement or Security Headers Documentation — urls.json, README.md. The repository does not document or verify that listed mirror sites use HTTPS or implement security headers (HSTS, CSP, X-Frame-Options, etc.). Users accessing insecure HTTP sites are vulnerable to man-in-the-middle attacks. Fix: Filter out any HTTP-only sites from the list. Add a validation script to verify HTTPS availability. Document recommended security headers that mirror sites should implement.
• Medium · Potential for Supply Chain Attack via urls.json — urls.json. The urls.json file is likely accessed directly by users or automated tools. If this repository or the raw JSON file is compromised, an attacker could inject malicious URLs serving phishing or malware to potentially thousands of users. Fix: Implement code signing for urls.json. Use GitHub branch protection rules to require review before merges. Add integrity checking mechanisms (hash verification). Consider using GitHub releases with signed tags.
• Medium · No Rate Limiting or Access Controls on Issue Templates — .github/ISSUE_TEMPLATE/. The GitHub issue templates for submitting new sites lack any rate limiting or CAPTCHA protection, allowing automated spam submissions or bulk injection of malicious URLs. Fix: Implement GitHub Actions to automatically validate submitted URLs and flag suspicious patterns. Consider requiring issue submitters to have verified GitHub accounts with history. Implement automated abuse detection.
• Low · Missing Dependencies Analysis — convert.py. The convert.py script is present but dependencies are not explicitly listed. If this script uses external libraries for URL validation or conversion, they could introduce vulnerabilities if outdated or malicious. Fix: Create a requirements.txt or pyproject.toml file documenting all dependencies. Run regular dependency audits using tools like pip-audit or safety. Use lock files to ensure reproducible builds.
• Low · No Data Privacy or Usage Policy — README.md. The repository collects and maintains a list of third-party services without clear documentation of how user data might be at risk or what privacy policies apply to the listed sites. Fix: Add a privacy and disclaimer section explaining that users access third-party sites at their own risk. Recommend reviewing each site's privacy policy before use.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/LiLittleCat/awesome-free-chatgpt shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live LiLittleCat/awesome-free-chatgpt repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/LiLittleCat/awesome-free-chatgpt.

What it runs against: a local clone of LiLittleCat/awesome-free-chatgpt — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in LiLittleCat/awesome-free-chatgpt | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch main exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 350 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of LiLittleCat/awesome-free-chatgpt. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/LiLittleCat/awesome-free-chatgpt.git
#   cd awesome-free-chatgpt
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of LiLittleCat/awesome-free-chatgpt and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "LiLittleCat/awesome-free-chatgpt(\\.git)?\\b" \\
  && ok "origin remote is LiLittleCat/awesome-free-chatgpt" \\
  || miss "origin remote is not LiLittleCat/awesome-free-chatgpt (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify main >/dev/null 2>&1 \\
  && ok "default branch main exists" \\
  || miss "default branch main no longer exists"

# 4. Critical files exist
test -f "urls.json" \\
  && ok "urls.json" \\
  || miss "missing critical file: urls.json"
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "README_en.md" \\
  && ok "README_en.md" \\
  || miss "missing critical file: README_en.md"
test -f "convert.py" \\
  && ok "convert.py" \\
  || miss "missing critical file: convert.py"
test -f ".github/ISSUE_TEMPLATE/添加镜像站点.md" \\
  && ok ".github/ISSUE_TEMPLATE/添加镜像站点.md" \\
  || miss "missing critical file: .github/ISSUE_TEMPLATE/添加镜像站点.md"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 350 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~320d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/LiLittleCat/awesome-free-chatgpt"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.