Skip to content

Repo Check: value your repository without sharing your code

One command on your own machine reads a repository and its git history. You share a file of counts and fixed labels, never code, and see an indicative range, which route fits and what to fix first.

Repo Check is a free script that values a Git repository on your own machine. It measures history, contributors, tests and size, never uploads source code, and writes share.json, a file of counts and fixed labels. Drop that file on this page to see an indicative range in your browser, measured against the Price Index row: standing-rate licenses typically pay $150 to $1,500 per repo, for each sale, and large repos up to about $10,000 per sale (indicative). A small repository can sit below the row's low end.

  • A standing-rate license is priced per token of original code and, at a lower rate, per token of git history, for each sale. Rightmark,
  • Git history often carries more than half the price. Rightmark,
  • Training-task buyers pay $200 to $2,000 per task. Epoch AI, (opens in a new tab)

Updated

share.jsonExcerpt of Sample B
{
  "schema": "rightmark/repo-check/2",
  "label": "Sample B",
  "code": {
    "original_loc": 29780,
    "test_files": 143,
    "source_tokens_est": 242916
  },
  "history": {
    "commits": 761,
    "merged_prs_est": 23,
    "human_contributors": 5,
    "years": 3.4
  },
  "risks": {
    "secrets_current": 0,
    "env_files": 0
  },
  "task_readiness": "strong",
  "route": "task_buyers"
}

Counts, names from fixed lists and yes or no answers, plus one label the owner chooses and a repository id. No paths, people, emails, commit messages or code.

Value a repository in four steps

Most of it is reading. You need Python 3.8 or newer and git, and a full clone of the repository.

  1. Download Repo Check

    One zip with a single Python script, a README and a sample report. It also runs as a Claude skill. Check the script's fingerprint if you like.

    rightmark-repo-check-v2.5.0.zipVersion 2.5.0, 290 KB, 5 files, released 30 Oct 2026
    Download Repo Check
    SHA-256 of the zip
    9e438c8e 816d6113 894e4d9a 404814f2 9d3db2eb c6aa2e39 ba996379 17a922fe
    Script fingerprint, SHA-256
    f18d3aa4 80fced03 7a37e74d f21e77e4 dadfaeac 15d7cd51 14c64c3a 3175708f

    Needs Python 3.8 or newer and git. One file of standard-library Python you can read line by line.

    Checksummed, not signed yet: the signature is published here once the release is signed.

  2. Run one command

    Point it at a full clone. Small repositories take seconds and very large ones several minutes; add --quick for the largest.

    Unzip it

    unzip rightmark-repo-check-v2.5.0.zip

    Run it on a full clone

    python3 rightmark-repo-check/scripts/rightmark_repo_check.py /path/to/repo --out ~/rightmark-reports/my-repo

    Check the fingerprint (optional)

    shasum -a 256 rightmark-repo-check/scripts/rightmark_repo_check.py
    • --label "Project A"The name share.json carries. Without it you get an anonymous label such as repo-3f9a1c. It is the only text in the file you choose, so choose one you are happy to share.
    • --quickFor very large repositories: skips the full-history pass and estimates history size instead.
    • --ref REFChecks another branch, tag or commit instead of what is checked out. It is laid out in a temporary folder inside the --out folder, which the check removes when it finishes; if one from an earlier run is still there, the check stops and asks you to remove it. Nothing is fetched and your checkout is not touched.
    • --merged-prs NYour own count of merged pull or merge requests, for example when your host squashes merges. It is recorded as your statement, beside the count measured from commit messages, and the quote says the owner stated it.
    • --test-report FILEA test report your CI already wrote, in JUnit XML. Repo Check reads the counts from the file and runs none of your tests. share.json then holds the passed, failed, skipped and error counts and whether the report matches the commit you checked; the file itself stays with you.
    • --test-run-link URLThe link to the CI run that wrote the report. It goes into report.md and report.json only; share.json says just that you gave one. Repo Check never opens it.
    • --test-commit HASHThe commit your test report was made at, when the report does not name one. It is your statement, compared with the commit you checked; share.json says only whether they match.
    • --public-checkOff unless you add it, and the only option that connects to the internet. It asks public code archives, package registries and a public web archive whether this repository, a sample of its commits or its package names are known there, prints every request before it is sent, and writes only the counts to share.json.
  3. Open share.json

    Six files appear, the report and a data card among them. Keep the other five; open share.json, the one to send, and read it before you send it.

    The six files Repo Check writes
    FileWhat it isYou
    report.mdThe full report: route, readiness, gates, the fix list, the ownership pack and where possible secrets areKeep
    report.jsonThe same report, machine-readableKeep
    datacard.mdThe data card: the repository in numbers and fixed words, with no names or pathsKeep
    datacard.jsonThe same data card, machine-readableKeep
    components.csvThe dependencies your package manifests declare, a starting point for a software bill of materialsKeep
    share.jsonCounts and fixed labels, plus one short label you choose and a repository idSend

    If the output folder is inside the repository, the check writes next to it instead. Download a sample share.json to try the check below.

  4. Drop it here

    See the quote in your browser at once.

    Many repositories? One output folder each, labeled in order (macOS and Linux)

    cd rightmark-repo-check 2>/dev/null
    repos="$HOME/code"; out="$(dirname "$repos")/rightmark-reports"
    mkdir -p "$out"; touch "$out/labels.txt"
    for r in "$repos"/*/; do
      name=$(basename "$r")
      if [ ! -e "$r.git" ]; then echo "Skipped $name: not a git repository"; continue; fi
      i=$(awk -F '\t' -v n="$name" '$NF == n { sub(/^Repo /, ""); sub(/\t.*/, ""); print; exit }' "$out/labels.txt")
      if [ -z "$i" ]; then i=$(( $(wc -l < "$out/labels.txt") + 1 )); printf 'Repo %s\t%s\n' "$i" "$name" >> "$out/labels.txt"; fi
      if [ -e "$out/$name/share.json" ]; then echo "Skipped $name: already checked"; continue; fi
      python3 scripts/rightmark_repo_check.py "$r" --out "$out/$name" --label "Repo $i" || echo "Not checked: $name"
    done
    for s in "$out"/*/share.json; do
      python3 -c 'import json,sys; d=json.load(open(sys.argv[1])); print(sys.argv[2] + " (" + d["label"] + "): route " + d["route"] + ", task readiness " + d["task_readiness"])' "$s" "$(basename "$(dirname "$s")")"
    done

The same loop on Windows, in PowerShell

cd rightmark-repo-check -ErrorAction SilentlyContinue
$repos = "$HOME\code"; $out = Join-Path (Split-Path $repos) 'rightmark-reports'
$labels = Join-Path $out 'labels.txt'; $null = New-Item -ItemType Directory -Force $out; if (-not (Test-Path $labels)) { $null = New-Item -ItemType File $labels }
Get-ChildItem $repos -Directory | ForEach-Object {
  $name = $_.Name
  if (-not (Test-Path (Join-Path $_.FullName '.git'))) { "Skipped ${name}: not a git repository"; return }
  $i = @(Get-Content $labels | Where-Object { ($_ -split "`t")[1] -eq $name } | ForEach-Object { ($_ -split "`t")[0] -replace '^Repo ', '' })[0]
  if (-not $i) { $i = @(Get-Content $labels).Count + 1; Add-Content $labels "Repo $i`t$name" }
  if (Test-Path (Join-Path $out "$name\share.json")) { "Skipped ${name}: already checked"; return }
  py scripts\rightmark_repo_check.py $_.FullName --out (Join-Path $out $name) --label "Repo $i"
  if ($LASTEXITCODE -ne 0) { "Not checked: $name" }
}
Get-ChildItem "$out\*\share.json" | ForEach-Object { $d = Get-Content $_.FullName -Raw | ConvertFrom-Json; "$($_.Directory.Name) ($($d.label)): route $($d.route), task readiness $($d.task_readiness)" }

Check a share.json

Drop the file Repo Check wrote, or several. See the quote, the route, the gates and the fix list at once. It is read in your browser, and nothing is uploaded until you save it to your portal.

Showing a sample reportMeets every gate, including the tests check

Sample reports

Exactly what will be sent1.8 KB of the 64 KB limit.

This is a sample. Drop your own share.json to see what would be sent for it.

{
  "share": {
    "schema": "rightmark/repo-check/2",
    "tool": "rightmark-repo-check",
    "version": "2.1.0",
    "generated_at": "2026-10-12T08:18:52+00:00",
    "label": "Sample B",
    "languages": [
      {
        "language": "Python",
        "loc": 29528,
        "share": 0.992
      },
      {
        "language": "TypeScript",
        "loc": 252,
        "share": 0.008
      }
    ],
    "code": {
      "main_language": "Python",
      "code_files": 150,
      "code_loc": 26096,
      "test_files": 143,
      "test_loc": 3684,
      "test_ratio": 0.141,
      "original_loc": 29780,
      "generated_loc": 0,
      "vendored_loc": 0,
      "comment_loc": 0,
      "test_comment_loc": 0,
      "commented_code_loc": 0,
      "test_commented_code_loc": 0,
      "source_tokens_est": 242916,
      "rare_stack_share": 0,
      "dotnet_share": 0
    },
    "history": {
      "commits": 761,
      "merge_commits": 23,
      "merged_prs_est": 23,
      "merged_prs_basis": "commit messages, bodies included",
      "human_contributors": 5,
      "human_contributors_core": 5,
      "top_contributor_share": 0.214,
      "years": 3.4,
      "years_active": 3.4,
      "active_months": 41,
      "late_commits": 0,
      "first_year": 2021,
      "last_activity_days": 837,
      "active_last_days": 837,
      "post_2023_share": 0.417,
      "fix_commits": 36,
      "fix_with_test_commits": 36,
      "history_tokens_est": 5443947,
      "history_tokens_basis": "measured"
    },
    "git": {
      "present": true,
      "has_commits": true,
      "shallow": false
    },
    "engineering": {
      "ci": [
        "GitHub Actions"
      ],
      "test_frameworks": [
        "Python tests",
        "pytest"
      ],
      "monorepo": false,
      "private_packages": 0,
      "private_registries": 0,
      "git_dependencies": 0,
      "ai_assistant_files": 0
    },
    "branch_ahead_of_default": 0,
    "disclosures": [
      "post_2023"
    ],
    "licence_kind": "Proprietary",
    "risks": {
      "secrets_current": 0,
      "secrets_history_distinct": 0,
      "secrets_in_test_files": 0,
      "fixture_strings_in_tests": 0,
      "emails_in_tests": 0,
      "env_files": 0,
      "emails_in_code": 0,
      "copyleft_header_files": 0,
      "publish_hints": 0,
      "squashed_history": false
    },
    "gates": {
      "contributors": true,
      "commits": true,
      "merged_prs": true,
      "original_loc": true
    },
    "task_readiness": "strong",
    "estimates": {
      "standing_rate_licence_usd": 242,
      "task_value_range_usd": [
        3000,
        30000
      ]
    },
    "route": "task_buyers"
  }
}

The label is the only text in it you chose. Every other value is a count, a yes or no answer or a name from a fixed list.

Sample quoteMedium confidence

Sample B

Repository, 29,780 lines

$150 to $242

per license

Training-task route. Ready for the training-task route; priced after review. The range is the standing-rate license.

Where it sits

  1. Private repo, standing-rate license$150 to $1,500
  2. Premium or task-grade repository$10,000 to $100,000+

This range $150 to $242 on the Private repo, standing-rate license row

Bars are published ranges from the Price Index, Q4 2026.

Show as a table
The Price Index code rows and this range
Data typePriceUnitConfidenceSource
Private repo, standing-rate license$150 to $1,500This range $150 to $242per repoMedium confidenceRightmark summary of public code licensing programs, Q3 2026
Premium or task-grade repository$10,000 to $100,000+per repoLow confidenceRightmark estimate for task-grade code repositories, Q3 2026
Readiness
Strong5 of 5 checks
Gates met
4 of 4License route open
To fix
0Nothing flagged

Samples cannot be saved. Run Repo Check on your own repository, then drop its share.json here.

Indicative estimate, not an offer. Final offers depend on the systems you connect, data size and quality, access terms and due diligence.

Based on the report generated 12 Oct 2026.

Routes and value

  • Standing-rate license$150 to $242 per license

    A non-exclusive license priced per token of original code and, at a lower rate, per token of git history, for each sale, so the same repository can be licensed more than once.

    Rightmark standing-rate model, Q3 2026. All four gates met

  • Training-task routeSuggestedPriced after review

    Repositories with strong tests and real history can become AI training tasks, priced after review.

    Training-task route; priced after review

  • Rare-stack reviewNot this route

    Code where legacy or rare languages such as COBOL, Fortran or RPG make up 20% or more is reviewed case by case, so no figure is shown.

    Rare-stack share 0%, under the 20% line

What to fix first0 items

Nothing flagged. Run the check again after any large change.

Buyer checklist

AI developers who license code read these lines before they take a repository. Each line says what this check measured and what settles it. A line still open is something to confirm, not a refusal.

  • To confirm
    Never public

    No public sign measured. Repo Check cannot see whether the code was ever public; the owner confirms it was never public and is not a fork.

  • Clear
    Written by people

    42% of the added lines date from 2023 on, and no AI-assistant settings are committed.

  • To confirm
    Clean ownership

    Repo Check cannot see ownership. The owner confirms it is their own work; client work needs the client's written OK.

  • Clear
    Not WordPress

    Not PHP-led, so not a WordPress site, theme or plugin.

  • Clear
    Not a copy

    The history size fits the code.

  • Clear
    Licensable source

    29,780 original lines, 100% of the lines counted.

  • Clear
    A real product

    29,780 original lines.

  • Clear
    Full git history

    761 commits, 5 core contributors, 3.4 active years.

  • Clear
    Pull requests and tests

    23 merged pull requests, 143 test files.

Not measured by this report

  • WordPress markers: this report comes from an earlier version of the check.
  • AI-tool markers in commits: this report comes from an earlier version of the check.
  • The share of lines in the first commit: this report comes from an earlier version of the check.
  • Lines in data files: this report comes from an earlier version of the check.
  • The host the repository came from: this report comes from an earlier version of the check.
  • Public code archives, package registries and a public web archive: only the optional public check looks there.
  • Whether the same code was submitted twice: Repo Check reads one repository at a time.
  • Issues and code review on the host: Repo Check reads the repository, not the host.
  • What kind of system it is (application, backend, internal tool, library or template): Repo Check does not judge it.

The owner's statements settle the ownership line and part of the never-public line.

Readiness for training-task buyersStrong, 5 of 5

Strong Ready for training-task buyers.

  • Passes: At least 5 test files and tests at 10%+ of code lines
  • Passes: Main language has mainstream test tooling
  • Passes: Continuous integration configured
  • Passes: 10+ bug-fix commits that also changed tests
  • Passes: 2+ years of active history and 3+ contributors in it

Standing-rate gates4 of 4 met

  • Passes: Contributorsneeds 3+5
  • Passes: Commitsneeds 100+761
  • Passes: Merged pull requestsneeds 10+23
  • Passes: Lines of original codeneeds 10,000+29,780

What the report says

  • Python 99%
  • TypeScript 1%

Size and tests

Lines of original code
29,780
Code
26,096 lines in 150 files
Tests
3,684 lines in 143 files
Tests to code lines
14%

Engineering

Main language
Python
Continuous integration
GitHub Actions
Test frameworks
Python tests, pytest
License file
Proprietary

History

Commits
761
Merge commits
23
Merged pull requests
23
Contributors
5
Years of history
3.4, since 2021
Bug fixes with tests
36 of 36
Added since 2023
42%
Last commit
837 days before the report
History size
Measured in full

The report

Generated
12 Oct 2026
Repo Check version
2.1.0
Confidence
Medium confidence

Read before you rely on it

  • The gates and the readiness check count contributors and years in the active history only, leaving out late commits.
  • Training-task value is priced after review, and only for tests that run green offline.
  • Disclosure: part of the added lines date from 2023 or later; this says when the code was written, not who or what wrote it.
  • You still confirm the code was never public, is not a fork, and that you own it or hold the client's written consent.
  • Indicative estimate, not an offer. Final offers depend on the systems you connect, data size and quality, access terms and due diligence.

Your code stays on your machine

Repo Check reads your repository where it is and writes six files next to it. Only share.json is meant to leave, and only when you choose.

What Repo Check never does

  • Makes no network connections and calls no AI service
  • Runs no code from your repository: no tests, builds or installers
  • Changes nothing in your repository and writes nothing inside it
  • Never prints secret values; your report shows only where possible secrets are, so you can rotate them
  • Never opens a .env file, now or in the history: committed ones are listed by name only
  • Uses only Python's standard library and read-only git commands

What share.json holds

  • Languages and line counts
  • History counts: commits, merges, contributors, years
  • CI systems and test frameworks
  • The kind of license file
  • Risk counts, never their contents
  • Counts from a test report you already have, when you pass one
  • The check's own gates, readiness and route, which we recompute
  • One short label you choose
  • A repository id: a one-way hash of the first commit, the same for every clone and fork, so anyone with a copy of the repository can match it

What it never holds

  • File names or paths
  • People's names or email addresses
  • Commit messages, commit hashes or remotes
  • Secret values
  • Any line of your code

What share.json contains, and what it leaves out

The field names below describe the documented payload.

Field map

Field familyWhat it describesWhat it does not disclose
schema, tool, version, generated_at and labelPayload identity and a short owner-supplied labelA path or commit message
languages and codeBounded language and code-shape signalsSource code or file contents
history and gitHistory shape, repository state, and selected fixed signalsCommit text, author names, or remote URLs
engineeringTests, tooling, CI, dependency, and related engineering signalsProprietary implementation details
licence_kindLicense-file signalsA conclusion that rights are clear
risksFixed privacy, secret, fixture, and related countsThe records that produced a count
gates and task_readinessStanding-rate gates and route-oriented readiness signalsA buyer decision or a quote
estimatesBounded estimates emitted by the toolAn offer or market promise
testsCounts from a test report the owner passed, read and not rerunTest names, test output, the commit or the run link
routeThe suggested routeA private customer or buyer relationship
provenanceWordPress (none, site, theme or plugin), the host as one word, commits that name an AI coding tool and their share, merges of a branch one made, the share of added lines from 2024 on, the share added in the first commit, whether that commit came from a starter template, and lines and files of data. From version 2.5.0.File paths, commit text, author names or the remote URL
public_checkOnly with --public-check. Counts of sampled commits, package names and web captures checked and found, and whether the repository page answers without signing in. No name, address or id.The names, addresses or ids it asked about

Schema 2 can add comment and test-comment signals, active-history signals, private package and registry signals, Git dependency signals, AI assistant file signals, test secret and email counts, branch-ahead state, disclosures, an optional repository identifier, and an optional test report summary. Those fields still carry bounded signals, not the underlying files.

Safe handling sequence

  1. Open the output folder locally and inspect the report and data card.
  2. Share only the requested file through the current approved route. Do not add code, paths, emails, commit messages, credentials, or private archive files.

Run the report on a full local clone, then review the Trust controls before deciding how a report or approved sample can move. Never send code, passwords or the full repository through this path.

Do not infer a rights conclusion from a technical signal.

Boundaries

Repo Check is an evidence aid. It does not establish ownership, consent, absence of third-party material, legal clearance, buyer demand, or a license price.

What it measures, and what buyers check

Repo Check counts what buyers price. A few things only you can confirm, so your portal asks you to before offers are requested.

  • SizeLines of original code by language, code and test files. Generated, vendored and build files are left out of the value. The range is measured against the Price Index row for private repositories, so a small repository can sit below the row's low end.
  • Tests and engineeringTest frameworks, the test-to-code ratio and the CI systems that run them.
  • HistoryCommits, merged pull requests, contributors, years of history and bug fixes that also changed tests.
  • What buyers flagPossible secrets now and in history, committed .env files, open-source license files, GPL-family headers, publishable manifests, email addresses, shallow or squashed history.

What buyers check beyond the numbers

  1. Never publicNot public now or before, not a fork and not a published package.
  2. Clean ownershipNo client claim, NDA restriction or unpaid contributor. You warrant that you own what you license.
  3. Real workNot a demo, tutorial, coursework or template copy, with history that was not pasted in by one or two people in a day.
  4. Builds and runs its testsA hard gate for training-task buyers: a red test suite has to be fixed first.
  5. Open source disclosedCopied open-source components are declared. Undisclosed copyleft can unwind a deal.
  6. Secrets and personal data outCredentials and personal data removed across the whole history, not just the latest commit.

What earns the premium

  • Hard, long-horizon work: large features built over many commits
  • Tasks that can be graded fairly, with deterministic tests that fail when a unit is removed
  • Real bug fixes that added a regression test
  • A well-structured codebase where hard new features can be specified and checked

What changed in Repo Check 2.1

The check now measures a few things differently: comments are counted apart from code, and the active history apart from commits made after a long quiet gap. A share.json from an earlier version is read with the rules for its format, so its figures do not change, and when the version that made it differs from those rules, the quote says which rules it used.

Repo Check 2.5.0, released 30 Oct 2026.

2.5.0: looks for WordPress, commits that name an AI coding tool, the share of lines from 2024 on, lines added in the first commit and data files, and names the host as one word. Adds the optional --public-check. Figures, gates and routes do not change.

  • Comments are not lines of codeComment lines no longer count toward lines of code, in source or in tests. They are counted apart.
  • Late commits stay out of the active historyCommits made after a long quiet gap no longer stretch the active span of the history, and their authors are no longer counted as core contributors. The gates and the readiness check read the active history.
  • Test fixtures are counted apartPassword-like strings and email addresses in test files are counted apart from secrets and personal data. Keys in a provider format still count as secrets wherever they are.
  • Merged pull requests read from commit bodiesMerged pull requests are read from the whole commit message, its body included, not only its first line.
  • Disclosures and build blockersThe report adds disclosures, facts to state up front such as work on the checked branch that the default branch does not have, and build blockers: private registries, private packages and dependencies that install from git or from a path outside the package.

Two more options

Check another branch, tag or commit

python3 rightmark-repo-check/scripts/rightmark_repo_check.py /path/to/repo --ref REF --out ~/rightmark-reports/my-repo

State your own count of merged pull or merge requests, recorded as your statement

python3 rightmark-repo-check/scripts/rightmark_repo_check.py /path/to/repo --merged-prs N --out ~/rightmark-reports/my-repo

On Windows, add the same option to the py command.

How the quote is worked out

The same math runs in the script, on this page and in your portal. Figures are recalculated from the counts every time, so an edited estimate changes nothing.

Standing-rate license

A non-exclusive license priced per token of original code and, at a lower rate, per token of git history, for each sale, so the same repository can be licensed more than once.

Rightmark standing-rate model, Q3 2026

Shown as a range with a confidence level, measured against the Price Index row for private repositories; a small repository can sit below the row's low end. Shown only when all four gates below are met. Git history often carries more than half the price, so run the check on a full clone.

Training-task route

Repositories with strong tests and real history can become AI training tasks, priced after review.

Training-task buyers pay $200 to $2,000 per task (Epoch AI, Jan 2026).

Ready means the five checks below, and a test suite that runs green offline.

Rare-stack review

Code where legacy or rare languages such as COBOL, Fortran or RPG make up 20% or more is reviewed case by case, so no figure is shown.

Not priced yet

The repository misses at least one standing-rate gate, so it is not priced yet. Close the gate and run the check again.

In the Price Index, Q4 2026

  • Private repo, standing-rate license$150 to $1,500 per repoMedium confidenceRightmark summary of public code licensing programs, Q3 2026
  • Premium or task-grade repository$10,000 to $100,000+ per repoLow confidenceRightmark estimate for task-grade code repositories, Q3 2026
  • Training task built from real code$200 to $2,000 per taskMedium confidenceEpoch AI, Jan 2026
Open the code rows

Standing-rate gates

  • ContributorsThe standing-rate license needs 3 or more human contributors.
  • CommitsNeeds 100 or more commits, not counting merges.
  • Merged pull requestsNeeds 10 or more merged pull requests.
  • Lines of original codeNeeds 10,000 or more lines of code and tests, leaving out generated and vendored files.

Readiness for training-task buyers

  • At least 5 test files and tests at 10%+ of code linesA training task needs a test suite that can run to check it.
  • Main language has mainstream test toolingPython, JavaScript, TypeScript, Go, Ruby, Java, Kotlin, C#, Rust, PHP, Vue, Svelte, Scala, Swift, Dart or Elixir.
  • Continuous integration configuredA CI set-up shows the tests are run and kept green.
  • 10+ bug-fix commits that also changed testsEach bug fix that came with a test can become a training task.
  • 2+ years of active history and 3+ contributors in itReal history from a working team adds value; commits after a long quiet stretch are left out.

Strong means the tests and stack checks pass and at least four of the five do. Possible means at least two; anything less is weak.

Questions owners ask

Does Repo Check upload my code?

No. The script runs locally and reads your repository without changing it. It writes share.json, which holds counts, names from fixed lists, one short label you choose and a repository id: no code, file names, paths, URLs or email addresses. The site refuses any share.json that contains them, or that is over 64 KB.

What does Repo Check measure?

Lines of original code by language, tests and CI, commits, merged pull requests, contributors, years of history and bug fixes that also changed tests. It also flags what buyers check: committed secrets, .env files, open-source license files, copyleft headers, shallow clones and squashed history.

How is the quote calculated?

The standing-rate estimate comes from the Rightmark standing-rate model, Q3 2026: each sale is priced per token of original code and, at a lower rate, per token of git history, and shown as an indicative range with a confidence level, measured against the Price Index row for private repositories, so a small repository can sit below the row's low end. It is shown only when the repository meets all four gates; otherwise the quote says it is not priced yet and what to change. Repositories ready for training-task buyers are priced after review; training-task buyers pay $200 to $2,000 per task (Epoch AI, Jan 2026).

What does a repository need to qualify?

Four gates: at least 3 contributors, 100 commits, 10 merged pull requests and 10,000 lines of original code. You also confirm the code was never public, is not a fork, and that you own it or hold the client's written consent.

Can I check many repositories at once?

Yes. Run the script in each repository, or use the loop in step 4, and drop the share.json files on this page, up to 100 at a time. You see each quote and a total. Then save them to your portal. Buyers see nothing until you request offers, and client code waits for the client's consent.

A buyer sent us an assessment tool to run on our code. Is that safe?

Some tools build your code, run its tests and call an AI model, and their reports can include file paths, commit details, contributor names and emails, and snippets flagged as possible secrets. Run them on a copy in an isolated environment, or ask us to run one in an isolated workspace under NDA, deleted when the scan ends, and review the report before you share it. Repo Check runs nothing and shares counts only.

Can I take my code back out?

Yes, for code that has not been licensed yet: delete a draft or withdraw an asset in your portal at any time. On code routes, signing covers later non-exclusive sales, and licenses already granted stay in force for their term.

What if my repository grades low?

A low grade is not a rejection. The fix list shows what would raise it: fix those items and run the check again.

Many repositories? Keep them in one portal.

Save every share.json to your portal to see each quote, one total by route and what to fix first. Request offers when you are ready.