Date when an entity entered Google's Knowledge Graph, and the original MID codec

A recent MID reads /g/11 followed by eight characters, for example /g/11k4jj7mq1. These characters come from a 32-symbol alphabet, 0123456789bcdfghjklmnpqrstvwxyz_, without vowels so that no word can form. The first 1 stands for the /g/ namespace; the rest, read in base 32, gives a number between 2⁴⁰ and 2⁴¹ for every /g/11…. That number is what grows over time.

We converted into numbers the MIDs of 95,647 entities dated by Wikidata, spread over ten families: events, albums, films, games, elections, sports competitions, organizations, products, created places and opened places. Each family was dated from the nine others only, and all follow the same curve. To the year, the estimate is right for 93% of unpredictable events, 81% of albums, 76% of films, 67% of games and 46% of organizations.

Precision by range

To the month in nearly every range, never below the week: an event usually gets its MID one to two weeks after it happens. The /g/11k-/g/11n area, shared by two series, remains the least reliable.

4,662 events dated without themselves, with the MID given by Wikidata or the one Google shows today, weighted by the real-world situation of MIDs (33-million block with or without a reference). On the MIDs Google shows, the tool is within three months in 82% of cases in /g/11k-n and 93% in /g/11p-t.

At the edge of the counter. References stop on October 22, 2026. An ID assigned after that date, in practice from November 2026 on, falls beyond them: the tool dates it by extending the counter. Recalibrating the tool at past dates, we measured that for the main series it stays within three months for 98 to 100% of events in the following two months (here until the end of December 2026), then for 82% in the third month (January 2027). For the slow series, nothing signals that it moves into a new block: the right date appears in the answer, often in second position, until the references are updated.

The slow series from /g/11k to /g/11p

A first series filled /g/11k to /g/11p in 2020-2022. A second, slower one has been occupying the ranges it left free since late 2022: these are the orange dots on the chart, two to five years above the blue ones. Starting from /g/11k, it entered /g/11p in late September 2026. An isolated ID from this area can therefore date from 2021 as well as from 2026.

Reference dates of each series, 10th to 90th percentile.

The two series rarely mix within the same block of 33 million IDs: 837 of the 891 blocks holding at least two dated references belong to a single series. The tool recognizes the series from the ID's block or from its neighbors. When the neighboring blocks disagree, it puts the slow series first and gives the fast-series date second: the slow series was the right one for 86% of reference events in that situation. When the fast series is inferred from the neighbors, it also gives the slow-series date, because the slow series moves into blocks left free without warning.

What each character encodes

Google's code reads a MID as a 64-bit integer in three parts: 2 version bits, always 0, 3 bits for the namespace (the code's "graph ID"), then 59 value bits. The string is written as the namespace prefix (/g/), one character carrying the version and the namespace, then the value in base 32 without leading zeros, in the alphabet the code calls "munch". This is why every /m/ starts with 0 and every /g/ with 1: that first digit is not part of the counter.

For /g/11b6377dzp: 2⁵⁹ for the /g/ namespace, plus 1b6377dzp read in base 32 (1,449,659,708,373), giving 576462201963131861. This is the integer Valentin Pletzer spotted in 2019 in a Google search URL (ibp=tpf;cl_tp:srp,mid:576462201963131861). This MID points to "Public prosecutor's office".

Google's code, reconstructed

The source file metaweb/util/mid/mid.cc is not public. Its path recalls where the codec comes from: Metaweb, the company that built Freebase before Google bought it in 2010. We got hold of the binary of the original codec and rebuilt it in C++. Logic, constants, messages and line numbers come from the binary. Function and variable names are ours: the binary no longer holds any.

// metaweb/util/mid/mid.cc                                     // reconstruction: the logic is the binary's, the names are ours
static const char kMunch[] = "0123456789bcdfghjklmnpqrstvwxyz_";
static const string_view kPrefix[8] = {"/m/", "/g/", "/t/", "/x/", "/n/", "/p/", "/r/", "/s/"};
static const uint64_t kMaxValue = 0x7ffffffffffffff;           // 2^59 - 1

uint64_t MakeMid(int graph, uint64_t value) {
  if (value >> 59) {
    VLOG(1) << "Mid exceeds max size 0x" << hex << kMaxValue   // line 226 of the source file
            << " for namespace " << kPrefix[graph] << ": 0x" << value;
    return -1;
  }
  if (graph == -1) return -1;
  return value | (uint64_t(graph) << 59);
}

bool ParseMunch(string_view s, uint64_t* out) {
  if (s.size() > 13) return false;
  if (s.size() == 13 && kMunchValue[s[0]] > 15) return false;  // would exceed 64 bits
  uint64_t v = 0;
  for (char c : s) {
    int d = kMunchValue[c];                                    // -1 outside the alphabet
    if (d < 0) return false;
    v = (v << 5) + d;
  }
  *out = v;
  return true;
}

uint64_t GuidToMid(string_view guid) {
  if (guid.size() != 32) return -1;
  uint64_t hi = HexToU64(guid.substr(0, 16)), lo = HexToU64(guid.substr(16, 16));
  uint64_t graph = hi - 0x9202a8c04000641f;                    // unsigned comparison
  if (lo < 0x8000000000000000 || lo > 0x80000003ffffffff || graph >= 8) return -1;
  return MakeMid(graph, lo & 0x3ffffffff);                     // 34 value bits
}

uint64_t ParseMid(string_view s) {
  if (s.size() >= 4 && s[0] == '/' && s[2] == '/') {
    int graph;
    switch (s[1]) {
      case 'm': graph = 0; break;   case 'g': graph = 1; break;
      case 't': graph = 2; break;   case 'x': graph = 3; break;
      case 'n': graph = 4; break;   case 'p': graph = 5; break;
      case 'r': graph = 6; break;                              // reserved, never observed
      default: return -1;                                      // 's' included, no message
    }
    char c0 = s[3];
    if ((c0 & 0x78) != 0x30) return -1;                        // '0' to '7': version 0
    uint64_t value;
    if (c0 == '7' || !ParseMunch(s.substr(4), &value)) {
      VLOG(1) << "Invalid mid characters: " << s;              // line 256 of the source file
      return -1;
    }
    uint64_t mid = MakeMid(kMunchValue[c0], value);
    if (mid == -1) return -1;
    return ((mid >> 59) & 7) == graph ? mid : -1;              // letter and digit must agree
  }
  if (StartsWith(s, "/guid/")) return GuidToMid(s.substr(6));
  if (StartsWith(s, "#"))      return GuidToMid(s.substr(1));
  return -1;
}

string MidToString(uint64_t mid) {
  if (mid == 0) return "/m/0";
  uint64_t top = mid >> 59;                                    // version + graph
  if (top >= 7) return "";                                     // /s/ or non-zero version
  char buf[13];
  return StrCat(kPrefix[top], kMunch[top], MunchDigits(mid & kMaxValue, buf)); // base 32 without leading zeros
}

VLOG(1) is a reading of the binary: before writing, the code tests a log level, but the exact macro is unknown. kMunchValue is the reverse alphabet table, MunchDigits writes the digits right to left into a 13-character buffer.

Two messages, and a lot of silence

The file holds only two error messages: "Mid exceeds max size 0x… for namespace …" at line 226, when a value exceeds 59 bits, and "Invalid mid characters:" at line 256, when a character falls outside the alphabet. An unknown prefix, a /s/ or a letter that does not match the first digit return −1 without logging anything.

Everything else is data: the alphabet, the table of the eight prefixes, the reverse table, and the two ways of writing a Freebase GUID, /guid/ and #.