Quickstarters
How to Build a Backend for Golang?

35min
Introduction
In this tutorial, you’ll learn how to build and test a complete backend for Golang using Back4App. 
We will walk you through integrating essential Back4App features—such as database management, security settings, user authentication, file storage, and Cloud Code—to create a secure, flexible, and scalable backend that works well with your Go http server. 
Our focus will be on using Back4App’s RESTful APIs to connect to the database from our Golang http client, rather than a dedicated Parse SDK, so we can illustrate how to build easy-to-maintain handler functions for your new backend.
You will see how this approach lowers development complexity compared to setting up your own servers from scratch. 
By relying on Back4App’s real-time queries, file storage, and user authentication systems, you’ll speed up your backend creation process. 
By the end, you’ll know how to build a secure Golang backend, schedule automated tasks, and integrate external webhooks. 
You’ll be well-prepared to enhance this foundation into a production-ready application or add custom logic as needed.
Prerequisites
A Back4App account
Sign up for free here.
A new Back4App project
Getting Started with Back4app﻿
Go (Golang) development environment
Make sure you have Go installed on your machine. You can find instructions in the Go Official Docs.
Basic knowledge of Go’s http package and RESTful APIs
Familiarity with how to write a func handler, parse error messages, handle method post requests, and set up an http localhost server will help.
Ensure you have these prerequisites in place before proceeding. This setup will streamline your experience as you discover how to build a backend for Golang using Back4App.
Step 1 – Creating a New Project on Back4App and Connecting
Why a New Project?
Creating a new Back4App project is your first step. It’s where you’ll store data, configure file storage, schedule cloud functions, and add background tasks. This backend project will anchor all subsequent steps.
Log in to your Back4App account.
Click “New App” in your Back4App dashboard.
Name your app (for example, “Golang-Backend-Tutorial”).
﻿
Once created, it will appear in your dashboard. This application is now your Back4App-based backend.
Connecting via REST APIs
Back4App provides RESTful APIs to create, update, and delete data. In Golang, we’ll use the http client from Go’s standard library to communicate with these endpoints.
Locate your Application ID and REST API Key by going to the Settings or Security & Keys section of your Back4App app:
﻿
You’ll need these credentials in each request header. We’ll illustrate this in the next steps when we connect to the database using method post, GET, and other HTTP requests.
Step 2 – Setting Up the Database
Creating a Data Model
To store data in Back4App, you define classes (tables) and columns (fields). For instance, let’s say we want a Todo class. You can create it manually in the Back4App Dashboard:
Go to the Database section in your app’s dashboard.
Create a new class named “Todo.”
Add columns such as title (String) and isCompleted (Boolean).
Create New Class
﻿
You can also let the system auto-create columns by sending objects with new fields from your Golang application.
Creating a Data Model using the AI Agent
Open the AI Agent in your App Dashboard.
Describe your desired data model (e.g., “Please create a new Todo class with a title field and isCompleted field.”).
Accept the suggested schema.
﻿
This handy feature saves time in designing your database schema.
Reading and Writing Data Using REST API (Golang Example)
Below is a basic example of how to create (method POST) and fetch (method GET) data using Go’s http package. Assume you have your APPLICATION_ID and REST_API_KEY as environment variables.
Go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

type Todo struct {
    ObjectID    string `json:"objectId,omitempty"`
    Title       string `json:"title,omitempty"`
    IsCompleted bool   `json:"isCompleted,omitempty"`
}

func main() {
    // Example: Create Todo
    newTodo := Todo{
        Title:       "Buy groceries",
        IsCompleted: false,
    }
    created, err := createTodo(newTodo)
    if err != nil {
        log.Println("Error creating todo:", err)
    } else {
        log.Println("Created todo with ID:", created.ObjectID)
    }

    // Example: Fetch Todos
    todos, err := fetchAllTodos()
    if err != nil {
        log.Println("Error fetching todos:", err)
    } else {
        for _, t := range todos {
            log.Println("Fetched todo:", t.Title, t.IsCompleted)
        }
    }
}

// createTodo sends a POST request to save a new record in the "Todo" class.
func createTodo(todo Todo) (Todo, error) {
    // Convert struct to JSON
    body, _ := json.Marshal(todo)

    // Create HTTP request
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/classes/Todo", bytes.NewBuffer(body))
    if err != nil {
        return Todo{}, err
    }

    // Set necessary headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    // Execute the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return Todo{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return Todo{}, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response
    var createdTodo Todo
    if err := json.NewDecoder(resp.Body).Decode(&createdTodo); err != nil {
        return Todo{}, err
    }

    return createdTodo, nil
}

// fetchAllTodos retrieves all Todo objects from Back4App using GET
func fetchAllTodos() ([]Todo, error) {
    req, err := http.NewRequest("GET", "https://parseapi.back4app.com/classes/Todo", nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response for "results" key
    var result struct {
        Results []Todo `json:"results"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    return result.Results, nil
}
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

type Todo struct {
    ObjectID    string `json:"objectId,omitempty"`
    Title       string `json:"title,omitempty"`
    IsCompleted bool   `json:"isCompleted,omitempty"`
}

func main() {
    // Example: Create Todo
    newTodo := Todo{
        Title:       "Buy groceries",
        IsCompleted: false,
    }
    created, err := createTodo(newTodo)
    if err != nil {
        log.Println("Error creating todo:", err)
    } else {
        log.Println("Created todo with ID:", created.ObjectID)
    }

    // Example: Fetch Todos
    todos, err := fetchAllTodos()
    if err != nil {
        log.Println("Error fetching todos:", err)
    } else {
        for _, t := range todos {
            log.Println("Fetched todo:", t.Title, t.IsCompleted)
        }
    }
}

// createTodo sends a POST request to save a new record in the "Todo" class.
func createTodo(todo Todo) (Todo, error) {
    // Convert struct to JSON
    body, _ := json.Marshal(todo)

    // Create HTTP request
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/classes/Todo", bytes.NewBuffer(body))
    if err != nil {
        return Todo{}, err
    }

    // Set necessary headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    // Execute the request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return Todo{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return Todo{}, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response
    var createdTodo Todo
    if err := json.NewDecoder(resp.Body).Decode(&createdTodo); err != nil {
        return Todo{}, err
    }

    return createdTodo, nil
}

// fetchAllTodos retrieves all Todo objects from Back4App using GET
func fetchAllTodos() ([]Todo, error) {
    req, err := http.NewRequest("GET", "https://parseapi.back4app.com/classes/Todo", nil)
    if err != nil {
        return nil, err
    }

    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    // Parse response for "results" key
    var result struct {
        Results []Todo `json:"results"`
    }

    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return nil, err
    }

    return result.Results, nil
}
﻿
In these examples, we create an http client, add the necessary headers, and handle response codes along with error messages. Remember to replace YOUR_APPLICATION_ID and YOUR_REST_API_KEY with the actual keys from your Back4App project.
Reading and Writing Data Using GraphQL API
Back4App also provides a GraphQL endpoint at https://parseapi.back4app.com/graphql. You can use a popular Go GraphQL client library (like Machine Box graphql) to perform queries or mutations. This can be a more structured approach than raw REST calls.
Working with Live Queries (Optional)
If you’d like to see real-time updates in your app, you can enable Live Queries in the Back4App Dashboard. Golang does not have an official Parse Live Query library. However, you can implement your own websocket connection to listen for Live Query updates from wss://YOUR_SUBDOMAIN.b4a.io. This feature is useful for collaborative apps requiring immediate data synchronization.
Step 3 – Applying Security with ACLs and CLPs
Overview
Back4App provides Access Control Lists (ACLs) and Class-Level Permissions (CLPs) to protect your data. ACLs are defined on each object, while CLPs define overarching rules for an entire class.
﻿
Class-Level Permissions
Go to your app’s Database view in Back4App.
Select a class (e.g., Todo).
Click Class-Level Permissions and set read/write access for different user roles or public access.
﻿
ACLs
You can pass an ACL when creating or updating an object via REST calls. This ensures only certain users or roles can read/write the data. For more details, visit App Security Guidelines.
Step 4 – Writing Cloud Code Functions
Why Cloud Code
Cloud Code allows you to run server-side functions, triggers, or validations—without managing your own servers. You can add advanced business logic or integrate external APIs from the server side.
Example Cloud Function
A simple example is a function that calculates text length. In your main.js file on the Back4App dashboard:
JS
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Deployment
Deploy Cloud Code by either:
Back4App CLI:
Back4App Dashboard under Cloud Code > Functions. Paste your code in the main.js editor and click Deploy.
﻿
Calling Cloud Functions from Golang
You can call a Cloud Function via REST from your http client:
Go
func callCalculateTextLength(txt string) (int, error) {
    body, _ := json.Marshal(map[string]string{"text": txt})
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/functions/calculateTextLength", bytes.NewBuffer(body))
    if err != nil {
        return 0, err
    }

    // Headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return 0, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    var result struct {
        Result map[string]int `json:"result"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return 0, err
    }

    return result.Result["length"], nil
}
func callCalculateTextLength(txt string) (int, error) {
    body, _ := json.Marshal(map[string]string{"text": txt})
    req, err := http.NewRequest("POST", "https://parseapi.back4app.com/functions/calculateTextLength", bytes.NewBuffer(body))
    if err != nil {
        return 0, err
    }

    // Headers
    req.Header.Set("X-Parse-Application-Id", "YOUR_APPLICATION_ID")
    req.Header.Set("X-Parse-REST-API-Key", "YOUR_REST_API_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := ioutil.ReadAll(resp.Body)
        return 0, fmt.Errorf("API error: %s", string(bodyBytes))
    }

    var result struct {
        Result map[string]int `json:"result"`
    }
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return 0, err
    }

    return result.Result["length"], nil
}
﻿
Step 5 – Configuring Authentication
Enable User Authentication
Back4App uses a User class for authentication. When you create a new user via REST, the backend will store credentials securely and generate a session token.
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "secret123", "email": "[email protected]"}' \
  https://parseapi.back4app.com/users
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "secret123", "email": "alice@example.com"}' \
  https://parseapi.back4app.com/users
﻿
Use the returned session token for subsequent requests that require user privileges. In Go, you’d send the same type of HTTP request from an http client as demonstrated earlier.
Social Login
For social logins like Google or Facebook, you’ll need to configure OAuth settings on Back4App. These flows often involve exchanging tokens. Consult the Sign in With Apple / Social Login Docs for details.
Step 6 – Handling File Storage
Setup and Upload
You can store files on Back4App by sending them as base64-encoded data or multipart/form-data:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "name": "myImage.png",
      "__type": "File",
      "base64": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  }' \
  https://parseapi.back4app.com/files/myImage.png
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file": {
      "name": "myImage.png",
      "__type": "File",
      "base64": "iVBORw0KGgoAAAANSUhEUgAA..."
    }
  }' \
  https://parseapi.back4app.com/files/myImage.png
﻿
After uploading, you can attach the file to an object by storing the returned file URL or file pointer. In Go, create an http request in the same manner—just ensure you encode the file content properly.
Step 7 – Email Verification and Password Reset
Importance
Email verification ensures users control the email provided, while password reset helps them recover accounts. Both features boost security and trust.
Enabling Email Verification
Go to your Back4App Dashboard.
Under Email Settings, enable verification emails.
Customize your email templates if needed.
When a user signs up, a verification email is automatically sent to them.
Password Reset
Use the requestPasswordReset REST endpoint to initiate a password reset:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"alice@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Step 8 – Scheduling Tasks with Cloud Jobs
What Cloud Jobs Do
Cloud Jobs run on a schedule to automate tasks like cleaning stale data or sending weekly newsletters.
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  // Remove records older than 30 days
  // ...
});
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  // Remove records older than 30 days
  // ...
});
﻿
Deploy this job and schedule it in your Back4App Dashboard > App Settings > Server Settings > Background Jobs.
﻿
Step 9 – Integrating Webhooks
Why Webhooks
Webhooks let you notify external services when certain events happen. For example, you might send Slack alerts when new Todo items are created.
Go to the Webhooks section in your Back4App Dashboard.
Configure your endpoint (like https://your-external-service.com/webhook).
Assign triggers (e.g., afterSave on Todo).
Adding a Webhook
﻿
You can also trigger external APIs from Cloud Code by writing an http client request if you prefer direct control of events.
Step 10 – Exploring the Back4App Admin Panel
Overview
The Back4App Admin App is a point-and-click interface you can share with non-technical team members to manage data.
Enable the Admin App
Go to More > Admin App in your Back4App Dashboard.
Enable it and create an admin user.
Enable Admin App
﻿
Use your chosen subdomain to log in to a straightforward UI for data manipulation. This frees you from writing direct queries or custom code to perform basic operations.
Conclusion
In this guide, you discovered how to build a backend for Golang using Back4App. 
You explored how to connect to the database via RESTful APIs, apply security measures with ACLs and CLPs, run scheduled tasks with Cloud Jobs, integrate with external services using Webhooks, and set up user authentication and file storage.
With Go’s http package and Back4App’s robust features, you can craft a powerful backend that saves time and scales effortlessly. 
Now that you’ve mastered the basics, you can extend your Golang handler function logic, connect to new API endpoints, and build a rich application that meets your needs.
Next Steps
Refine your Golang app: Add advanced features like role-based access, or optimize your http server for production.
Learn more about real-time queries: Integrate Live Queries for collaborative apps.
Explore advanced Back4App documentation: Fine-tune your ACLs, logs, and analytics.
Incorporate third-party APIs: Use Cloud Code or direct webhooks to expand your backend functionality.
﻿
Updated 15 Jan 2025
Did this page help you?
How to Build a Backend for Deno?
How to Build a Backend for Symfony?