Before you can deploy smart contracts or explore decentralized applications, you need a crypto wallet and access to a test network. This guide will walk you through setting up MetaMask and obtaining free POL tokens on Polygon’s Amoy testnet.

Polygon is a Layer 2 blockchain network built on top of Ethereum. It’s fully compatible with Ethereum’s Virtual Machine (EVM), which means developers can use the same tools (like Solidity and MetaMask) and deploy smart contracts on Polygon just as they would on Ethereum — but with lower fees and faster speeds. Just like a developer might test an app on a “staging” version before going live, blockchain developers use testnets to try out smart contracts and decentralized applications (dApps) without risking real funds.

Testnets behave like real blockchains but use fake tokens and simulate real-world conditions, including:

• Smart contract deployment

• Gas usage and fees

• Wallet interactions and transactions

On the Amoy Polygon testnet, you use test POL tokens, which have no real-world value. They’re distributed for free via faucets and are used to Simulate transaction costs, test smart contracts and interact with dApps before going to mainnet. Since testnets are for development and learning, the tokens don’t come from real exchanges. Instead, developers request tokens from faucets — special services that send small amounts of testnet tokens (like POL on Amoy) to your wallet.

MetaMask is one of the most widely used browser-based wallets for Ethereum and EVM-compatible chains like Polygon. It’s beginner-friendly, well-supported, integrates directly with Remix, and is available as a browser extension and mobile app.

Other wallets like Rabbi, or Trust Wallet are excellent alternatives — especially for more advanced users or specific use cases — but MetaMask remains the simplest and most universal option for getting started with smart contracts. To get started, install MetaMask and follow the steps shown in the figure below to create your wallet safely.

Understand Password vs Secret Recovery Phrase

The password you create in MetaMask only unlocks the extension on your local device. If you lose it, you can still recover your wallet on any device using your Secret Recovery Phrase. That phrase is everything. It’s a master key to your wallet — anyone with it can access your funds, and if you lose it, your wallet is gone forever. That’s why you should store it offline, ideally on paper or a hardware password manager, and never on your computer or cloud storage.

The Amoy testnet is the official test network for Polygon. To add Amoy to MetaMask open MetaMask and click the network dropdown, then click Add network > Add a network manually and enter the information below.

Network Name: Polygon Amoy
New RPC URL: https://rpc-amoy.polygon.technology
Chain ID: 80002
Currency Symbol: POL
Block Explorer URL: https://www.oklink.com/amoy

This figure below shows how it shall look when you add Amoy on Metamask. After saving, you’ll be ready to interact with dApps and smart contracts on the Polygon Amoy testnet.

To interact with the Polygon Amoy testnet, you’ll need test POL tokens to pay for transactions.

Visit the Polygon Faucet, paste your wallet address, and select Amoy as the network. To prevent spam, the faucet requires you to verify your request by connecting a GitHub or X (Twitter) account — your wallet does not need to be connected. You can also request test tokens from third-party faucets if you don’t use GitHub or X.

Once verified, request the POL tokens. They should arrive in your wallet within seconds and appear under the Amoy network, as shown in the figure below.

You can now view your wallet activity directly on the Polygon Amoy Testnet Explorer. Just paste your wallet address into the search bar, and you’ll see your balance, transactions, and history—like the receipt of your test POL tokens. From here, your wallet is ready to use: you can send and receive tokens, monitor activity, and begin connecting to decentralized applications (dApps) built for testnets.

Stay tuned — this post is the first in a series. In the next entry, we’ll deploy a simple smart contract to the Amoy testnet and connect our wallet to it, and simulate sending environmental data (like temperature) as if from an IoT sensor. You’ll learn to interact with contracts on-chain, and begin experimenting with decentralized logic in practice.

GeoPackage (GPKG) is an open and non-proprietary data format that allows different layers, both spatial and non-spatial, to be stored within the same file.
These layers can include:

• Spatial Layers with vector data such as points, lines, and polygons representing geographic features; Raster Data with gridded data representing continuous phenomena like elevation, land cover, or satellite imagery.
• Non-Spatial Layers such as tabular data: Attribute tables associated with spatial features, containing information such as attribute values, metadata, or statistical data or metadata: Descriptive information about the dataset, including authorship, data sources, coordinate reference systems, and data quality indicators.

GeoPackage’s ability to accommodate various types of spatial and non-spatial data in a single file makes it a versatile and efficient format for storing geospatial information. In this blog post, we are going to read and save geopackage’s layers using python and R.

Let’s download a simple Geopackage file. The following file comprises a GeoPackage file containing two building layers corresponding to two small cities in Italy: Grosseto and Sinalunga. First, you have to put the geopackage into your working directory. Then, you can run the code below to import the Grosseto layer and print the first rows of the dataset.

#Load the sf library
library(sf)

# Read the Grosseto layer of buildings
Grosseto = st_read("Italian_cities.gpkg", layer = "Grosseto")

# Print the first rows
head(Grosseto)

Let’s create another layer by doing a simple buffer over the buildings of Grosseto. The st_buffer function from the sf package allows doing buffer quickly. In addition, the code belows perform a buffer of 10 meters around the buildings of Grosseto. Then, the newly created layer is saved as an additional layer into the original geopackage using the st_write function.

# Perform a buffer of 10 meters
Grosseto_10B <- st_buffer(Grosseto, 10)

# Save the newly created layer
st_write(Grosseto_10B, "Italian_cities.gpkg", layer = "Grosseto_10B")

If you are new to Python, you can refer to this post to set up your Python environment with Anaconda and the Jupyter Notebook for spatial analysis. We will work with the same Geopackage file than for the R application. First, place the Geopackage in the same directory as your notebook. You can now run the code below to import a layer in Python using the GeoPandas library. In this example, we are importing a layer of building related to the italian city of Grosseto. In order to check that the layer has been imported, you can print the first rows using the .head function.

import geopandas as gpd
Grosseto = gpd.read_file("Italian_cities.gpkg", layer = "Grosseto")
Grosseto.head()

You can use the ‘to_file‘ method provided by GeoPandas to save a new layer in the GeoPackage. For example, the code below reproject the geometries in a projected CRS, perform a buffer of 10 meters and save a new layer named « buffered_Grosseto » in the GeoPackage « Italian_cities ».

# Re-project geometries to a projected CRS
Grosseto = Grosseto.to_crs(epsg=6875)

# Create a buffer of 10 meters around the geometries
buffered_Grosseto = Grosseto.buffer(10)

# Save the buffered layer to the GeoPackage file
buffered_Grosseto.to_file("Italian_cities.gpkg", driver="GPKG", layer="buffered_Grosseto")

I hope you enjoyed this short tutorial about how to work with the geopackage format in Python and R. Don’t hesitate to comment and provide feedbacks by engaging with this post.

R is an open-source statistical programming language used in statistical analysis but also in spatial analysis, artificial intelligence (AI), and machine learning (ML) applications. When coupled with RStudio, an integrated development environment (IDE) for R, it becomes user-friendly with an interactive interface. In this guide, we will walk you through the initial steps of setting up R and RStudio along with installing essential packages and testing them with spatial data.

Before diving into data mining, you need to set up the programming environment. Start by downloading and installing R from the Comprehensive R Archive Network (CRAN) website (https://cran.r-project.org/). Choose the appropriate version for your operating system and follow the installation instructions. Once R is installed, proceed to install RStudio, which provides a user-friendly interface for R programming. You can download RStudio from the official website (https://www.rstudio.com/products/rstudio/download/) and install it on your system.

The interface is divided into four parts, each fulfilling a specific role in the workflow. The Source section houses scripts, while the Console executes code and displays feedback. In Environments, users can review imported data and created objects. Finally, the Output section presents graphs, maps, and other outputs. This output section also facilitates file browsing and access to the help sections of the packages.

R’s functionality can be extended through packages, which are collections of R functions, data, and compiled code. One such essential package for spatial analysis is sf, which provides simple features (sf) for handling and analyzing spatial data. To install the sf package, open RStudio and execute the following command in the console:

install.packages("sf")

Once the sf package is installed, load it into your R session using the library() function:

library(sf)

Now, you have access to a wide range of spatial functions and data structures provided by the sf package, allowing you to manipulate and analyze spatial data efficiently.

Reading a csv file in R is straightforward using the read.csv function. Within this function, you can set a custom delimiter using the sep argument, and point at the presence of a header (first line as column titles). Don’t forget to put your file in your working directory. Alternatively, you can provide the full path to your file if your csv file is not located in your working directory. This website provides samples of csv file to download.

# Example 1: File in the working directory
read_csv = read.csv('file.csv', sep=',', header=FALSE)

# Example 2 : path to file
read_csv = read.csv('/Users/admin/file.csv', sep=',', header=FALSE)

To test the functionality of the sf package, let’s import a GeoPackage (GPKG) layer containing spatial data and visualize it on a map. You can download sample GPKG data from various sources such as governmental GIS portals or open data repositories. Assuming you have a GPKG file named example_data.gpkg, use the st_read() function from the sf package to read the spatial data into R. If you want to know more about the GeoPackage format, and try with a real Geopackage file, you can have a look at this post.

data <- st_read("path/to/example_data.gpkg")

Replace "path/to/example_data.gpkg" with the actual path to your GPKG file. If your geopackage file contains more than one layer, you can choose which layer to import using the layer = "layer_name" argument. Once the data is imported, you can create a simple map to visualize it using the plot() function

plot(data)

This will generate a basic plot displaying the spatial features contained in the GPKG layer.
R combined with RStudio provides a powerful environment for spatial analysis, AI, and ML tasks. By following the steps outlined in this guide, you’ve prepared a perfect environment for exploring more advanced techniques. Stay tuned for more tutorials and insights on leveraging R for spatial analysis. Happy coding

In this guide you’ll find clear instructions on setting up Python with Anaconda for spatial analysis. Then, we’ll cover installing Python alongside Anaconda and adding essential dependencies like GeoPandas via the Anaconda Prompt. Lastly, we’ll explore using the Jupyter Notebook for practical application. By the end, you’ll be ready to start your journey in Python-based spatial analysis, AI, and machine learning.

Anaconda is a powerful tool for managing Python environments. Indeed, Anaconda simplifies package management through its integrated package manager, conda. In addition, it comes bundled with a set of pre-installed libraries commonly used in data science and spatial analysis, such as NumPy, Pandas or Matplotlib. Therefore, this eliminates the need for manual installation and ensures immediate access to these libraries. Anaconda is also cross-platform compatible (available for Windows, macOS, and Linux) thus providing consistent Python environments across different operating systems. Furthermore, it seamlessly integrates with popular development environments like Jupyter Notebook, known amongst other things for its user-friendly interface. Visit the Anaconda website and download the Anaconda distribution related to your operating system (Windows, macOS, or Linux). Once Anaconda is installed, you’ll have access to the Anaconda Navigator, Anaconda Prompt, and other useful tools for managing Python environments.

Even if the Python distribution installed by Anaconda comes with numerous pre-installed libraries, additional dependencies will be required to enable performing advanced manipulations, and this is especially true for manipulating spatial data. So, let’s install the following three dependencies to manipulate spatial data : GeoPandas : allow spatial operations on geometric types ; Pyogrio : interoperability between spatial data formats and Contextily : retrieve tile maps from the internet.
Then, on Windows, click on the Start Menu and type “Anaconda Prompt” in the search bar and open it. This will open a new command prompt window with Anaconda enabled. Within the command prompt, run the following commands one by one to install the aforementioned dependencies.

conda install -c conda-forge geopandas 
conda install -c conda-forge pyogrio 
conda install -c conda-forge contextily

If you’ve previously installed the libraries, executing these lines will not only update the libraries themselves but also their dependencies. Additionally, any other dependencies not encompassed within the Anaconda distribution of Python can be installed using the same commands. For instance, for machine learning purposes, you can install ‘XGBoost’ (eXtreme Gradient Boosting) using these lines as well.

Now that you’ve installed Python and the required dependencies, you can open the Anaconda Navigator and launch the Jupyter Notebook from the Home tab, as follows:

Jupyter Notebook is an open-source web application that allows users to create and share documents containing live code, visualizations, and narrative text. Upon launching the notebook, you’ll be directed to the Jupyter Notebook explorer in your default web browser, where you can create folders and new notebooks with a simple right-click action, as demonstrated below.

Afterward, you can rename your notebook (indicated by arrow 1 below). In a notebook, users can compose and execute code in segmented blocks. The figure below illustrates one such block (indicated by arrow 2 below).

Your notebook is automatically linked to the files within the folders where it resides. Let’s add some data to this folder and import it into the notebook (or Python environment). Begin by downloading the dataset provided below. This dataset comprises a GeoPackage file containing two building layers corresponding to two small cities in Italy: Grosseto and Sinalunga. For further insight related the GeoPackage format, you can refer to this post. Then, once you have downloaded, place it in the same directory as your notebook.

Then, you can run the code below to import a layer in Python using GeoPandas. In this example, we are importing a layer of building related to the italian city of Grosseto.

Finally, you can run the code below to plot the building layer with a basemap from OSM using contextily.

The map above was generated using the Python code provided — demonstrating how to overlay geospatial data with a custom basemap using contextily. Fell free to provide feedbacks on our blog posts by contacting us.