How start web server to open page in browser in golang?

How do I temporarily open a web page in browser using golang?

Like here is how it is done using HTTPServer in python.

Your question is a little misleading as it asks how to open a local page in the web browser, but you actually want to know how to fire up a web server so it can be opened in the browser.

For the latter (firing up a web server to serve static files), you may use the http.FileServer() function. For answers presenting it in greater detail, see: Include js file in Go template and With golang webserver where does the root of the website map onto the filesystem>.

Example serving your /tmp/data folder:

http.Handle("/", http.FileServer(http.Dir("/tmp/data")))
panic(http.ListenAndServe(":8080", nil))

If you want to serve dynamic content (generated by Go code), you can use the net/http package and write your own handler generating the response, e.g.:

func myHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello from Go")
}

func main() {
    http.HandleFunc("/", myHandler)
    panic(http.ListenAndServe(":8080", nil))
}

As to the first (to open a page in your default browser), there is no builtin support in the Go standard library. But it's not that hard, you just have to execute an OS-specific external command. You may use this cross-platform solution (which I also released in my github.com/icza/gox library, see osx.OpenDefault()):

// open opens the specified URL in the default browser of the user.
func open(url string) error {
	var cmd string
	var args []string

	switch runtime.GOOS {
	case "windows":
		cmd = "cmd"
		args = []string{"/c", "start"}
	case "darwin":
		cmd = "open"
	default: // "linux", "freebsd", "openbsd", "netbsd"
		cmd = "xdg-open"
	}
	args = append(args, url)
	return exec.Command(cmd, args...).Start()
}

This example code is taken from Gowut (which is Go Web UI Toolkit; disclosure: I'm the author).

Note that exec.Command() performs OS-specific argument quoting if needed. So for example if the URL contains &, it will be properly escaped on Linux, however, it might not work on Windows. On Windows you might have to manually quote it yourself, e.g. with replacing & signs with "^&" with a call like strings.ReplaceAll(url, "&", "^&").

Using this to open the previously started webserver in your default browser:

open("http://localhost:8080/")

One last thing to note: http.ListenAndServe() blocks and never returns (if there is no error). So you have to start the server or the browser in another goroutine, for example:

go open("http://localhost:8080/")
panic(http.ListenAndServe(":8080", nil))

Check out this question for other alternatives how to start the browser after the webserver has been started: https://stackoverflow.com/questions/32738188/go-how-can-i-start-the-browser-after-the-server-started-listening/32738973#32738973

It is quite a general problem. You can use xdg-open program to do it for you. Just run the process from Go. The xdg-open will fork by itself so we can just simply use Run and wait for the end of process.

package main

import "os/exec"

func main() {
	exec.Command("xdg-open", "http://example.com/").Run()
}

Building off of Paul's answer, here is a solution that works on Windows:

package main

import (
	"log"
	"net/http"
	"os/exec"
	"time"
)


func main() {
	http.HandleFunc("/", myHandler)
	go func() {
		<-time.After(100 * time.Millisecond)
		err := exec.Command("explorer", "http://127.0.0.1:8080").Run()
		if err != nil {
			log.Println(err)
		}
	}()

	log.Println("running at port localhost:8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

for windows simply run:

exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Run()

Last time I did something like this, I added a short delay before starting up the browser, to make sure the server had time to be listening before the browser sent the first request. On my Linux system, xdg wasn't configured quite right and rather than fixing the xdg configuration, I just hardwired it with "firefox" rather than "xdg-open". Starting the browser on the same machine as the web server made for a good thing in development. But in deployment, the web server is likely to be running on a headless remote system and it might make more sense to simply print the initial URL to the console for a copy-paste from a terminal session to the remote server into a local browser.

package main

import (
	"fmt"
	"net/http"
	"time"
)

func myHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello from Go")
}

func main() {
	http.HandleFunc("/", myHandler)
	go func() {
		<-time.After(100 * time.Millisecond)
		open("http://localhost:8080/")
	}()
	panic(http.ListenAndServe(":8080", nil))
}