I would like to find a good estimate of the sum total amount of payload that humans have put into space, that is, over all years, all space programs, and all types of payload that reached orbit. Obviously a large fraction of these quickly spent more of their mass as propellant or de-orbited, so it has no physically meaning interpretation.

The total number of orbital launches each year can be found on Wikipedia.

orbital launches

It would follow that if you had the payload for each one of these launches, or a good estimate of average payload, you could find the total mass that has been sent into orbit over human history. I found one source that gives the total number of orbital launches as 5,210, which I think is as of 2010. An obvious approach is to take the number of launches, and multiply by some generic payload mass to get an estimate. So far this is the best I can find online.

There is the problem of military launches, in that we categorically don't have information about those payloads. These seem to be less than 1/3rd of the launches, so it shouldn't introduce any more error than that.

I did find one source that estimates that 255 tons were put into orbit in 2007. That year is probably not representative.

  • 2
    $\begingroup$ If you were willing to do the legwork, the Launch Log maintained by Jonathan McDowell is fairly complete, and at least will give you an idea of the specific launch vehicle and (in some cases) payload. $\endgroup$
    – user29
    Jul 16 '13 at 22:50
  • 1
    $\begingroup$ Do we even publicly know about all military launches? And do you count failed launches? Payloads that deorbited within hours or days? $\endgroup$
    – gerrit
    Jul 16 '13 at 23:50
  • 1
    $\begingroup$ @gerrit Since the starting premise is that we're counting things that later went out of orbit, it seems that anything which completed a full orbit is fairly obvious to include. Between getting into space and getting into orbit... that would be less obvious, but I would exclude them. Actually, I'm surprised you didn't mention launches going from ground to an orbit other than LEO, which is technically much more difficult to deal with. In every case, one does wonder if the category will come close to the margin of error to begin with. $\endgroup$
    – AlanSE
    Jul 17 '13 at 2:10
  • 2
    $\begingroup$ I think this is a tractable question. After all, the answer is just a single number. The details behind that number could be gathered in a spreadsheet or a gist and linked with a little summary here. I might add an as-of date to the question though. This really is the kind of question that is useful here I think. $\endgroup$
    – Erik
    Jul 20 '13 at 16:37

Using the links in Erik's answer and comments, I threw this together.


(C) 2014 Dotan Cohen

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License version 3.


import re
import time
import urllib.request
from bs4 import BeautifulSoup

def main():

    year_links = []
    year_launches = []
    total_mass = 0

    start_url = 'http://space.skyrocket.de/directories/chronology.htm'
    year_links = get_year_links(start_url)

    for link in year_links:
        launches = get_year_launches(link)
        for launch_url in launches:
            year_launches.append( launch_url )

    for launch in year_launches:
        time.sleep(0.1) # Be nice to server
        total_mass += get_launch_mass(launch)

    print("Total mass: %i KG" % (total_mass, ))

    return True

def get_year_links(start_url):

    year_links = []

    html = urllib.request.urlopen(start_url).read()
    parsed_page = BeautifulSoup(html)
    links = parsed_page.find_all('a')

    for link in links:
        link = str(link)
        if 'doc_chr' in link:
            tmp_link = link[link.find('"')+1:]
            tmp_link = tmp_link[:tmp_link.find('"')]

    return year_links

def get_year_launches(year_link):

    year_launches = []

    url = 'http://space.skyrocket.de/' + year_link[3:]
    html = urllib.request.urlopen(url).read()
    parsed_page = BeautifulSoup(html)
    links = parsed_page.find_all('a')

    for link in links:
        link = str(link)
        if 'doc_sdat' in link:
            tmp_link = link[link.find('"')+1:]
            tmp_link = tmp_link[:tmp_link.find('"')]

    return year_launches

def get_launch_mass(launch_url):

    mass = 0

        url = 'http://space.skyrocket.de/' + launch_url[3:]
        html = urllib.request.urlopen(url).read()
        parsed_page = BeautifulSoup(html)

        for pre_mass_element in parsed_page.find_all(text='Mass:'):
            mass_element = pre_mass_element.find_next()
            mass = int(re.search(r'(\d+)', mass_element.text).group(0))

    except Exception:

    return mass

if __name__ == '__main__':

The code took 54 minutes to run, here is the output:

Total mass: 10500435 KG

The code visits a website that lists launches by year, and from each year's page it visits each launch's dedicated webpage. From there the code finds the "Mass" table cell. It then extracts the text of the next cell, pulls out the first integer, and adds that to the running total mass. Python!

Since the answer is in code, it can be periodically rerun as new launches occur and as details of old launches are revised.

Update 25 December, 2017:

Total mass: 13367669 KG

Update 23 December, 2019:

$ time ./mass.py 

Total mass: 14466896 KG

real    199m30.311s
user    26m51.576s
sys     0m38.556s
  • $\begingroup$ Not every item on this page, that is shot into orbit has a mass listed. $\endgroup$
    – mike
    Apr 25 '17 at 10:43
  • $\begingroup$ Aha, almost a year has passed and I haven't tried the soup yet. OK a good reminder. Is the ~1 hour run time mostly waiting for the website, or is a lot of that local? Also, most of a rocket's mass is fuel, so it wouldn't apply to "sent to orbit". Dry mass of upper stages sometimes makes it to a real orbit. Is there any chance of breaking it down that way? $\endgroup$
    – uhoh
    Dec 25 '17 at 16:59
  • 1
    $\begingroup$ @uhoh: I havn't timed the components, but adding timers to the sleep (nice to websites) and http requests would be simple enough. If you can find a reliable source of data for the masses that you mention, I'll code it. $\endgroup$
    – dotancohen
    Dec 25 '17 at 17:06

Here is part of the answer: a chronologigal list of all orbital launches and launch attempts for each year. The other part is probably to cross this with the payload each mission delivered to orbit.

  • $\begingroup$ Yes, this is half of it. But I haven't seen any list of flights with payloads. Maybe the only option is to pair the flight list with a launch vehicle list and use the known capacity of the launch vehicles. Even if the list was incomplete, a representative of number of flights for a given payload would allow a decent estimate of average payload, but I just haven't seen this nature of data at all. $\endgroup$
    – AlanSE
    Jul 20 '13 at 17:24
  • $\begingroup$ That list I linked provides payloads, and usually mass as well. For example: space.skyrocket.de/doc_sdat/elektro-l.htm for the first mission in 2011: space.skyrocket.de/doc_chr/lau2011.htm. $\endgroup$
    – Erik
    Jul 20 '13 at 17:26

My son modified the program to dump out data yearly, and also report the number of launches with unknown payload mass. I corrected the data using:

$$m_{estimate} = m_{known}*{n\over n-n_{unknown}}$$


$m_{estimate}$ is the estimate of mass launched in a given year

$n$ is the number of launches in the year

$n_{unknown}$ is the number of launches where we don't know the payload mass in the year

$m_{known}$ is the total payload mass for those launches that list the payload mass in a year.

With this correction factor, the total tally for all years becomes 17,976,052 kg.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.