let’s make something together

Give us a call or drop by anytime, we endeavour to answer all enquiries within 24 hours on business days.

Find us

PO Box 16122 Collins Street West
Victoria 8007 Australia

Email us


Phone support

Phone: + (066) 0760 0260
+ (057) 0760 0560

Store and sync data in Firebase with Golang

  • By Reddy Sai
  • March 31, 2017

Here, I am going to describe how to store and sync data in Firebase with Golang development. Aslo, I have explained the how to connect the Firebase with Golang and authenticate using two types of credentials, namely Json and OAuth. When I first tried this, I faced some issues during connectivity, and hence thought it would be good to consolidate the process into an article.
The Firebase Real time Database, by definition, is a cloud-hosted database. This Firebase NoSQL cloud database is trending as the new go-to data storage concept. With this, data is stored as JSON, and not in the traditional format. Also, Firebase performs real time data synchronisation to every client that is connected.

How does it work?

The Firebase Real time Database lets you build rich, collaborative applications by allowing secure access to the database directly from client-side code.
Since I am describing how to implement a client of Firebase with Golang, first, we need to install the Firego package, and the fireauth package for authentication. Below are the steps:


go get -u gopkg.in/zabawaba99/firego.v1

If you want to add authentication token (as mentioned above), install the fireauth package also

go get -u github.com/zabawaba99/fireauth

If you want to add OAuth authentication by means of JWT (JSON Web Token):

go get -u golang.org/x/oauth2
go get -u golang.org/x/oauth2/google



Next, in order to use Firebase, we need to access the installed packages, as below:
import firego

  //(If fireauth has been installed by you for authentication, issue the following command)
 _ "github.com/zabawaba99/fireauth"
//(If oAuth package has been installed by you for authentication, issue the following commands)
 _ "golang.org/x/oauth2"
 _ "golang.org/x/oauth2/google"

Next, we need to generate a new firego reference:

f := firego.New("https://test-sample-application.firebaseio.com", nil)

If we have an already existing http client, we can generate the reference as below:

f := firego.New("https://test-sample-application.firebaseio.com", client)


Request Timeouts

By default, the Firebase reference will timeout after 30 seconds of trying to reach a Firebase server. You can configure this value by setting the global timeout duration, as:

firego.TimeoutDuration = time.Minute


Auth Tokens

Now, in order to set the authentication for the Firebase, we need to get the token using fireauth package.
Get the secret key from under Project Settings. The url should looks something like:
“https://console.firebase.google.com/project/YOUR_PROJECT_NAME/settings/database” or “https://console.firebase.google.com/project/YOUR_PROJECT_NAME/settings/serviceaccounts/databasesecrets”

// Create a TokenGenerator
gen := fireauth.New("<SECRET-KEY>")
// Generate a token
data := fireauth.Data{"uid": "1"}
token, err := gen.CreateToken(data, nil)
if err != nil {
 // handle error

If you don’t want authentication:

// Unauth removes the current token being used to authenticate.

Are you going to use OAuth authentication?
Then, follow as below:

jsonKey, err := ioutil.ReadFile("./json-credentials.json") // or path of whatever name you downloaded the JWT to.
if err != nil {
 // handle err
conf, err := google.JWTConfigFromJSON(jsonKey, "https://www.googleapis.com/auth/userinfo.email",
if err != nil {
 // handle err
client := conf.Client(oauth2.NoContext)
fb := firego.New("https://my-sample-app.firebaseio.com", client)

Once the authentication is done, and all has been set, we can access the set database. Let us see them below:

Get Value

Get the values of the reference.

var v map[string]interface{}
if err := f.Value(&v); err != nil {
 // handle err
fmt.Printf("%s\n", v)



Take a look at Firebase’s query parameters for more information on what each function does.

var v map[string]interface{}
if err := f.StartAt("a").EndAt("c").LimitToFirst(8).OrderBy("field").Value(&v); err != nil {
 // handle err
fmt.Printf("%s\n", v)


Set Value

Set the value of the reference.

v := map[string]string{"foo":"bar"}
if err := f.Set(v); err != nil {
 // handle err


Push Value

Push creates a reference to an auto-generated child location.

v := "bar"
pushedFirego, err := f.Push(v)
if err != nil {
 // handle err
var bar string
if err := pushedFirego.Value(&bar); err != nil {
 // handle err
// prints "https://my-sample-app.firebaseio.com/-JgvLHXszP4xS01CV-nI: bar"
fmt.Printf("%s: %s\n", pushedFirego, bar)


Update Child

Update the specific child with the given value.

v := map[string]string{"foo":"bar"}
if err := f.Update(v); err != nil {
 // handle err


Remove Value

Remove the reference from the cloud.

if err := f.Remove(); err != nil {
 // handle err


Watch a Node

The Watch function listens for any changes on an instance of the specified Firebase. The result is passed over to the given channel. Since only one connection can be established at any given time, f.StopWatching should be mandatorily issued before the next call to Watch. If not, the second or next call will result in the given channel being closed and nil being returned immediately.

event_notifications := make(chan firego.Event) //Here, we assign the channel to a variable
if err := f.Watch(event_notifications); err != nil {
 // handle err
defer f.StopWatching()
for event := range event_notifications {
 fmt.Printf("Event %#v\n", event)
fmt.Println("Notifications have stopped")


Change reference

You, by now, know that a reference is used to save or read data from a specified reference. Ref function returns a copy of an existing Firebase reference with a new path.

userID := "bar"
usersRef,err := f.Ref("users/"+userID)
if err != nil {
 // handle err
v := map[string]string{"id":userID}
if err := usersRef.Set(v); err != nil {
 // handle err


That’s it. We now have a basic idea as to how to implement a Firebase with Golang, and how to perform the basic operations on the same. As mentioned in the beginning, two options are given here for authentication on Firebase with Golang. It is simply a matter of choice.

The above example is given in detail here. You can try it out.

Also, you can check the GoDocs for more details.

We offer Golang development services for building world-class enterprise apps. We have expertise in building most complex software solutions using Google’s Go language. Chat with us now and hire golang developers within 72 hours.

Turn your vision to magnificent reality With
Our Web and Mobile Solutions