> [!NOTE]
> Third-party code libraries mentioned in this page are not necessarily endorsed or supported by Google, and any described usage is not part of the official Earth Engine product documentation.

## General questions

### I have a problem, I need help!

[Post a question following this guide](https://developers.google.com/earth-engine/help#ask_a_question),
providing as much information as possible (see
[the Stack Overflow guide to asking good questions](https://stackoverflow.com/help/minimal-reproducible-example)).
This usually means:

- sending a link to a script in the Code Editor (click on the "Get Link"
  button to obtain it)

- [sharing any assets](https://developers.google.com/earth-engine/guides/access_control#set_asset_permissions)
  needed to run the script

- for failed batch tasks, report the ID of the failed task. Task IDs look
  like this: `4C25GIJBMB52PXTEJTF4JLGL`. They can be found in the Task tab of
  the Code Editor.
  [Learn more](https://developers.google.com/earth-engine/guides/processing_environments#task_id).

### Where can I read about the Earth Engine architecture?

See this paper:
[Gorelick et al. 2017](https://doi.org/10.1016/j.rse.2017.06.031).

### Are there any recommended Earth Engine tutorials not created by Google?

See the [EDU](https://developers.google.com/earth-engine/tutorials/edu) and
[Training Resources](https://developers.google.com/earth-engine/tutorials/ttt) pages.

### Are there any recommended remote sensing tutorials?

See [this free EE course](https://courses.spatialthoughts.com/end-to-end-gee.html)
by Ujaval Gandhi, which includes a video with an introduction to remote sensing.

## Earth Engine programming

### What are some common coding errors?

See the
[debugging guide](https://developers.google.com/earth-engine/guides/debugging).

### Why am I getting a "... is not a function" error?

This error occurs when Earth Engine cannot find the called method. Check the
following common causes:

**Spelling or case sensitivity** : Methods are case-sensitive. Verify
spelling against the [API Reference](https://developers.google.com/earth-engine/apidocs).

    Error: img.normalizedDiff(...) -> Correct: img.normalizedDifference(...)

**Missing type casts** : Values returned from functions like `.get()` are
generic `ee.ComputedObject` instances and must be explicitly cast. See
[Unknown object type casting](https://developers.google.com/earth-engine/guides/debugging#unknown-object-type-casting).

    Error: dict.get('val').add(5) -> Correct: ee.Number(dict.get('val')).add(5)

**Mixing client and server methods** : Ensure you are not using standard
JavaScript or Python methods (like `.push()` or `.append()`) on Earth Engine
objects. See [Avoid mixing client and server functions](https://developers.google.com/earth-engine/guides/debugging#avoid-mixing).

    Error: list.push(4) or list.append(4) -> Correct: list.add(4)

**Unavailable methods** : If the object is properly typed and the method
exists in the documentation or has worked previously but now fails,
[report a bug](https://developers.google.com/earth-engine/help#report_a_bug).

<br />

### Why can't I use basic math like `ee.Image("image") * 2`?

<br />

In EE you shouldn't mix server-side and client-side objects or operations.
All operations on EE objects are performed server-side. Any client-side
computations won't do what you intend them to do. See
[this page for more details](https://developers.google.com/earth-engine/guides/client_server).

### How can I use `for` loops or `if/else` statements?

Earth Engine programming is done using a functional language, so
loops and conditional operations should be expressed using equivalent
concepts like `map` or `filter`. See
[this page for more details](https://developers.google.com/earth-engine/tutorials/tutorial_js_03).

### How do I show text labels in my image or video?

There is no built-in support for text labels, but you can:

- Use a third-party JS package. [See example](https://code.earthengine.google.com/?scriptPath=users/gena/packages:text-test-landsat.js)
- Use a third-party Python package [geemap](https://geemap.org/).
- Use QGIS bringing in EE images using the [EE QGIS plugin](https://gee-community.github.io/qgis-earthengine-plugin/)

### Can I use some standard color palettes?

Use a third-party JS package
[ee-palettes](https://github.com/gee-community/ee-palettes).

### How do I create my own website that uses Earth Engine?

Use [Earth Engine Apps](https://developers.google.com/earth-engine/guides/apps)
for basic applications. In more complex cases,
[you can build EE-powered App Engine apps](https://developers.google.com/earth-engine/guides/app_engine_intro).

### How do Map IDs work?

Map IDs (called `mapid` throughout the API) are keys which allow clients to
fetch map tiles. Each ID is a hash created by providing an image expression to
the `getMapId` endpoint. The resulting IDs are keys which point to both the
*image expression* and the *user credentials* that will be used to generate
tiles in a later stage.

Requesting map tiles involves specifying the location of the tile (`x`, `y`,
`zoom`) as well as the `mapid` (the key to the image and credentials). The same
ID can be reused to load many map tiles. There are no limits on the reuse of
`mapid` keys, but they expire after a few hours. We don't publish
specific timeframes about how long they persist, but any code you write should
be resilient to the ID expiring.

Creating these IDs involves storing a small amount of data and validating
credentials, so it's best to reuse them for as long as possible. There's no API
quota specifically associated with the `getMapId` endpoint, but any workflow
which involves creating `mapid` objects at a rate anywhere near the rate of
fetching tiles is probably doing something wrong. Earth Engine has no API
endpoint to remove, list or manage these IDs, since these are transient
resources.

### Why does `ee.Algorithms.If()` print both the true and false case?

    function a() { print("true"); }
    function b() { print("false"); }
    // Prints 'true' and 'false'.
    ee.Algorithms.If(true, a(), b());

The `If()` algorithm works just like every other algorithm on Earth Engine in
that all its arguments have to be evaluated before the algorithm itself can run.
The algorithm gets both the `trueCase` and `falseCase` results and then picks
and returns one based on the `condition` argument, but both paths had to be
executed in order for those values to be passed into the algorithm in the first
place.

### I get the error "Request payload size exceeds the limit"

You are trying to send to Earth Engine a very large request. This typically
happens when the code uses a lot of client-side 'for' loops or constructs
a FeatureCollection out of many geometry objects. In the latter case,
instead of creating such geometries in your script, generate a CSV file
containing them and
[upload it into a table asset](https://developers.google.com/earth-engine/guides/table_upload#upload-a-csv-file).

### What the difference between `ee.Image.clip()` and `ee.Filter.bounds()`?

See [this GIS Stack Exchange thread](https://gis.stackexchange.com/questions/247955/clipping-vs-filtering-images-with-a-polygon-google-earth-engine).
The [`ee.Image.clip()`](https://developers.google.com/earth-engine/apidocs/ee-image-clip) function masks out
pixels that don't intersect a given `ee.Geometry` or `ee.Feature`, making them
transparent in visualizations and excluded in computations. You can
conceptualize it as clipping off pixels from an image.

The [`ee.Filter.bounds()`](https://developers.google.com/earth-engine/apidocs/ee-imagecollection-filterbounds)
function filters `ee.Image` objects out of an `ee.ImageCollection` based on
image intersection with an `ee.Geometry` or `ee.Feature`. It is used to limit
the scope of an analysis to only the images that intersect a given region,
which [helps to optimize expressions](https://developers.google.com/earth-engine/guides/best_practices#filter-and-select-first).

### How to convert image pixels to feature collections, with one feature per pixel?

Use the `ee.Image.sample()` function. See usage examples on the function's API
[reference page](https://developers.google.com/earth-engine/apidocs/ee-image-sample).

### What is the difference between `ee.ImageCollection.merge()` and `ee.ImageCollection.combine()`?

The [`ee.ImageCollection.merge()`](https://developers.google.com/earth-engine/apidocs/ee-imagecollection-merge)
function merges all of the images from two collections into one collection,
regardless of whether their respective images have coincident bands, metadata,
CRS, or scale. It is the union of two collections. The `combine()` method
combines the bands of matching images from two collections into a single
collection. Matching images share the same ID (`system:index` property). It is
an inner join of two collections based on image ID, where bands from matching
images are combined. For matching images, bands from the secondary image are
appended to the primary image (overwrite is optional). If there are no matching
images, an empty collection is returned.

### How to filter image collections on multiple date intervals?

See [this GIS Stack Exchange thread](https://gis.stackexchange.com/questions/287477/multiple-date-filter-google-earth-engine).
Either `merge()` multiple collections together or use `ee.Filter.or()`.

### How to create a bounding box around a given point?

    // Buffer the point by a chosen radius and then get the bounding box.
    var LNG = -117.298;
    var LAT = 45.162;
    var point = ee.Geometry.Point([LNG, LAT]);
    var buffer = point.buffer(30000); // half of box width as buffer input
    var box = buffer.bounds(); // draw a bounding box around the buffered point
    Map.centerObject(box);
    Map.addLayer(point);
    Map.addLayer(box);

    // Map the buffer and bounds procedure over a point feature collection.
    var pointCol = ee.FeatureCollection([
      ee.Feature(ee.Geometry.Point([LNG + 1, LAT])),
      ee.Feature(ee.Geometry.Point([LNG - 1, LAT]))
    ]);
    var boxCol = pointCol.map(function(feature) {
      var box = feature.buffer(30000).bounds();
      return feature.setGeometry(box.geometry());
    });
    Map.addLayer(boxCol);

## Data Catalog

### Can you add dataset X?

File a dataset request bug following
[the dataset request guide](https://developers.google.com/earth-engine/help#dataset_requests).

You can also upload data into your Earth Engine home folder. See
[Importing Raster Data](https://developers.google.com/earth-engine/guides/image_upload) and
[Importing Table Data](https://developers.google.com/earth-engine/guides/importing).

### An existing dataset has a new version

File a dataset bug following the [dataset request guide](https://developers.google.com/earth-engine/help#dataset_requests),
and indicate that you are requesting a dataset update.

### An existing dataset is not updated or is missing assets

Before reporting a problem, verify, if possible, that the selected assets
actually exist on the dataset provider's site. See
[the guide on missing images](https://developers.google.com/earth-engine/help_missing_images) for more
details.

If you are looking for an asset by filtering an `ImageCollection`, make sure
your filters are not too restrictive.

In particular, note that:

- Sentinel-2 SR (Level 2 data) were not produced by ESA for early Level 1
  scenes.

- Landsat does not have worldwide coverage before 2000.

### An existing dataset has wrong values

[Post on the developers forum](https://developers.google.com/earth-engine/help#earth_engine_developer_forum).
Include a script that zooms into the original resolution of the asset and makes
it clear to see what values are wrong. Explain where exactly you observed the
alternative value.

### Where else can I ask about datasets?

For questions about NASA datasets, see
[the NASA Earth Data forum](https://forum.earthdata.nasa.gov/viewforum.php?f=7&sid=83205cdfea62dbe374548ff25900e61c&start=75).

For questions about the toolboxes operating on Copernicus datasets, see the
[S1](http://forum.step.esa.int/c/s1tbx),
[S2](https://forum.step.esa.int/c/s2tbx), and
[S3](https://forum.step.esa.int/c/s3tbx) forums.

### How large is the EE catalog?

As of October 2023, the catalog contains over 1000 datasets. Its size on disk
is over 90 petabytes (after taking into account lossless compression).

### How often are data in EE updated?

Normally, all ongoing datasets are updated at least daily (though not all
such datasets have new data every day). Some datasets are updated several
times a day. However, there is no policy ensuring the presence of the
most recent assets in the catalog.

### How do I view the contents of the EE catalog programmatically?

The list of dataset is exported in [the STAC format](https://stacspec.org/) to
[a Google Cloud Storage bucket `gs://earthengine-stac`](https://console.cloud.google.com/storage/browser/earthengine-stac/catalog).
The entry file is
[catalog.json](https://storage.googleapis.com/earthengine-stac/catalog/catalog.json).

### Can I use Google Maps data or imagery for analysis?

Google does not license or sell basemap data for analysis.

### How can I find the date an asset was ingested?

The `'system:version'` asset property is the ingestion timestamp, formatted as
microseconds since Unix epoch. Here is an example that converts the ingestion
timestamp of a Landsat image to a human readable format.

    var image = ee.Image('LANDSAT/LC08/C02/T1_L2/LC08_044034_20210508');
    print('Ingest date', ee.Date(image.getNumber('system:version').divide(1000)));

### Does Earth Engine Catalog have JSON-LD metadata?

Yes, JSON-LD metadata are embedded in the catalog HTML pages. For example, the
[Sentinel-2 page](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_HARMONIZED) contains the following block:

    <script type="application/ld+json">
      {
        "@context": "https://schema.org",
        "@type": "BreadcrumbList",
        "itemListElement": [{
          "@type": "ListItem",
          "position": 1,
          "name": "Earth Engine Data Catalog",
          "item": "https://developers.google.com/earth-engine/datasets"
        },{
          "@type": "ListItem",
          "position": 2,
          "name": "Harmonized Sentinel-2 MSI: MultiSpectral Instrument, Level-1C",
          "item": "https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_HARMONIZED"
        }]
      }
      </script>

## Landsat

### How is the [`simpleComposite`](https://developers.google.com/earth-engine/apidocs/ee-algorithms-landsat-simplecomposite) algorithm implemented?

The server-side implementation is equivalent to
[this JavaScript code](https://code.earthengine.google.com/?scriptPath=Examples:Image+Collection/Landsat+Simple+Composite).

### How can I create cloud-free composites from Landsat surface reflectance data?

Landsat Level 2 (surface reflectance) data have several quality bands that
can be used to mask out clouds and other unwanted image artifacts. An example
of using these bands to process Landsat 8 SR images and create a median
cloud-free composite is provided in
[this GIS Stack Exchange post](https://gis.stackexchange.com/a/425160/68792).
The same procedure is used to build a cloud-free composite for use in
[supervised classification examples](https://developers.google.com/earth-engine/guides/classification) in
the Developer's Guide.

### Is cross-sensor Landsat surface reflectance harmonization needed?

[Roy et al., 2016](https://doi.org/10.1016/j.rse.2015.12.024) included an
analysis of reflectance differences between Landsat 7-8 TOA and surface
reflectance. They published the OLS and RMA coefficients so readers could
transform the reflectance values of one sensor's data to another. The final line
of the paper states: "Although sensor differences are quite small they may have
significant impact depending on the Landsat data application." However, this
analysis was based on pre-collection data.

The improvements made during Collection 1 and Collection 2 reprocessing may
influence the relationship between sensors, but as far as we know, there have
been no analyses similar to Roy et al. (2016) for Collection 1 or Collection 2
data. Despite no formal analysis, there seems to be a general consensus among
influential Landsat users that no correction is needed for Collection 2, Level
2 (surface reflectance) data. For example, in a reply to a question regarding
the need for Collection 2, Level 2 harmonization, Mike Wulder of the Landsat
Science Team noted that depending on the nature of the application of interest
(including land cover mapping and change detection), the Collection 2 surface
reflectance products are highly suitable and reliable, without need for
cross-sensor adjustment.

### How can I mask clouds and cloud shadows in MSS imagery?

The third-party [msslib module](https://github.com/gee-community/msslib)
for the JavaScript Code Editor includes an implementation of the
[MSScvm algorithm](https://jdbcode.github.io/MSScvm/imgs/braaten_et_al_2015_automated%20cloud_and_cloud_shadow_identification_in_landsat_mss_imagery_for_temperate_ecosystems.pdf),
as well as other helpful functions for exploring and preparing MSS data.

## Data Management

### Who owns the data that I upload?

According to the Earth Engine
[Terms of Service](https://earthengine.google.com/terms/), customers own the
data that they upload to Earth Engine.

### I can't upload data!

Check the upload task status in the Tasks pane in the upper right-hand
corner of the [Code Editor](https://code.earthengine.google.com/). You can also
view the
[dedicated task page](https://code.earthengine.google.com/tasks).

If there is no task, you have probably tried uploading your file through the Code
Editor, but due to a networking problem the file never finished uploading, so
the task was never created. Try using a different browser or a
different computer.

If there is a failed task, examine the error it shows. If there is no
specific error message, first verify that your file is not corrupt by running
[`gdalinfo`](https://gdal.org/programs/gdalinfo.html) for raster
files or [`ogr2ogr`](https://gdal.org/programs/ogr2ogr.html) for vector files.
These commands will try to read all the data from the source files and
display errors if the files are corrupt.

Example gdalinfo call:

    gdalinfo -mm -stats -checksum file.tif

Example ogr2ogr call that will convert `in.shp` to `out.csv`:

    ogr2ogr -lco GEOMETRY=AS_WKT -f CSV out.csv in.shp

If the file looks valid, post the failed task ID as text (not as a
screenshot) on the
[developers mailing list](https://groups.google.com/g/google-earth-engine-developers).
Task ids have this format: `4C25GIJBMB52PXTEJTF4JLGL`. Make your
source file publicly readable if possible. If it's a private file, share it
with just `earthengine@google.com` if you would like the Earth Engine team to
examine it. If it's not possible to share the source file, at least
provide the output of `gdalinfo -mm -stats -checksum`.

If Earth Engine does not support a certain projection, you will need to
reproject the data before uploading using, for example,
[`gdalwarp`](https://gdal.org/programs/gdalwarp.html).

### How do I upload a file in NetCDF or another unsupported raster format?

Only GeoTIFFs can be uploaded to Earth Engine. Other GDAL-compatible
formats can be converted to GeoTIFFs using
[`gdal_translate`](https://gdal.org/programs/gdal_translate.html). Example:

    gdal_translate -co COMPRESS=DEFLATE file.nc file.tif

Note that some NetCDF or HDF files consist of multiple sub datasets that can be
discovered with [`gdalinfo`](https://gdal.org/programs/gdalinfo.html). The
`gdal_translate` command in this case will look like this (note that path
between the double quotes):

    gdal_translate HDF4_EOS:EOS_GRID:"/tmp/MCD12Q1.A2001001.h00v08.005.2011055224312.hdf":MOD12Q1:Land_Cover_Type_1 file.tif

NetCDF files sometimes don't carry a projection that GDAL recognizes. In this
case you would need to set the projection and spatial extent in the
`gdal_translate` command line. Example:

    gdal_translate -a_srs EPSG:4326 -a_ullr -180 90 180 -90 file.nc file.tid

### What compression algorithms can I use for uploaded GeoTIFFs?

For uploading, GeoTIFFs can be compressed with DEFLATE, JPEG, JPEG-XL/JXL, LERC,
LERC_DEFLATE, LERC_ZSTD, LZMA, LZW, WEBP, or ZSTD. COGs that Earth Engine reads
in place (with `ee.Image.loadGeoTIFF()` or as COG-backed assets) can use
DEFLATE, JPEG, LZW, PACKBITS, ZSTD, or no compression (see
[COG best practices](https://developers.google.com/earth-engine/guides/cog_overview#compression_overviews_and_creation_options)).
ZSTD is a good overall choice as it is quick to decompress while still offering
good compression of most images.

To apply ZSTD compression when using `gdal_translate`, add these options. If
the data has floating point values, change the `PREDICTOR` to 3. (For files you
plan to register as COGs instead of uploading, see the
[COG registration guide](https://developers.google.com/earth-engine/guides/cog_registration#prepare_your_cogs).)

    gdal_translate in.tif out.tif \
      -co BIGTIFF=YES \
      -co TILED=YES \
      -co BLOCKXSIZE=512 \
      -co BLOCKYSIZE=512 \
      -co COMPRESS=ZSTD \
      -co PREDICTOR=2 \
      -co ZSTD_LEVEL=16 \
      -co INTERLEAVE=BAND \
      -co NUM_THREADS=ALL_CPUS

### My raster ingestion has been running for days and has not finished.

Using `gdalinfo`, check if your file has the following GDAL option set:
`INTERLEAVE=PIXEL`. For files with this option and many bands, ingestion might
never finish because the layout of such files makes reads very slow.

Try converting such files to the band-interleaved layout before uploading:

    gdal_translate -co "INTERLEAVE=BAND" src.tif dst.tif

This applies to ingestion; COG-backed assets support both interleaves (see
[single-band versus multi-band files](https://developers.google.com/earth-engine/guides/cog_overview#single-band_versus_multi-band_files)).

### My uploaded rasters don't match the basemap.

If the data is slightly offset from the basemap, the projection probably has
an incorrect datum (assumption about the shape of the Earth).
This happens most often with
the sinusoidal projection that cannot be fully encoded in GDAL metadata. When
you know what the target projection should be (e.g., `SR-ORG:6974` for files using
MODIS sinusoidal projection), set the `--crs` flag during
[command-line upload](https://developers.google.com/earth-engine/guides/command_line#upload)
or the `crs` field of the
[upload manifest](https://developers.google.com/earth-engine/guides/image_manifest).

If the data appear grossly distorted or in the completely wrong place, the
projection or the affine transform is likely wrong.

### My raster only shows up over the Eastern hemisphere.

You probably uploaded a global raster that spans the longitude range \[0, 360\].
However, Earth Engine requires rasters to be in the range \[-180, 180\].
Swap the left and right halves of the raster before ingestion.
[See these GIS Stack Exchange suggestions](https://gis.stackexchange.com/questions/37790/reprojecting-raster-from-0-360-to-180-180-with-cutting-180-meridian-using-gdalw).

### Why does my ingested classification image look speckled?

You probably used the default `MEAN`
[pyramiding policy](https://developers.google.com/earth-engine/guides/scale).
For classification images, the `MODE` pyramiding policy should be used. for
QA/bitmask images, the `SAMPLE` pyramiding policy should be used.

### I get the following error: No data value -128.0 cannot be applied to band #0 of type Short\<0, 255\>.

GDAL cannot treat single-byte bands as containing signed integers, so it
reads such bands as unsigned integers. This would conflict with negative
no data values.

If your values are actually signed integers, use
[manifest upload](https://developers.google.com/earth-engine/guides/image_manifest)
and add this to the tileset section containing your file: `data_type: "INT8"`

If your values are unsigned integers, your file has a bad nodata value. You can
override it on upload with the correct data value (or a value that never occurs,
if one exists). You can also use `gdal_translate -a_nodata` to change the nodata
value or `gdal_edit.py -unsetnodata` to remove it.

### How do I upload a file in the GeoJSON or another unsupported vector format?

Use [`ogr2ogr`](https://gdal.org/programs/ogr2ogr.html) to translate
OGR-compatible formats into CSV or SHP. Example:

    or2ogr -f "ESRI Shapefile" file.shp file.kml

Note that in CSV uploads, the geometry column can contain GeoJSON.

### I want to upload data using Python, or upload many files at once.

Use
[command-line upload](https://developers.google.com/earth-engine/guides/command_line#upload).
Such uploads require source files to be first placed into a GCS (Google
[Cloud Storage](https://cloud.google.com/storage/docs/introduction)) bucket. GCS
usage does not cost anything if you stay within the free tier limits - see
[the pricing page](https://cloud.google.com/storage/pricing#cloud-storage-always-free).

### I want to upload a large raster mosaic split into many tiles.

If the files all have the same projection and pixel size, just upload
them together into the same asset --- they will be mosaiced automatically.

If the files have different projections or pixel sizes, they cannot be mosaiced
into a single raster asset. Instead, upload each tile as a separate asset into
the same `ImageCollection` that can be mosaiced using
[`ImageCollection.mosaic()`](https://developers.google.com/earth-engine/apidocs/ee-imagecollection-mosaic)

### I am trying to upload a mosaic and get errors about mismatched tiles.

Tiles for Earth Engine raster mosaics must have the same projection and pixel
size. In addition, the tiles must align exactly on pixel boundaries.

### I am trying to upload a file from a GCS bucket, but Earth Engine cannot find it.

You may have used different Google Accounts for the GCS upload and for
connecting to Earth Engine. Make sure the GCS file is readable by the account
you use to connect to Earth Engine. If browser multilogin makes this confusing,
connect to Earth Engine in an incognito browser window.

### I want to export many assets at once.

You must export each image separately.

### I want to move or delete a `Folder` or an `ImageCollection` with a single command.

`earthengine rm -r` deletes a folder or collection and everything in it, but one
asset at a time, so a large collection can take hours. To go faster, delete the
children in parallel from a script and then delete the parent (see
[working with large collections](https://developers.google.com/earth-engine/guides/cog_registration#working_with_large_collections));
the same approach works for any flat collection or folder. A folder that
contains other folders or collections must be emptied bottom-up, since a
container can't be deleted until it's empty. To move, use
[`mv`](https://developers.google.com/earth-engine/guides/command_line#mv) the same way.

### I want to directly access Earth Engine data from outside of EE.

QGIS has an
[Earth Engine plugin](https://gee-community.github.io/qgis-earthengine-plugin/).

GDAL has an [Earth Engine driver](https://gdal.org/drivers/raster/eedai.html).

Other systems can use the EE [REST API](https://developers.google.com/earth-engine/reference).

### I would like to update a part of my Earth Engine asset without completely reingesting it.

It's not possible to update raster or vector data uploaded into EE.
Only asset metadata properties can be updated. The exception is COG-backed
assets, which you can point at an updated Cloud Storage file by
[re-registering them with overwrite enabled](https://developers.google.com/earth-engine/faq#cog_update_file).

### I am losing access to my account. What do I do with my assets?

If the policies of the original account allow data transfer, please share your
assets with another account, then copy the assets to be owned by the new
account. Use the [command-line copy utility](https://developers.google.com/earth-engine/guides/command_line#cp)
if there are many assets to move.

If an account is deleted, the assets owned by it are no longer accessible.

### My exported image is in the wrong place.

For some projections, such as sinusoidal or conic, GeoTIFF files sometimes
cannot store all the necessary projection parameters. This results in
an exported file that appears in the wrong place when viewed in desktop GIS
tools or reingested into EE.

To fix this, specify an export `crs` parameter that's known to work well
with GeoTIFF files---for example, use the EPSG code for the UTM zone
containing your area of interest.

### Exported feature collection assets don't preserve properties I set.

No `Export.table.*` functions preserve table-level properties in the output.
For many output formats (e.g. CSV, GeoJSON), there is no support for such
metadata. The `Export.table.toAsset` function could support table-level
properties, but does not at this time.

### Tables exported to Drive as CSV format are converted to XLSX format.

Depending on your Google Drive settings, CSV tables that you export from Earth
Engine can be converted to XLSX files with unintended effects, such as data type
conversions. Follow these steps to modify the behavior for subsequent exports.

1. In Google Drive on the web, click the Settings cog at the top right.
2. Click Settings.
3. Scroll to and clear "Convert uploaded files to Google Docs editor format".

## Cloud Optimized GeoTIFFs (COGs)

For background, see the [COG overview](https://developers.google.com/earth-engine/guides/cog_overview) and
the [COG registration guide](https://developers.google.com/earth-engine/guides/cog_registration).

### I shared a COG-backed asset, but my collaborators get a permission error.

A COG-backed asset is a pointer to files in your Cloud Storage bucket, so
collaborators need read access to **both** the Earth Engine asset and the
bucket. On the bucket, grant them the **Storage Object Viewer** and
**Storage Bucket Viewer** roles; a permission error on an asset they can
otherwise see usually means one of the two is missing. See
[configure permissions](https://developers.google.com/earth-engine/guides/cog_registration#configure_permissions).

### What Cloud Storage bucket location should I use to store COG assets?

Only a few US locations are supported, and Earth Engine rejects registration
and read requests for buckets anywhere else. See
[supported bucket locations](https://developers.google.com/earth-engine/guides/cog_overview#supported_cloud_storage_bucket_locations).

### I replaced a COG file in Cloud Storage. Why does the asset fail to load, or still show the old data?

When you register a COG, Earth Engine pins the file's object generation
(version), so overwriting the file in place doesn't update the asset.
Re-register the asset with the same name and overwrite enabled; you don't need
to delete it first. See
[updating, replacing, and deleting COG-backed assets](https://developers.google.com/earth-engine/guides/cog_registration#updating_assets).

### How can I tell which version of a file my COG-backed asset points to?

The asset's metadata (`ee.data.getAsset()`) shows the pinned generation as a
suffix on the file's URI. See
[object generations](https://developers.google.com/earth-engine/guides/cog_registration#object_generations).

### What happens if I delete a COG file in Cloud Storage but not the Earth Engine asset, or the other way around?

They're independent. Deleting the Earth Engine asset leaves your files in Cloud
Storage untouched, and deleting the file leaves the asset in place but normally
makes its pixels unreadable. See
[independent lifecycles](https://developers.google.com/earth-engine/guides/cog_registration#independent_lifecycles).

### What's the fastest way to delete or replace a large COG-backed `ImageCollection`?

There is no batch or recursive delete in the Earth Engine API, and
`earthengine rm -r` deletes one asset at a time. If you're replacing images,
re-register them with overwrite enabled instead of deleting them; if you're
deleting, parallelize from a script. See
[working with large collections](https://developers.google.com/earth-engine/guides/cog_registration#working_with_large_collections)
for the approach and a script.

### Why doesn't my COG registration show up in the Tasks tab?

Registering a COG is a synchronous API call that only indexes the file's
metadata, not a batch ingestion job, so it doesn't create a task. The asset is
available in the **Assets** tab as soon as the call returns. See
[submit the registration request](https://developers.google.com/earth-engine/guides/cog_registration#submit_the_registration_request).

### Can I combine several COG files into one Earth Engine asset?

Only when each file holds different bands of the same scene: list each file
as its own tileset in the manifest and map bands to tilesets. You can't mosaic
spatially adjacent files into one COG-backed asset; register each file as its
own image in an `ee.ImageCollection` and call `mosaic()`. See
[manifest restrictions](https://developers.google.com/earth-engine/guides/cog_registration#manifest_restrictions).

### Which compression schemes, tile sizes, and pixel types can COG-backed assets use?

See
[best practices for preparing external COGs](https://developers.google.com/earth-engine/guides/cog_overview#best_practices_for_preparing_external_cogs)
for the supported compression schemes, tile sizes, and pixel data types. Files
in compression formats that Earth Engine can't read directly as COGs can still
be [uploaded as standard assets](https://developers.google.com/earth-engine/faq#upload_compression).

### I get the error "The metadata of the TIFF could not be read in the first 10000000 bytes."

Earth Engine reads only the start of a file when loading or registering it;
large images with many tiles, and truncated files, exceed it. See
[choosing file dimensions](https://developers.google.com/earth-engine/guides/cog_overview#choosing_file_dimensions)
for the limit and how to stay under it.

### How does `ee.Image.loadGeoTIFF()` differ from a registered asset when the file changes?

`ee.Image.loadGeoTIFF()` reads whatever version of the file is current on each
computation or map-tile request, so it picks up replacements (unevenly on a map,
because rendered map tiles stay cached). A registered asset always pins the
generation it was registered with and must be re-registered to see a new file,
but in exchange its footprint and metadata are indexed, which is what makes it
usable in large collections. See
[reading COGs from Cloud Storage](https://developers.google.com/earth-engine/guides/cog_overview#reading_cogs_from_cloud_storage).

## Code Editor

### I cannot sign in to the Code Editor because it prompts me to use the wrong account.

[Log out](https://code.earthengine.google.com/logout), select the account
that is registered to use Earth Engine in the "Choose an account" page, and then
re-select the same account in the second "Choose an account to continue to Earth
Engine Code Editor" page (exact wording may be different).

### I want to screenshot a global map, but don't like the Web Mercator projection.

The map projection used in the Code Editor is
[Web Mercator](https://en.wikipedia.org/wiki/Web_Mercator_projection)
('EPSG:3857'). It inflates the size of objects away from the equator, making
high latitude regions appear much larger than they actually are,
as compared to regions near the equator. You cannot change the projection of the
Code Editor's map canvas, but you can "paint" an image in the projection of your
choice to the Web Mercator canvas using the `ee.Image.changeProj` method.
See the method's [API reference page](https://developers.google.com/earth-engine/apidocs/ee-image-changeproj)
for an example of displaying a global DEM to the Code Editor map in the
[Robinson projection](https://en.wikipedia.org/wiki/Robinson_projection).
Note that this technique should only be used for visualization purposes, as the
Code Editor's inspector and drawing tools are still operating in Web Mercator.

### My script does not save (`Script error: Unknown commit`).

If you receive a `Script error: Unknown commit` message when saving a script,
it likely means that the repository that you are saving to is out of sync.
The cause of this state is variable and difficult to identify. To resolve the
issue, try refreshing the script list using the button in the upper right corner
of the Script tab. If that does not work, try creating a new repository from
the New button in the Script tab and saving your script there
(you may need to move scripts into the new repository from the out-of-sync
repo).

### Why am I seeing repeated 400 errors in the Code Editor?

If you are seeing repeated 400 errors in the Code Editor, navigate to
<https://myaccount.google.com/connections>,
find "Earth Engine Code Editor" in the list of apps \& services, select it, and
then select "Delete all connections you have with Earth Engine Code Editor" and
confirm. Then open the Code Editor and re-authenticate.

### How do I recover deleted scripts and folders?

If you accidentally delete a script or folder inside an existing repository, the
full commit history is preserved in the Git logs on our servers. You can restore
deleted scripts or folders by cloning the repository locally using standard Git
command-line tools.

Deleting an entire **repository** (`users/username/repository`), however,
permanently removes the repository and its commit history from
`earthengine.googlesource.com` and can't be undone or recovered.

For step-by-step instructions on generating Git credentials, cloning your
repository, and restoring deleted files or folders, see the
[Script recovery and repository migration](https://developers.google.com/earth-engine/guides/script_recovery)
guide.

### How can I rename my script repository root?

Your script root directory (`users/username`) is bound to your original Earth
Engine account registration. It cannot be renamed directly on the backend
because doing so would break any external scripts or collaborator projects that
import your modular code using the
`require('users/username/repository:...')` path.

If you need a new namespace, the supported workaround is to migrate your work
to a new account:

1. Register a new Earth Engine account using your new Google identity (which generates a clean `users/new_username` root).
2. Follow the [repository migration instructions](https://developers.google.com/earth-engine/guides/script_recovery#option_c_migrate_a_whole_repository) to clone your old repository and push its complete history to the new empty repository.

**Important Considerations:**

- **Public Modules:** If you have public modules that others rely on, we highly recommend keeping your old account and repository active so you don't break their workflows.
- **Private Scripts:** If your scripts are entirely private, you can update your `require()` import statements to reference the new repository path and then safely delete the old repositories.