diff --git a/post_test.go b/post_test.go
index 80a890c..6c4ad14 100644
--- a/post_test.go
+++ b/post_test.go
@@ -1,44 +1,44 @@
 package writeas
 
 import (
 	"testing"
 
 	"strings"
 )
 
 func TestCreatePost(t *testing.T) {
-	wac := NewClient("")
+	wac := NewClient()
 	p, err := wac.CreatePost(&PostParams{
 		Title:   "Title!",
 		Content: "This is a post.",
 		Font:    "sans",
 	})
 	if err != nil {
 		t.Errorf("Post create failed: %v", err)
 	} else {
 		t.Logf("Post created: %+v", p)
 	}
 }
 
 func TestGetPost(t *testing.T) {
-	wac := NewClient("")
+	wac := NewClient()
 
 	res, err := wac.GetPost("zekk5r9apum6p")
 	if err != nil {
 		t.Errorf("Unexpected fetch results: %+v, err: %v\n", res, err)
 	} else {
 		t.Logf("Post: %+v", res)
 		if res.Content != "This is a post." {
 			t.Errorf("Unexpected fetch results: %+v\n", res)
 		}
 	}
 
 	res, err = wac.GetPost("3psnxyhqxy3hq")
 	if err != nil {
 		t.Errorf("Unexpected fetch results: %+v, err: %v\n", res, err)
 	} else {
 		if !strings.HasPrefix(res.Content, "                               Write.as Blog") {
 			t.Errorf("Unexpected fetch results: %+v\n", res)
 		}
 	}
 }
diff --git a/writeas.go b/writeas.go
index e6f4f53..97bfbb8 100644
--- a/writeas.go
+++ b/writeas.go
@@ -1,88 +1,91 @@
 package writeas
 
 import (
 	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/writeas/impart"
 	"io"
 	"net/http"
 	"time"
 )
 
 const (
 	apiURL = "https://write.as/api"
 )
 
 type Client struct {
 	baseURL string
 
 	// Access token for the user making requests.
 	token string
 	// Client making requests to the API
 	client *http.Client
 }
 
 // defaultHTTPTimeout is the default http.Client timeout.
 const defaultHTTPTimeout = 10 * time.Second
 
-func NewClient(token string) *Client {
+func NewClient() *Client {
 	return &Client{
-		token:   token,
 		client:  &http.Client{Timeout: defaultHTTPTimeout},
 		baseURL: apiURL,
 	}
 }
 
+func (c *Client) SetToken(token string) {
+	c.token = token
+}
+
 func (c *Client) get(path string, r interface{}) (*impart.Envelope, error) {
 	method := "GET"
 	if method != "GET" && method != "HEAD" {
 		return nil, errors.New(fmt.Sprintf("Method %s not currently supported by library (only HEAD and GET).\n", method))
 	}
 
 	return c.request(method, path, nil, r)
 }
 
 func (c *Client) post(path string, data, r interface{}) (*impart.Envelope, error) {
 	b := new(bytes.Buffer)
 	json.NewEncoder(b).Encode(data)
 	return c.request("POST", path, b, r)
 }
 
 func (c *Client) request(method, path string, data io.Reader, result interface{}) (*impart.Envelope, error) {
 	url := fmt.Sprintf("%s%s", c.baseURL, path)
 	r, err := http.NewRequest(method, url, data)
 	if err != nil {
 		return nil, fmt.Errorf("Create request: %v", err)
 	}
 
 	c.prepareRequest(r)
 	resp, err := c.client.Do(r)
 	if err != nil {
 		return nil, fmt.Errorf("Request: %v", err)
 	}
 	defer resp.Body.Close()
 
 	env := &impart.Envelope{
 		Code: resp.StatusCode,
 	}
 	if result != nil {
 		env.Data = result
 	}
 
 	err = json.NewDecoder(resp.Body).Decode(&env)
 	if err != nil {
 		return nil, err
 	}
 
 	return env, nil
 }
 
 func (c *Client) prepareRequest(r *http.Request) {
 	r.Header.Add("User-Agent", "go-writeas v1")
 	r.Header.Add("Content-Type", "application/json")
 	if c.token != "" {
 		r.Header.Add("Authorization", "Token "+c.token)
 	}
 }