Decode JSON with unknown structure

I want to get a string that represents a json like this one:

{ "votes": { "option_A": "3" } }

and include a "count" key in it so it ends like this:

{ "votes": { "option_A": "3" }, "count": "1" }

This is why I planned to convert it to json so I could add the count and then
make it a string again. The problem is I don't know the structure of that
JSON, so I can't use json.Unmarshal(in, &myStruct) because that struct
varies. How can I do this?

Unmarshal into map[string]interface{}:

package main

import "encoding/json"

func main() {
	in := []byte(`{ "votes": { "option_A": "3" } }`)
	var raw map[string]interface{}
	if err := json.Unmarshal(in, &raw); err != nil {
		panic(err)
	}
	raw["count"] = 1
	out, err := json.Marshal(raw)
    if err != nil {
        panic(err)
    }
	println(string(out))
}

https://play.golang.org/p/o8ZwvgsQmoO

You really just need a single struct, and as mentioned in the comments the correct annotations on the field will yield the desired results. JSON is not some extremely variant data format, it is well defined and any piece of json, no matter how complicated and confusing it might be to you can be represented fairly easily and with 100% accuracy both by a schema and in objects in Go and most other OO programming languages. Here's an example;

package main

import (
	"fmt"
	"encoding/json"
)

type Data struct {
	Votes *Votes `json:"votes"`
	Count string `json:"count,omitempty"`
}

type Votes struct {
	OptionA string `json:"option_A"`
}

func main() {
	s := `{ "votes": { "option_A": "3" } }`
	data := &Data{
		Votes: &Votes{},
	}
	err := json.Unmarshal([]byte(s), data)
	fmt.Println(err)
	fmt.Println(data.Votes)
	s2, _ := json.Marshal(data)
	fmt.Println(string(s2))
	data.Count = "2"
	s3, _ := json.Marshal(data)
	fmt.Println(string(s3))
}

https://play.golang.org/p/ScuxESTW5i

Based on your most recent comment you could address that by using an interface{} to represent data besides the count, making the count a string and having the rest of the blob shoved into the interface{} which will accept essentially anything. That being said, Go is a statically typed language with a fairly strict type system and to reiterate, your comments stating 'it can be anything' are not true. JSON cannot be anything. For any piece of JSON there is schema and a single schema can define many many variations of JSON. I advise you take the time to understand the structure of your data rather than hacking something together under the notion that it cannot be defined when it absolutely can and is probably quite easy for someone who knows what they're doing.