The len prefix is superficial and causes the invalid utf-8 error:

package main

import (
        "encoding/base64"
        "fmt"
        "log"
)

func main() {
        str := base64.StdEncoding.EncodeToString([]byte("Hello, playground"))
        fmt.Println(str)

        data, err := base64.StdEncoding.DecodeString(str)
        if err != nil {
                log.Fatal("error:", err)
        }

        fmt.Printf("%q\n", data)
}

(Also here)

Output

SGVsbG8sIHBsYXlncm91bmQ=
"Hello, playground"

EDIT: I read too fast, the len was not used as a prefix. dystroy got it right.

The alphabet of the standard Base64 does not contain backslash. So the qU4aaakFmjaaaaI5aaa\/EN\/aaa\/SaaaJaaa6aa+nGnk= input is not valid Base64 encoded string.

The forward slash is valid character in Base64, just not the backslash. It's possible the \/ is a sequence designating a single slash. If so, replace the \/ sequences with a single / and you're good to go.

For example:

s := `qU4aaakFmjaaaaI5aaa\/EN\/aaa\/SaaaJaaa6aa+nGnk=`
s = strings.ReplaceAll(s, `\/`, `/`)
dcd, err := base64.StdEncoding.DecodeString(s)
if err != nil {
    log.Fatal(err)
}

fmt.Println(string(dcd))

Which outputs (try it on the Go Playground):

�Ni��6�i�9i����i��i��i��i��y

If \/ is not a special sequence and you want to discard all invalid characters from the input, this is how it could be done:

var valid = map[rune]bool{}

func init() {
    for _, r := range "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" {
        valid[r] = true
    }
}

func clean(s string) string {
    return strings.Map(func(r rune) rune {
        if valid[r] {
            return r
        }
        return -1
    }, s)
}

func main() {
    s := `qU4aaakFmjaaaaI5aaa\/EN\/aaa\/SaaaJaaa6aa+nGnk=`
    s = clean(s)
    dcd, err := base64.StdEncoding.DecodeString(s)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(dcd))
}

Output is the same. Try this one on the Go Playground.

Go1.5 will have a WithPadding option on Encoding.

This also will add 2 pre-defined encodings, RawStdEncoding, and RawURLEncoding, which will have no padding.

Though since you're on app-engine, and won't have access to Go1.5 for a while, you can make some helper function to add and remove the padding as needed.

Here is an example to encode and decode strings. If you need, it could easily be adapted to work more efficiently using []byte.

func base64EncodeStripped(s string) string {
    encoded := base64.StdEncoding.EncodeToString([]byte(s))
    return strings.TrimRight(encoded, "=")
}

func base64DecodeStripped(s string) (string, error) {
    if i := len(s) % 4; i != 0 {
        s += strings.Repeat("=", 4-i)
    }
    decoded, err := base64.StdEncoding.DecodeString(s)
    return string(decoded), err
}