Google Earth Engine for R
Alternatives To Rgee
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
9 months ago252apache-2.0C++
Google Earth Enterprise - Open Source
Earthengine Api2,34013127 days ago211August 24, 20237apache-2.0JavaScript
Python and JavaScript bindings for calling the Earth Engine API.
Awesome Gee670
10 months agocc0-1.0
A curated list of Google Earth Engine resources
Rgee56827 days ago7September 13, 202234otherR
Google Earth Engine for R
Gee_tools45924a month ago60September 08, 202130mitPython
A collection of tools to work with Google Earth Engine Python API
Eemont36623 days ago17April 05, 20229mitPython
A python package that extends Google Earth Engine.
10 months ago5Jupyter Notebook
A series of Jupyter notebook to learn Google Earth Engine with Python
Overlappingmarkerspiderfier Leaflet217
2 years ago32CoffeeScript
Deals with overlapping markers in the Leaflet maps API, Google Earth-style
Load Google Maps Api166180473 years ago16March 07, 20202mitJavaScript
:earth_asia: A lightweight Promise-returning helper for loading the Google Maps JavaScript API
User Toolkit88
a month ago8mpl-2.0JavaScript
A repository for MapBiomas data accessing in Google Earth Engine
Alternatives To Rgee
Select To Compare

Alternative Project Comparisons

Markdownify Markdownify Markdownify
rgee: Google Earth Engine for R

rgee is an R binding package for calling Google Earth Engine API from within R. Various functions are implemented to simplify the connection with the R spatial ecosystem.

Open in Colab R build status Project Status: Active – The project has reached a stable, usable
state and is being actively
developed. codecov License lifecycle status CRAN
status DOI CRAN status
Buy Me A Coffee

Installation  • Hello World  • How does rgee work?  • Guides  • Contributing  • Citation  • Credits

What is Google Earth Engine?

Google Earth Engine is a cloud-based platform that enables users to access a petabyte-scale archive of remote sensing data and conduct geospatial analysis on Google's infrastructure. Currently, Google offers support only for Python and JavaScript. rgee fills that gap by providing support for R!. Below, you will find a comparison between the syntax of rgee and the two other client libraries supported by Google.

JS (Code Editor) Python R
var db = 'CGIAR/SRTM90_V4'
var image = ee.Image(db)
#> 'elevation'
import ee
db = 'CGIAR/SRTM90_V4'
image = ee.Image(db)
#> [u'elevation']
db <- 'CGIAR/SRTM90_V4'
image <- ee$Image(db)
#> [1] "elevation"

Quite similar, isn't it?. However, additional more minor changes should be considered when using Google Earth Engine with R. Please check the consideration section before you start coding!

How to use

NOTE: Create a .Renviron file file to prevent setting RETICULATE_PYTHON and EARTHENGINE_GCLOUD every time you authenticate/init your account.


# Set your Python ENV
Sys.setenv("RETICULATE_PYTHON" = "/usr/bin/python3")

# Set Google Cloud SDK. Only need it the first time you log in. 
Sys.setenv("EARTHENGINE_GCLOUD" = "home/csaybar/google-cloud-sdk/bin/")

# Init your Earth Session  


Install from CRAN with:


Install the development versions from github with


Furthermore, rgee depends on numpy and earthengine-api and it requires gcloud CLI to authenticate new users. The following example shows how to install and set up 'rgee' on a new Ubuntu computer. If you intend to use rgee on a server, please refer to this example in RStudio Cloud." -- https://posit.cloud/content/5175749)

install.packages(c("remotes", "googledrive"))


# Get the username
HOME <- Sys.getenv("HOME")

# 1. Install miniconda

# 2. Install Google Cloud SDK
system("curl -sSL https://sdk.cloud.google.com | bash")

# 3 Set global parameters
Sys.setenv("RETICULATE_PYTHON" = sprintf("%s/.local/share/r-miniconda/bin/python3", HOME))
Sys.setenv("EARTHENGINE_GCLOUD" = sprintf("%s/google-cloud-sdk/bin/", HOME))

# 4 Install rgee Python dependencies

# 5. Authenticate and init your EE session

There are three (3) different ways to install rgee Python dependencies:

  1. Use ee_install (Highly recommended for users with no experience with Python environments)
  1. Use ee_install_set_pyenv (Recommended for users with experience in Python environments)
  py_path = "/home/csaybar/.virtualenvs/rgee/bin/python", # Change it for your own Python PATH
  py_env = "rgee" # Change it for your own Python ENV

Take into account that the Python PATH you set must have earthengine-api and numpy installed. The use of miniconda/anaconda is mandatory for Windows users, Linux and MacOS users could also use virtualenv. See reticulate documentation for more details.

If you are using MacOS or Linux, you can choose setting the Python PATH directly:

  py_path = "/usr/bin/python3",
  py_env = NULL

However, rgee::ee_install_upgrade and reticulate::py_install will not work until you have set up a Python ENV.

  1. Use the Python PATH setting support that offer Rstudio v.1.4 >. See this tutorial.

After install Python dependencies, you might want to use the function below for checking the rgee status.

ee_check() # Check non-R dependencies

Sync rgee with other Python packages

Integrate rgee with geemap.


# 1. Initialize the Python Environment

# 2. Install geemap in the same Python ENV that use rgee
gm <- import("geemap")

Upgrade the earthengine-api


Package Conventions

  • All rgee functions have the prefix ee_. Auto-completion is your best ally :).
  • Full access to the Earth Engine API with the prefix ee$....
  • Authenticate and Initialize the Earth Engine R API with ee_Initialize. It is necessary once per session!.
  • rgee is "pipe-friendly"; we re-export %>% but do not require to use it.

Hello World

1. Compute the trend of night-time lights (JS version)

Authenticate and Initialize the Earth Engine R API.


Let's create a new band containing the image date as years since 1991 by extracting the year of the image acquisition date and subtracting it from 1991.

createTimeBand <-function(img) {
  year <- ee$Date(img$get('system:time_start'))$get('year')$subtract(1991L) 

Use your TimeBand function to map it over the night-time lights collection.

collection <- ee$

Compute a linear fit over the series of values at each pixel, so that you can visualize the y-intercept as green, and the positive/negative slopes as red/blue.

col_reduce <- collection$reduce(ee$Reducer$linearFit())
col_reduce <- col_reduce$addBands(

Let's visualize our map!

Map$setCenter(9.08203, 47.39835, 3)
  eeObject = col_reduce,
  visParams = list(
    bands = c("scale", "offset", "scale"),
    min = 0,
    max = c(0.18, 20, -0.18)
  name = "stable lights trend"


2. Let's play with some precipitation values

Install and load tidyverse and sf R packages, and initialize the Earth Engine R API.



Read the nc shapefile.

nc <- st_read(system.file("shape/nc.shp", package = "sf"), quiet = TRUE)

We will use the Terraclimate dataset to extract the monthly precipitation (Pr) from 2001

terraclimate <- ee$ImageCollection("IDAHO_EPSCOR/TERRACLIMATE") %>%
  ee$ImageCollection$filterDate("2001-01-01", "2002-01-01") %>%
  ee$ImageCollection$map(function(x) x$select("pr")) %>% # Select only precipitation bands
  ee$ImageCollection$toBands() %>% # from imagecollection to image
  ee$Image$rename(sprintf("PP_%02d",1:12)) # rename the bands of an image

ee_extract will help you to extract monthly precipitation values from the Terraclimate ImageCollection. ee_extract works similar to raster::extract, you just need to define: the ImageCollection object (x), the geometry (y), and a function to summarize the values (fun).

ee_nc_rain <- ee_extract(x = terraclimate, y = nc["NAME"], sf = FALSE)

Use ggplot2 to generate a beautiful static plot!

ee_nc_rain %>%
  pivot_longer(-NAME, names_to = "month", values_to = "pr") %>%
  mutate(month, month=gsub("PP_", "", month)) %>%
  ggplot(aes(x = month, y = pr, group = NAME, color = pr)) +
  geom_line(alpha = 0.4) +
  xlab("Month") +
  ylab("Precipitation (mm)") +

3. Create an NDVI-animation (JS version)

Install and load sf. after that, initialize the Earth Engine R API.



Define the regional bounds of animation frames and a mask to clip the NDVI data by.

mask <- system.file("shp/arequipa.shp", package = "rgee") %>%
  st_read(quiet = TRUE) %>%
region <- mask$geometry()$bounds()

Retrieve the MODIS Terra Vegetation Indices 16-Day Global 1km dataset as an ee.ImageCollection and then, select the NDVI band.

col <- ee$ImageCollection('MODIS/006/MOD13A2')$select('NDVI')

Group images by composite date

col <- col$map(function(img) {
  doy <- ee$Date(img$get('system:time_start'))$getRelative('day', 'year')
  img$set('doy', doy)
distinctDOY <- col$filterDate('2013-01-01', '2014-01-01')

Now, let's define a filter that identifies which images from the complete collection match the DOY from the distinct DOY collection.

filter <- ee$Filter$equals(leftField = 'doy', rightField = 'doy')

Define a join and convert the resulting FeatureCollection to an ImageCollection... it will take you only 2 lines of code!

join <- ee$Join$saveAll('doy_matches')
joinCol <- ee$ImageCollection(join$apply(distinctDOY, col, filter))

Apply median reduction among the matching DOY collections.

comp <- joinCol$map(function(img) {
  doyCol = ee$ImageCollection$fromImages(

Almost ready! but let's define RGB visualization parameters first.

visParams = list(
  min = 0.0,
  max = 9000.0,
  bands = "NDVI_median",
  palette = c(
    'FFFFFF', 'CE7E45', 'DF923D', 'F1B555', 'FCD163', '99B718', '74A901',
    '66A000', '529400', '3E8601', '207401', '056201', '004C00', '023B01',
    '012E01', '011D01', '011301'

Create RGB visualization images for use as animation frames.

rgbVis <- comp$map(function(img) {
  do.call(img$visualize, visParams) %>%

Let's animate this. Define GIF visualization parameters.

gifParams <- list(
  region = region,
  dimensions = 600,
  crs = 'EPSG:3857',
  framesPerSecond = 10

Get month names

dates_modis_mabbr <- distinctDOY %>%
  ee_get_date_ic %>% # Get Image Collection dates
  '[['("time_start") %>% # Select time_start column
  lubridate::month() %>% # Get the month component of the datetime
  '['(month.abb, .) # subset around month abbreviations

And finally, use ee_utils_gif_* functions to render the GIF animation and add some texts.

animation <- ee_utils_gif_creator(rgbVis, gifParams, mode = "wb")
animation %>%
    text = "NDVI: MODIS/006/MOD13A2",
    size = 15, color = "white",
    location = "+10+10"
  ) %>%
    text = dates_modis_mabbr,
    size = 30,
    location = "+290+350",
    color = "white",
    font = "arial",
    boxcolor = "#000000"
  ) # -> animation_wtxt

# ee_utils_gif_save(animation_wtxt, path = "raster_as_ee.gif")

How does rgee work?

rgee is not a native Earth Engine API like the Javascript or Python client. Developing an Earth Engine API from scratch would create too much maintenance burden, especially considering that the API is in active development. So, how is it possible to run Earth Engine using R? the answer is [reticulate]! (https://rstudio.github.io/reticulate/). reticulate is an R package designed to allow seamless interoperability between R and Python. When an Earth Engine request is created in R, reticulate will translate this request into Python and pass it to the Earth Engine Python API, which converts the request to a JSON format. Finally, the request is received by the GEE Platform through a Web REST API. The response will follow the same path in reverse.


Code of Conduct

Please note that the rgee project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.

Contributing Guide

👍 Thanks for taking the time to contribute! 🎉👍 Please review our Contributing Guide.

Share the love

Enjoying rgee? Let others know about it! Share it on Twitter, LinkedIN or in a blog post to spread the word.

Using rgee for your scientific article? here's how you can cite it

To cite rgee in publications use:

  C Aybar, Q Wu, L Bautista, R Yali and A Barja (2020) rgee: An R
  package for interacting with Google Earth Engine Journal of Open
  Source Software URL https://github.com/r-spatial/rgee/.

A BibTeX entry for LaTeX users is

  title = {rgee: An R package for interacting with Google Earth Engine},
  author = {Cesar Aybar and Quisheng Wu and Lesly Bautista and Roy Yali and Antony Barja},
  journal = {Journal of Open Source Software},
  year = {2020},


We want to offer a special thanks 🙌 👏 to Justin Braaten for his wise and helpful comments in the whole development of rgee. As well, we would like to mention the following third-party R/Python packages for contributing indirectly to the improvement of rgee:

Popular Earth Projects
Popular Google Projects
Popular Mapping Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Spatial Analysis