Toronto Shelter Data Updated Daily

We rebuild Toronto’s shelter dashboards, check the numbers, and publish what we find

Daily Toronto shelter data for people who need somewhere safe to stay, including people who are housing insecure, unhoused, or experiencing homelessness.

daily_occ    = FileAttachment("data/daily_occupancy.json").json()
bt_data      = FileAttachment("data/city_bridging_triage.json").json()
city_table   = FileAttachment("data/city_daily_table.json").json()
seasonRug    = FileAttachment("data/season_rug.csv").csv().then(rows =>
  rows.map(d => ({ min_temp: +d.min_temp, winter_season: d.winter_season }))
)
binnedSC     = FileAttachment("data/cold_response_binned_by_winter_sc.csv").csv().then(rows =>
  rows.map(d => ({
    min_temp_bin:  +d.min_temp_bin,
    winter_season: d.winter_season,
    mean_unplaced: +d.mean_unplaced,
    n:             +d.n
  }))
)

// The newest date the table below can actually show, which on a contingency
// day is a City-webpage date rather than an open-data one. The card says
// "shown here", so it tracks what is displayed, not just what CKAN has.
homeLatestDate = latestDate
homeLatestLabel = {
  const [year, month, day] = homeLatestDate.split("-").map(Number)
  return new Date(year, month - 1, day).toLocaleDateString("en-CA", {
    year: "numeric", month: "long", day: "numeric"
  })
}

BonQuery rebuilds Toronto’s public shelter dashboards using the City’s public data sources. We show how many shelter spaces were recorded as used, unoccupied or unavailable at 4 a.m., how demand is changing, and when people who need somewhere safe to stay are still left without shelter.

These sources do not show everyone who needs a safe place or every form of homelessness. See who the numbers include, who they miss, and why BonQuery uses more than one term →

I need help nowToronto shelter, violence, outreach, and emergency contacts I want to understandStart with the latest shelter numbers and trends

Help the French sound natural

I used an LLM to translate the English site into French, then proofread it myself. My French is intermediate, so I am looking for native French speakers, especially Canadian Francophones, to check that the translations sound natural to French readers and speakers in Canada.

The homepage is my highest priority. Partial reviews are welcome, and I will credit editors and proofreaders for any portion they help with.

Help proofread the French →

html`<div class="bq-home-status" role="status">
  <span class="bq-status-dot" aria-hidden="true"></span>
  <span><strong>Updated every day.</strong> Latest published City of Toronto shelter data shown here: ${homeLatestLabel}. <strong>Not live bed availability.</strong></span>
</div>`

Start with your question

HOW MANY PEOPLE WERE ACCOMMODATED? LATEST CITY SNAPSHOT

Beds and Spaces

See the latest City shelter use and capacity, then browse every published day since January 2021.

See the daily numbers →

HOW MANY PEOPLE NEED SHELTER? LATEST PUBLISHED

Monthly Snapshot

See how many people were counted as homeless, entered or left the shelter system, and moved into housing. Choose any month from 2018 onward.

Open the snapshot →

HOW DID WE GET HERE? LATEST PUBLISHED

Historical Trends

See how homelessness and shelter use have changed since January 2021.

Explore the trends →

HOW MANY CALLS WERE HANDLED? LATEST PUBLISHED

Calls Asking for Shelter

See average daily calls handled, shelter referrals, and individual or couple callers still without a place at 4 a.m.

See the call data →

IS THE SYSTEM IMPROVING? LATEST PUBLISHED

This Year So Far

Compare how many people were newly counted as homeless or moved into housing this year and in earlier years.

Compare years →

Every day

We show how many shelter beds and spaces were used, empty, or unavailable.

Every month

We show how many people entered shelters, left them, or moved into housing.

Every winter

We check whether people are still left without a place during dangerous cold.

See how many shelter spaces are used

See calls asking for shelter

See what happened in cold weather

See where the numbers come from

Cold-Weather Findings

A warm place before harm starts

96% of nights at or below −5 °C: From 2020–21 to 2025–26, at least one person or couple was still without a place at 4 a.m. People turned away at the door are not counted.

More access, but still nearly full: From 2023–24 to 2025–26, at least one direct-access space was reported open on 90% of nights from 0 to −5 °C, compared with 40% during the previous three winters. Cold-weather beds and spaces were at least 98% full on 47% of nights at or below −5 °C.

Cold injury can cause lasting harm before it becomes life-threatening. No one should suffer preventable harm because they could not get indoors.

Read the full article for the sources, methods and limitations. BonQuery cannot provide direct cold-weather help. For verified services, use I need help now.

Read the Cold-Weather Article →

See Where the Numbers Come From →

WHAT HAPPENED ON COLD NIGHTS

People still without a shelter place at 4 a.m. on cold nights

cs      = getComputedStyle(document.body)
refLine = cs.getPropertyValue("--bq-chart-stroke").trim()

seasonColorMap = new Map([
  ["2020-21", "#4DF884"],
  ["2021-22", "#2F9DF5"],
  ["2022-23", "#DEDD32"],
  ["2023-24", "#E63946"],
  ["2024-25", "#F65F18"],
  ["2025-26", "#900C00"]
])

viewof selectedWinters = {
  const allSeasons = [
    "2020-21","2021-22","2022-23","2023-24","2024-25","2025-26"
  ];
  const selected = new Set(allSeasons);

  if (!document.getElementById("bq-season-cb-style")) {
    const s = document.createElement("style");
    s.id = "bq-season-cb-style";
    s.textContent = `
      .bq-season-cb {
        appearance: none;
        -webkit-appearance: none;
        width: 14px;
        height: 14px;
        border-radius: 2px;
        margin: 0;
        border: 1.5px solid #888;
        cursor: pointer;
        display: inline-flex;
        align-items: center;
        justify-content: center;
        flex-shrink: 0;
        background: transparent;
      }
      .bq-season-cb:checked {
        background-color: var(--season-color);
        border-color: var(--season-color);
      }
      .bq-season-cb:checked::after {
        content: "✓";
        color: #fff;
        font-size: 10px;
        font-weight: 700;
        line-height: 1;
      }
      .bq-season-cb:hover {
        transform: scale(1.15);
        box-shadow: 0 0 0 2px rgba(0,0,0,0.15);
      }
      .bq-season-lbl {
        display: inline-flex;
        align-items: center;
        gap: 8px;
        cursor: pointer;
        user-select: none;
      }
    `;
    document.head.appendChild(s);
  }

  const root = document.createElement("div");
  root.style.cssText = "font-family:var(--sans-serif,sans-serif);font-size:13.5px;";

  const labelEl = document.createElement("div");
  labelEl.textContent = "Winters shown";
  labelEl.style.cssText = "font-weight:600;margin-bottom:3px;";

  const hint = document.createElement("div");
  hint.textContent = "Choose which winters to show";
  hint.style.cssText =
    "font-size:11.5px;font-weight:400;color:var(--bq-fg-faint);margin-bottom:6px;";

  const row = document.createElement("div");
  row.style.cssText =
    "display:flex;flex-wrap:wrap;gap:6px 20px;align-items:center;";

  for (const season of allSeasons) {
    const color = seasonColorMap.get(season);

    const cb = document.createElement("input");
    cb.type = "checkbox"; cb.value = season; cb.checked = true;
    cb.className = "bq-season-cb";
    cb.style.setProperty("--season-color", color);

    const txt = document.createElement("span");
    txt.textContent = season;

    const lbl = document.createElement("label");
    lbl.className = "bq-season-lbl";
    lbl.append(cb, txt);
    row.append(lbl);

    cb.addEventListener("change", () => {
      if (cb.checked) selected.add(season); else selected.delete(season);
      root.value = [...selected];
      root.dispatchEvent(new Event("input"));
    });
  }

  root.append(labelEl, hint, row);
  root.value = allSeasons;
  return root;
}

scSeasons = selectedWinters

Note

How to read this chart. Each dot shows the average for nights near that temperature. Bigger dots mean more nights. Each coloured mark along the bottom is one night. The colours separate the six winters. Use the boxes above to show or hide a winter.

{
  const visibleBinned = binnedSC.filter(d => scSeasons.includes(d.winter_season))
  const visibleRug    = seasonRug.filter(d => scSeasons.includes(d.winter_season))

  return Plot.plot({
    width:        720,
    height:       400,
    marginLeft:   70,
    marginRight:  20,
    marginTop:    20,
    marginBottom: 50,
    color: {
      type:   "ordinal",
      legend: true,
      label:  "Winter",
      domain: [...seasonColorMap.keys()],
      range:  [...seasonColorMap.values()]
    },
    r: { range: [2, 8] },
    x: {
      label: "Lowest temperature that night (°C)",
      labelAnchor: "center",
      reverse: true
    },
    y: {
      label: "People or couples still without a place at 4 a.m. (average)",
      labelAnchor: "top",
      grid: true
    },
    marks: [
      Plot.tickX(visibleRug, {
        x: "min_temp",
        stroke: "winter_season",
        frameAnchor: "bottom",
        strokeOpacity: 0.35,
        strokeWidth: 1
      }),
      Plot.ruleX([0, -5, -10, -15], {
        stroke: refLine,
        strokeWidth: 1,
        strokeDasharray: "4,3"
      }),
      Plot.dot(visibleBinned, {
        x: "min_temp_bin",
        y: "mean_unplaced",
        fill: "winter_season",
        r: "n"
      }),
      Plot.tip(visibleBinned, Plot.pointer({
        x: "min_temp_bin",
        y: "mean_unplaced",
        title: d =>
          `${d.winter_season}\n` +
          `About ${d.min_temp_bin} °C  ·  ${d.n} nights\n` +
          `Average still without a place: ${d.mean_unplaced.toFixed(1)}`
      }))
    ]
  })
}

Figure 1: Each dot shows the average number of single people and couples still without a shelter place at 4 a.m. on nights near that temperature. Temperatures are grouped in 2 °C steps. The City counts a couple as one call, so the number of people affected is at least as high as the chart shows. Bigger dots cover more nights.

See All Cold-Weather Findings →

The City dashboards we rebuild and check

BonQuery rebuilds Toronto’s public shelter dashboards from the City’s public data files. Our pages update when the City posts new data. They also keep older dates and show the difference between spaces that are funded, open, and used.

---

NoteMonthly Shelter System Flow

Open each dashboard directly in your browser. They work best full-screen on a phone.

• Monthly Snapshot →
• Year-to-Date Comparison →
• Historical Trends →

The three tabs below show different views of the monthly data. Each dashboard has interactive filters.

Monthly Snapshot

A point-in-time view of the shelter system for any month from January 2018 forward.

Open in a new tab →

Year-to-Date Comparison

Compare this year’s cumulative figures with the same period in earlier years.

Open in a new tab →

Historical Trends

See multi-year changes in homelessness and shelter use.

Open in a new tab →

---

NoteBeds and Spaces Today

function fmtDate(s) {
  const [y, m, d] = s.split("-").map(Number)
  return new Date(y, m - 1, d).toLocaleDateString("en-US", {
    year: "numeric", month: "long", day: "numeric"
  })
}

CITY_CENSUS_URL_TABLE = "https://www.toronto.ca/city-government/data-research-maps/research-reports/housing-and-homelessness-research-and-reports/shelter-census/"

// ── Two sources, one table ────────────────────────────────────────────────
// Open data carries the detailed and funded-capacity fields, so it is primary
// once available.
// The City's daily webpage is the fallback, used only for dates the open data
// has not reached. Precedence is decided here, at render time, so the table
// returns to open data on its own once the City publishes the missing dates.
openDates = [...new Set(daily_occ.map(r => r.date))].sort().reverse()
latestOpenDate = openDates[0]

cityDates = Object.keys(city_table.entries ?? {}).sort().reverse()
contingencyDates = cityDates.filter(d => d > latestOpenDate)

allDates = [...new Set([...openDates, ...contingencyDates])].sort().reverse()
latestDate = allDates[0]

This table adds two things to the City’s page. First, you can choose any date from January 2021 to today. The City’s page shows only its newest date. Second, the Funded but unavailable column shows beds, rooms, or spaces that had funding but were not open to use. See why the two City sources can differ.

Toronto shelter use on

latestRows = daily_occ.filter(r => r.date === latestOpenDate)

function getVal(rows, key) {
  const row = rows.find(r => r.key === key)
  return row ? row.ind : null
}

validationChecks = {
  const rows = latestRows
  const checks = []

  // Check 1: all expected keys present
  const expectedKeys = [
    "all_shelter","room_based","singles_sector","singles_shelter","allied_summ",
    "temp_summ","iso_summ","fam_total","fam_emerg","fam_trans_r","fam_hotel",
    "sng_hotel","singles_total","emerg_total","mix_emerg","men_emerg","wom_emerg",
    "yth_emerg","trans_total","mix_trans","fam_trans_b","men_trans","wom_trans",
    "yth_trans","allied_total","respites","dropin","temp_resp","hotels","iso"
  ]
  const presentKeys = new Set(rows.map(r => r.key))
  const missingKeys = expectedKeys.filter(k => !presentKeys.has(k))
  checks.push({
    name: "All expected rows present",
    pass: missingKeys.length === 0,
    detail: missingKeys.length > 0 ? `Missing: ${missingKeys.join(", ")}` : null
  })

  // Check 2: All Shelter Programs total = sum of components
  const allShelter = getVal(rows, "all_shelter")
  const compSum = ["fam_total","sng_hotel","singles_total","allied_total","temp_resp","hotels","iso"]
    .reduce((s, k) => s + (getVal(rows, k) ?? 0), 0)
  checks.push({
    name: "All Shelter Programs rollup matches components",
    pass: allShelter === compSum,
    detail: allShelter !== compSum
      ? `all_shelter.ind=${allShelter}, component sum=${compSum}, diff=${allShelter - compSum}`
      : null
  })

  // Check 3: Singles sectors total = emergency + transitional
  const singlesTotal = getVal(rows, "singles_total")
  const emergTotal = getVal(rows, "emerg_total")
  const transTotal = getVal(rows, "trans_total")
  checks.push({
    name: "Singles sectors rollup: emergency + transitional = singles total",
    pass: singlesTotal === (emergTotal + transTotal),
    detail: singlesTotal !== (emergTotal + transTotal)
      ? `singles=${singlesTotal}, emerg+trans=${emergTotal + transTotal}`
      : null
  })

  // Check 4: For every row with non-null cap, occ + unocc = cap (within 1, for rounding)
  const capRows = rows.filter(r => r.cap !== null && r.cap > 0)
  const arithFails = capRows.filter(r => Math.abs(r.occ + r.unocc - r.cap) > 0.5)
  checks.push({
    name: "Internal arithmetic: occupied + unoccupied = actual capacity",
    pass: arithFails.length === 0,
    detail: arithFails.length > 0
      ? arithFails.map(r => `${r.key}: ${r.occ}+${r.unocc}≠${r.cap}`).join("; ")
      : null
  })

  return checks
}

allPass = validationChecks.every(c => c.pass)

// ── Validation banner ─────────────────────────────────────────────────────
validationBanner = {
  const CITY_CENSUS_URL = "https://www.toronto.ca/city-government/data-research-maps/research-reports/housing-and-homelessness-research-and-reports/shelter-census/"

  if (!allPass) {
    const failedChecks = validationChecks.filter(c => !c.pass)
    return html`<div style="
      background:var(--bq-warn-bg);border:1px solid var(--bq-warn-border);border-radius:4px;
      padding:8px 14px;font-size:0.88em;color:var(--bq-warn-fg);margin-bottom:12px">
      <strong>⚠ Validation issue detected for ${fmtDate(latestOpenDate)}</strong>
      <details style="margin-top:6px">
        <summary style="cursor:pointer">Show details</summary>
        <ul style="margin:6px 0 0;padding-left:20px">
          ${failedChecks.map(c => html`<li>${c.name}${c.detail ? html` — <em>${c.detail}</em>` : ""}</li>`)}
        </ul>
      </details>
    </div>`
  }

  // ── City-vs-BonQuery banner temporarily hidden ───────────────────────────
  // Bridging & Triage (29 ppl) and known capacity differences cause the
  // current validator to always fail. Re-enable after the capacity
  // reconciliation analysis so we can show a clean ✓ / ≈ / ✗ status that
  // distinguishes documented structural differences from genuine discrepancies.
  //
  // if (cityValidation === null) {
  //   return html`<div style="
  //     background:#e9ecef;border:1px solid #adb5bd;border-radius:4px;
  //     padding:8px 14px;font-size:0.88em;color:#495057;margin-bottom:12px">
  //     Validation status unavailable in local development
  //   </div>`
  // }
  // if (!cityValidation.city_reachable) {
  //   return html`<div style="
  //     background:#fff3cd;border:1px solid #e0a800;border-radius:4px;
  //     padding:8px 14px;font-size:0.88em;color:#533f03;margin-bottom:12px">
  //     ⚠ City of Toronto shelter census page could not be reached · <a href="${CITY_CENSUS_URL}" target="_blank">View City data →</a>
  //   </div>`
  // }
  // if (cityValidation.passed && cityValidation.city_date === cityValidation.bonquery_latest_date) {
  //   return html`<div style="
  //     background:#d4edda;border:1px solid #76b88d;border-radius:4px;
  //     padding:8px 14px;font-size:0.88em;color:#1a4731;margin-bottom:12px">
  //     ✓ Validated against <a href="${CITY_CENSUS_URL}" target="_blank">City's Daily Shelter &amp; Overnight Service Usage page</a> for ${fmtDate(cityValidation.city_date)}
  //   </div>`
  // }
  // if (cityValidation.passed && cityValidation.city_date !== cityValidation.bonquery_latest_date) {
  //   return html`<div style="
  //     background:#d4edda;border:1px solid #76b88d;border-radius:4px;
  //     padding:8px 14px;font-size:0.88em;color:#1a4731;margin-bottom:12px">
  //     ✓ Last validated against <a href="${CITY_CENSUS_URL}" target="_blank">City's Daily Shelter &amp; Overnight Service Usage page</a> for ${fmtDate(cityValidation.city_date)} · BonQuery data current to ${fmtDate(cityValidation.bonquery_latest_date)}.
  //   </div>`
  // }
  // return html`<div style="
  //   background:#fff3cd;border:1px solid #e0a800;border-radius:4px;
  //   padding:8px 14px;font-size:0.88em;color:#533f03;margin-bottom:12px">
  //   ⚠ Discrepancy found for ${fmtDate(cityValidation.city_date)} — BonQuery values differ from <a href="${CITY_CENSUS_URL}" target="_blank">City's published table</a>
  // </div>`

  return html``
}

viewof selectedDate = Inputs.select(allDates, {
  label: "Date",
  format: d => fmtDate(d)
})

sourceNote = {
  if (selectedSource !== "city") {
    return html`<p class="bq-ckan-note">
      Newest open data: <strong>${fmtDate(latestOpenDate)}</strong>.
    </p>`
  }
  return html`<div class="bq-warn" style="margin:0.5rem 0 1rem;font-size:0.88em">
    <p style="margin:0">
      <strong>Temporary webpage fallback.</strong>
      The detailed Open Data file currently reaches ${fmtDate(latestOpenDate)}, so this date
      comes from its <a href="${CITY_CENSUS_URL_TABLE}" target="_blank">daily
      webpage</a>. Funded but unavailable stays blank until the detailed file
      is published.
    </p>
  </div>`
}

rowTemplate = new Map(
  daily_occ.filter(r => r.date === latestOpenDate).map(r => [r.key, r])
)

// The City's webpage reuses one row where the open data has two (a summary
// entry and a detail entry); the scrape keeps only the first occurrence.
cityKeyAliases = ({
  singles_shelter_total: ["singles_shelter_total", "singles_shelter"],
  allied_total:          ["allied_total", "allied_summ"],
  iso:                   ["iso", "iso_summ"]
})

// The City sometimes prints a section total with only an individuals count and
// leaves the rest of the row blank, as it did for Allied Services on Aug 6.
// Where every component row is present, rebuild the missing columns from them.
// The identity holds exactly on every date the City published both, so this
// reproduces the City's own arithmetic rather than inventing a figure.
//
// Done here and not in the scrape on purpose: audit_city_scrape.py reads
// city_daily_table.json as evidence of what the City actually published, and
// a derived value written into that archive would show up in the daily audit
// as though the City had published it.
cityTotalComponents = ({ allied_total: ["respites", "dropin"] })

function cityDerivedTotals(rows) {
  const byKey = new Map(rows.map(r => [r.key, r]))
  const out = new Map()
  for (const [total, parts] of Object.entries(cityTotalComponents)) {
    const t = byKey.get(total)
    if (!t || t.city_occ !== null) continue          // already published in full
    const ps = parts.map(k => byKey.get(k))
    if (ps.some(p => !p || p.city_occ === null || p.city_unocc === null
                       || p.city_cap === null)) continue
    const sum = f => ps.reduce((a, p) => a + p[f], 0)
    const occ = sum("city_occ"), cap = sum("city_cap")
    out.set(total, {
      city_occ:   occ,
      city_unocc: sum("city_unocc"),
      city_cap:   cap,
      city_rate:  cap > 0 ? Math.round(1000 * occ / cap) / 10 : null
    })
  }
  return out
}

function cityRowsFor(date) {
  const rows = (city_table.entries ?? {})[date]
  if (!rows) return []
  const patch = cityDerivedTotals(rows)
  return rows.flatMap(row => {
    const keys = cityKeyAliases[row.key] ?? [row.key]
    return keys.map(key => {
      const t = rowTemplate.get(key)
      return {
        date,
        key,
        label:       t ? t.label : row.label,
        indent:      t ? t.indent : 0,
        is_total:    t ? t.is_total : false,
        col_type:    t ? t.col_type : row.col_type,
        ind:         row.city_ind,
        occ:         (patch.get(row.key) ?? row).city_occ,
        unocc:       (patch.get(row.key) ?? row).city_unocc,
        cap:         (patch.get(row.key) ?? row).city_cap,
        rate:        (patch.get(row.key) ?? row).city_rate,
        cap_funding: null,     // the City's webpage does not publish it
        source:      "city"
      }
    })
  })
}

dayRows = {
  const open = daily_occ.filter(r => r.date === selectedDate)
  if (open.length) return open.map(r => ({...r, source: "open"}))
  return cityRowsFor(selectedDate)
}

selectedSource = dayRows.length > 0 ? dayRows[0].source : "open"

function n(v) { return v !== null && v !== undefined ? v.toLocaleString() : "—" }
function pct(v) { return v !== null && v !== undefined ? v.toFixed(1) + "%" : "—" }

function offlineCell(r) {
  if (r.cap === null || r.cap === undefined) return `<td></td>`
  if (r.cap_funding === null || r.cap_funding === undefined) return `<td></td>`
  const offline = r.cap_funding - r.cap
  if (offline <= 0) {
    return `<td class="bq-num">${offline.toLocaleString()}</td>`
  }
  return `<td class="bq-num bq-danger">${offline.toLocaleString()}</td>`
}

function tableRow(r, col1Label) {
  const pad = (r.indent ?? 0) * 16
  const cls = r.is_total ? "bq-row-total" : "bq-row"
  const bld = r.is_total ? " bq-bold" : ""
  if (r.col_type === "summary") {
    return `<tr class="${cls}">
      <td style="padding-left:${pad}px" class="${bld}">${r.label}</td>
      <td class="bq-num${bld}">${n(r.ind)}</td>
      <td></td><td></td><td></td><td></td><td></td>
    </tr>`
  }
  return `<tr class="${cls}">
    <td style="padding-left:${pad}px" class="${bld}">${r.label}</td>
    <td class="bq-num${bld}">${n(r.ind)}</td>
    <td class="bq-num">${n(r.occ)}</td>
    <td class="bq-num">${n(r.unocc)}</td>
    <td class="bq-num">${n(r.cap)}</td>
    ${offlineCell(r)}
    <td class="bq-num">${pct(r.rate)}</td>
  </tr>`
}

function sectionHeader(label, col1, col2, col3, col4) {
  return `<tr class="bq-th">
    <td>${label}</td>
    <td class="bq-num">Individuals</td>
    <td class="bq-num">${col1}</td>
    <td class="bq-num">${col2}</td>
    <td class="bq-num">${col3}</td>
    <td class="bq-num">${col4}</td>
    <td class="bq-num">Percent full</td>
  </tr>`
}

function summaryHeader() {
  return `<tr class="bq-th">
    <td>People using shelters</td>
    <td class="bq-num">People</td>
    <td colspan="5"></td>
  </tr>`
}

dailyTable = {
  const s = (key) => dayRows.find(r => r.key === key)

  const allShelterInd = s("all_shelter") ? s("all_shelter").ind : null
  const btEntry  = bt_data && bt_data.entries ? bt_data.entries[selectedDate] : null
  const btInd    = btEntry ? btEntry.bridging_triage : null
  const btStart  = bt_data && bt_data.first_captured
    ? bt_data.first_captured
    : "the date scraping began"
  const totalInd = (allShelterInd !== null && btInd !== null)
    ? allShelterInd + btInd
    : allShelterInd

  const totalAccomRow = `<tr class="bq-row-total bq-bold">
    <td>Total People Accommodated †</td>
    <td class="bq-num">${n(totalInd)}</td>
    <td></td><td></td><td></td><td></td><td></td>
  </tr>`
  const bridgingRow = btInd !== null
    ? `<tr class="bq-row-alt">
        <td style="padding-left:26px">Bridging &amp; Triage Programs</td>
        <td class="bq-num">${n(btInd)}</td>
        <td></td><td></td><td></td><td></td><td></td>
       </tr>`
    : `<tr class="bq-row-na">
        <td style="padding-left:26px">Bridging &amp; Triage Programs</td>
        <td class="bq-num" style="font-size:0.85em"
          >Not available for this date</td>
        <td></td><td></td><td></td><td></td><td></td>
       </tr>`

  const summaryKeys = ["all_shelter","room_based","singles_sector","singles_shelter","allied_summ","temp_summ","iso_summ"]
  const roomKeys    = ["fam_total","fam_emerg","fam_trans_r","fam_hotel","sng_hotel"]
  const bedKeys     = ["singles_total","emerg_total","mix_emerg","men_emerg","wom_emerg","yth_emerg",
                       "trans_total","mix_trans","fam_trans_b","men_trans","wom_trans","yth_trans"]
  const alliedKeys  = ["allied_total","respites","dropin"]

  return html`
    <div style="overflow-x:auto;margin:0 0 1rem">
    <table class="bq-table">
      ${summaryHeader()}
      ${totalAccomRow}
      ${bridgingRow}
      ${summaryKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      ${sectionHeader("Shelter programs with rooms", "Rooms used", "Rooms empty", "Rooms open to use", "Funded but unavailable")}
      ${roomKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      ${sectionHeader("Shelter programs with beds", "Beds used", "Beds empty", "Beds open to use", "Funded but unavailable")}
      ${bedKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      ${sectionHeader("Other shelter services", "Spaces used", "Spaces empty", "Spaces open to use", "Funded but unavailable")}
      ${alliedKeys.map(k => s(k) ? tableRow(s(k)) : "").join("")}

      <tr class="bq-th">
        <td>Temporary programs with beds or spaces</td>
        <td class="bq-num">People</td>
        <td class="bq-num">Used</td>
        <td class="bq-num">Empty</td>
        <td class="bq-num">Open to use</td>
        <td class="bq-num">Funded but unavailable</td>
        <td class="bq-num">Percent full</td>
      </tr>
      ${s("temp_resp") ? tableRow(s("temp_resp")) : ""}

      ${sectionHeader("Temporary programs with rooms", "Rooms used", "Rooms empty", "Rooms open to use", "Funded but unavailable")}
      ${s("hotels") ? tableRow(s("hotels")) : ""}

      ${sectionHeader("Temporary health and recovery programs", "Rooms used", "Rooms empty", "Rooms open to use", "Funded but unavailable")}
      ${s("iso") ? tableRow(s("iso")) : ""}
    </table>
    <p class="bq-footnote">
      † Total people = All Shelter Programs + Bridging &amp; Triage Programs.
      The detailed open-data file does not include Bridging &amp; Triage. BonQuery copies
      that number from the City's daily webpage when it appears. We have saved it
      since ${btStart}. If the City has not posted it, the row says "Not available
      for this date" and the total does not include it.
    </p>
    </div>`
}

We rebuild this table from the City’s public data file. The detailed file does not include Bridging & Triage Programs, so we add the number from the City’s daily webpage when it is available. The total includes that number when we have it. The webpage and open-data file can be published on different schedules. See how BonQuery combines and labels the two sources.

Contains information licensed under the Open Government Licence – Toronto. Source: City of Toronto Open Data — Daily Shelter & Overnight Service Occupancy & Capacity. Aggregated by BonQuery.

Download BonQuery’s daily data from 2021 to today: JSON · CSV

---

NoteCalls asking for shelter

These charts show the average number of calls each day to Toronto’s 24-hour shelter line. See how many calls were answered, how many callers got a shelter referral, and how many did not. Choose the dates you want to see. We rebuild the City’s Shelter System Requests for Referrals page from two open data files. See what the numbers can and cannot tell us.

• See calls asking for shelter →

Open in a new tab →

Contains information licensed under the Open Government Licence - Toronto. Source: City of Toronto Open Data, Central Intake Calls. Charts by BonQuery.

---

BonQuery checks Toronto’s public shelter data. Want to know exactly how we got the numbers? Email Miriam.