diff --git a/README.md b/README.md
index feb4549..ea4d564 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ Library webhooks
 [![Build Status](https://travis-ci.org/go-playground/webhooks.svg?branch=v4)](https://travis-ci.org/go-playground/webhooks)
 [![Coverage Status](https://coveralls.io/repos/go-playground/webhooks/badge.svg?branch=v4&service=github)](https://coveralls.io/github/go-playground/webhooks?branch=v3)
 [![Go Report Card](https://goreportcard.com/badge/go-playground/webhooks)](https://goreportcard.com/report/go-playground/webhooks)
-[![GoDoc](https://godoc.org/gopkg.in/go-playground/webhooks.v4?status.svg)](https://godoc.org/gopkg.in/go-playground/webhooks.v4)
+[![GoDoc](https://godoc.org/gopkg.in/go-playground/webhooks.v5?status.svg)](https://godoc.org/gopkg.in/go-playground/webhooks.v5)
 ![License](https://img.shields.io/dub/l/vibe-d.svg)
 
 Library webhooks allows for easy receiving and parsing of GitHub, Bitbucket and GitLab Webhook Events
@@ -24,17 +24,17 @@ Installation
 Use go get.
 
 ```shell
-go get -u gopkg.in/go-playground/webhooks.v4
+go get -u gopkg.in/go-playground/webhooks.v5
 ```
 
 Then import the package into your own code.
 
-	import "gopkg.in/go-playground/webhooks.v4"
+	import "gopkg.in/go-playground/webhooks.v5"
 
 Usage and Documentation
 ------
 
-Please see http://godoc.org/gopkg.in/go-playground/webhooks.v4 for detailed usage docs.
+Please see http://godoc.org/gopkg.in/go-playground/webhooks.v5 for detailed usage docs.
 
 ##### Examples:
 
@@ -46,8 +46,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"gopkg.in/go-playground/webhooks.v4"
-	"gopkg.in/go-playground/webhooks.v4/github"
+	"gopkg.in/go-playground/webhooks.v5"
+	"gopkg.in/go-playground/webhooks.v5/github"
 )
 
 const (
@@ -103,8 +103,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"gopkg.in/go-playground/webhooks.v4"
-	"gopkg.in/go-playground/webhooks.v4/github"
+	"gopkg.in/go-playground/webhooks.v5"
+	"gopkg.in/go-playground/webhooks.v5/github"
 )
 
 const (
diff --git a/bitbucket/bitbucket.go b/bitbucket/bitbucket.go
index e296667..4b430d7 100644
--- a/bitbucket/bitbucket.go
+++ b/bitbucket/bitbucket.go
@@ -6,7 +6,7 @@ import (
 	"io/ioutil"
 	"net/http"
 
-	"gopkg.in/go-playground/webhooks.v4"
+	"gopkg.in/go-playground/webhooks.v5"
 )
 
 // Webhook instance contains all methods needed to process events
diff --git a/bitbucket/bitbucket_test.go b/bitbucket/bitbucket_test.go
index b002eae..5351422 100644
--- a/bitbucket/bitbucket_test.go
+++ b/bitbucket/bitbucket_test.go
@@ -9,7 +9,7 @@ import (
 	"time"
 
 	. "gopkg.in/go-playground/assert.v1"
-	"gopkg.in/go-playground/webhooks.v4"
+	"gopkg.in/go-playground/webhooks.v5"
 )
 
 // NOTES:
diff --git a/examples/custom-logger/main.go b/examples/custom-logger/main.go
index 9a819d6..f15a819 100644
--- a/examples/custom-logger/main.go
+++ b/examples/custom-logger/main.go
@@ -5,8 +5,8 @@ import (
 	"log"
 	"strconv"
 
-	"gopkg.in/go-playground/webhooks.v4"
-	"gopkg.in/go-playground/webhooks.v4/github"
+	"gopkg.in/go-playground/webhooks.v5"
+	"gopkg.in/go-playground/webhooks.v5/github"
 )
 
 const (
diff --git a/examples/multiple-handlers/main.go b/examples/multiple-handlers/main.go
index 5b4b85e..d96e761 100644
--- a/examples/multiple-handlers/main.go
+++ b/examples/multiple-handlers/main.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"gopkg.in/go-playground/webhooks.v4"
-	"gopkg.in/go-playground/webhooks.v4/github"
+	"gopkg.in/go-playground/webhooks.v5"
+	"gopkg.in/go-playground/webhooks.v5/github"
 )
 
 const (
diff --git a/examples/single-handler/main.go b/examples/single-handler/main.go
index 667d63d..72b7c69 100644
--- a/examples/single-handler/main.go
+++ b/examples/single-handler/main.go
@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strconv"
 
-	"gopkg.in/go-playground/webhooks.v4"
-	"gopkg.in/go-playground/webhooks.v4/github"
+	"gopkg.in/go-playground/webhooks.v5"
+	"gopkg.in/go-playground/webhooks.v5/github"
 )
 
 const (
diff --git a/github/github.go b/github/github.go
index 656dbc7..800d2e3 100644
--- a/github/github.go
+++ b/github/github.go
@@ -5,24 +5,23 @@ import (
 	"crypto/sha1"
 	"encoding/hex"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net/http"
-
-	"gopkg.in/go-playground/webhooks.v4"
 )
 
-// Webhook instance contains all methods needed to process events
-type Webhook struct {
-	provider   webhooks.Provider
-	secret     string
-	eventFuncs map[Event]webhooks.ProcessPayloadFunc
-}
-
-// Config defines the configuration to create a new GitHub Webhook instance
-type Config struct {
-	Secret string
-}
+// parse errros
+var (
+	ErrEventNotSpecifiedToParse  = errors.New("No Event specified to parse")
+	ErrInvalidHTTPMethod         = errors.New("Invalid HTTP Method")
+	ErrMissingGithubEventHeader  = errors.New("Missing X-GitHub-Event Header")
+	ErrMissingHubSignatureHeader = errors.New("Missing X-Hub-Signature")
+	ErrEventNotFound             = errors.New("Event not defined to be parsed")
+	ErrParsingPayload            = errors.New("Error Reading Payload")
+	ErrHMACVerificationFailed    = errors.New("HMAC verification failed")
+)
 
 // Event defines a GitHub hook event type
 type Event string
@@ -76,217 +75,221 @@ const (
 	IssueSubtype  EventSubtype = "issues"
 )
 
+// Option is a configuration option for the webhook
+type Option func(*Webhook) error
+
+// Options is a namespace var for configuration options
+var Options = WebhookOptions{}
+
+// WebhookOptions is a namespace for configuration option methods
+type WebhookOptions struct{}
+
+// Secret registers the GitHub secret
+func (WebhookOptions) Secret(secret string) Option {
+	return func(hook *Webhook) error {
+		hook.secret = secret
+		return nil
+	}
+}
+
+// Webhook instance contains all methods needed to process events
+type Webhook struct {
+	secret string
+}
+
 // New creates and returns a WebHook instance denoted by the Provider type
-func New(config *Config) *Webhook {
-	return &Webhook{
-		provider:   webhooks.GitHub,
-		secret:     config.Secret,
-		eventFuncs: map[Event]webhooks.ProcessPayloadFunc{},
+func New(options ...Option) (*Webhook, error) {
+	hook := new(Webhook)
+	for _, opt := range options {
+		if err := opt(hook); err != nil {
+			return nil, errors.New("Error applying Option")
+		}
 	}
+	return hook, nil
 }
 
-// Provider returns the current hooks provider ID
-func (hook Webhook) Provider() webhooks.Provider {
-	return hook.provider
-}
+// Parse verifies and parses the events specified and returns the payload object or an error
+func (hook Webhook) Parse(r *http.Request, events ...Event) (interface{}, error) {
+	defer func() {
+		_, _ = io.Copy(ioutil.Discard, r.Body)
+		_ = r.Body.Close()
+	}()
 
-// RegisterEvents registers the function to call when the specified event(s) are encountered
-func (hook Webhook) RegisterEvents(fn webhooks.ProcessPayloadFunc, events ...Event) {
-
-	for _, event := range events {
-		hook.eventFuncs[event] = fn
+	if len(events) == 0 {
+		return nil, ErrEventNotSpecifiedToParse
+	}
+	if r.Method != http.MethodPost {
+		return nil, ErrInvalidHTTPMethod
 	}
-}
-
-// ParsePayload parses and verifies the payload and fires off the mapped function, if it exists.
-func (hook Webhook) ParsePayload(w http.ResponseWriter, r *http.Request) {
-	webhooks.DefaultLog.Info("Parsing Payload...")
 
 	event := r.Header.Get("X-GitHub-Event")
 	if len(event) == 0 {
-		webhooks.DefaultLog.Error("Missing X-GitHub-Event Header")
-		http.Error(w, "400 Bad Request - Missing X-GitHub-Event Header", http.StatusBadRequest)
-		return
+		return nil, ErrMissingGithubEventHeader
 	}
-	webhooks.DefaultLog.Debug(fmt.Sprintf("X-GitHub-Event:%s", event))
-
 	gitHubEvent := Event(event)
 
-	fn, ok := hook.eventFuncs[gitHubEvent]
-	// if no event registered
-	if !ok {
-		webhooks.DefaultLog.Info(fmt.Sprintf("Webhook Event %s not registered, it is recommended to setup only events in github that will be registered in the webhook to avoid unnecessary traffic and reduce potential attack vectors.", event))
-		return
+	var found bool
+	for _, evt := range events {
+		if evt == gitHubEvent {
+			found = true
+			break
+		}
+	}
+	// event not defined to be parsed
+	if !found {
+		return nil, ErrEventNotFound
 	}
 
 	payload, err := ioutil.ReadAll(r.Body)
 	if err != nil || len(payload) == 0 {
-		webhooks.DefaultLog.Error("Issue reading Payload")
-		http.Error(w, "Issue reading Payload", http.StatusInternalServerError)
-		return
+		return nil, ErrParsingPayload
 	}
-	webhooks.DefaultLog.Debug(fmt.Sprintf("Payload:%s", string(payload)))
 
 	// If we have a Secret set, we should check the MAC
 	if len(hook.secret) > 0 {
-		webhooks.DefaultLog.Info("Checking secret")
 		signature := r.Header.Get("X-Hub-Signature")
 		if len(signature) == 0 {
-			webhooks.DefaultLog.Error("Missing X-Hub-Signature required for HMAC verification")
-			http.Error(w, "403 Forbidden - Missing X-Hub-Signature required for HMAC verification", http.StatusForbidden)
-			return
+			return nil, ErrMissingHubSignatureHeader
 		}
-		webhooks.DefaultLog.Debug(fmt.Sprintf("X-Hub-Signature:%s", signature))
-
 		mac := hmac.New(sha1.New, []byte(hook.secret))
 		mac.Write(payload)
-
 		expectedMAC := hex.EncodeToString(mac.Sum(nil))
 
 		if !hmac.Equal([]byte(signature[5:]), []byte(expectedMAC)) {
-			webhooks.DefaultLog.Error("HMAC verification failed")
-			http.Error(w, "403 Forbidden - HMAC verification failed", http.StatusForbidden)
-			return
+			return nil, ErrHMACVerificationFailed
 		}
 	}
 
-	// Make headers available to ProcessPayloadFunc as a webhooks type
-	hd := webhooks.Header(r.Header)
-
 	switch gitHubEvent {
 	case CommitCommentEvent:
-		var cc CommitCommentPayload
-		json.Unmarshal([]byte(payload), &cc)
-		hook.runProcessPayloadFunc(fn, cc, hd)
+		var pl CommitCommentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case CreateEvent:
-		var c CreatePayload
-		json.Unmarshal([]byte(payload), &c)
-		hook.runProcessPayloadFunc(fn, c, hd)
+		var pl CreatePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case DeleteEvent:
-		var d DeletePayload
-		json.Unmarshal([]byte(payload), &d)
-		hook.runProcessPayloadFunc(fn, d, hd)
+		var pl DeletePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case DeploymentEvent:
-		var d DeploymentPayload
-		json.Unmarshal([]byte(payload), &d)
-		hook.runProcessPayloadFunc(fn, d, hd)
+		var pl DeploymentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case DeploymentStatusEvent:
-		var d DeploymentStatusPayload
-		json.Unmarshal([]byte(payload), &d)
-		hook.runProcessPayloadFunc(fn, d, hd)
+		var pl DeploymentStatusPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case ForkEvent:
-		var f ForkPayload
-		json.Unmarshal([]byte(payload), &f)
-		hook.runProcessPayloadFunc(fn, f, hd)
+		var pl ForkPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case GollumEvent:
-		var g GollumPayload
-		json.Unmarshal([]byte(payload), &g)
-		hook.runProcessPayloadFunc(fn, g, hd)
+		var pl GollumPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case InstallationEvent, IntegrationInstallationEvent:
-		var i InstallationPayload
-		json.Unmarshal([]byte(payload), &i)
-		hook.runProcessPayloadFunc(fn, i, hd)
+		var pl InstallationPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case IssueCommentEvent:
-		var i IssueCommentPayload
-		json.Unmarshal([]byte(payload), &i)
-		hook.runProcessPayloadFunc(fn, i, hd)
+		var pl IssueCommentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case IssuesEvent:
-		var i IssuesPayload
-		json.Unmarshal([]byte(payload), &i)
-		hook.runProcessPayloadFunc(fn, i, hd)
+		var pl IssuesPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case LabelEvent:
-		var l LabelPayload
-		json.Unmarshal([]byte(payload), &l)
-		hook.runProcessPayloadFunc(fn, l, hd)
+		var pl LabelPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case MemberEvent:
-		var m MemberPayload
-		json.Unmarshal([]byte(payload), &m)
-		hook.runProcessPayloadFunc(fn, m, hd)
+		var pl MemberPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case MembershipEvent:
-		var m MembershipPayload
-		json.Unmarshal([]byte(payload), &m)
-		hook.runProcessPayloadFunc(fn, m, hd)
+		var pl MembershipPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case MilestoneEvent:
-		var m MilestonePayload
-		json.Unmarshal([]byte(payload), &m)
-		hook.runProcessPayloadFunc(fn, m, hd)
+		var pl MilestonePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case OrganizationEvent:
-		var o OrganizationPayload
-		json.Unmarshal([]byte(payload), &o)
-		hook.runProcessPayloadFunc(fn, o, hd)
+		var pl OrganizationPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case OrgBlockEvent:
-		var o OrgBlockPayload
-		json.Unmarshal([]byte(payload), &o)
-		hook.runProcessPayloadFunc(fn, o, hd)
+		var pl OrgBlockPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case PageBuildEvent:
-		var p PageBuildPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl PageBuildPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case PingEvent:
-		var p PingPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl PingPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case ProjectCardEvent:
-		var p ProjectCardPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl ProjectCardPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case ProjectColumnEvent:
-		var p ProjectColumnPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl ProjectColumnPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case ProjectEvent:
-		var p ProjectPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl ProjectPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case PublicEvent:
-		var p PublicPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl PublicPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case PullRequestEvent:
-		var p PullRequestPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl PullRequestPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case PullRequestReviewEvent:
-		var p PullRequestReviewPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl PullRequestReviewPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case PullRequestReviewCommentEvent:
-		var p PullRequestReviewCommentPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl PullRequestReviewCommentPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case PushEvent:
-		var p PushPayload
-		json.Unmarshal([]byte(payload), &p)
-		hook.runProcessPayloadFunc(fn, p, hd)
+		var pl PushPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case ReleaseEvent:
-		var r ReleasePayload
-		json.Unmarshal([]byte(payload), &r)
-		hook.runProcessPayloadFunc(fn, r, hd)
+		var pl ReleasePayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case RepositoryEvent:
-		var r RepositoryPayload
-		json.Unmarshal([]byte(payload), &r)
-		hook.runProcessPayloadFunc(fn, r, hd)
+		var pl RepositoryPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case StatusEvent:
-		var s StatusPayload
-		json.Unmarshal([]byte(payload), &s)
-		hook.runProcessPayloadFunc(fn, s, hd)
+		var pl StatusPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case TeamEvent:
-		var t TeamPayload
-		json.Unmarshal([]byte(payload), &t)
-		hook.runProcessPayloadFunc(fn, t, hd)
+		var pl TeamPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case TeamAddEvent:
-		var t TeamAddPayload
-		json.Unmarshal([]byte(payload), &t)
-		hook.runProcessPayloadFunc(fn, t, hd)
+		var pl TeamAddPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
 	case WatchEvent:
-		var w WatchPayload
-		json.Unmarshal([]byte(payload), &w)
-		hook.runProcessPayloadFunc(fn, w, hd)
+		var pl WatchPayload
+		err = json.Unmarshal([]byte(payload), &pl)
+		return pl, err
+	default:
+		return nil, fmt.Errorf("unknown event %s", gitHubEvent)
 	}
 }
-
-func (hook Webhook) runProcessPayloadFunc(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
-	go func(fn webhooks.ProcessPayloadFunc, results interface{}, header webhooks.Header) {
-		fn(results, header)
-	}(fn, results, header)
-}
diff --git a/github/github_test.go b/github/github_test.go
index f993e69..096fa62 100644
--- a/github/github_test.go
+++ b/github/github_test.go
@@ -2,14 +2,13 @@ package github
 
 import (
 	"bytes"
+	"log"
 	"net/http"
+	"net/http/httptest"
 	"os"
-	"strconv"
 	"testing"
-	"time"
 
 	. "gopkg.in/go-playground/assert.v1"
-	"gopkg.in/go-playground/webhooks.v4"
 )
 
 // NOTES:
@@ -24,109 +23,81 @@ import (
 //
 
 const (
-	port = 3010
 	path = "/webhooks"
 )
 
-// HandlePayload handles GitHub event(s)
-func HandlePayload(payload interface{}, header webhooks.Header) {
-
-}
-
 var hook *Webhook
 
 func TestMain(m *testing.M) {
 
 	// setup
-	hook = New(&Config{Secret: "IsWishesWereHorsesWedAllBeEatingSteak!"})
-	hook.RegisterEvents(
-		HandlePayload,
-		CommitCommentEvent,
-		CreateEvent,
-		DeleteEvent,
-		DeploymentEvent,
-		DeploymentStatusEvent,
-		ForkEvent,
-		GollumEvent,
-		InstallationEvent,
-		IntegrationInstallationEvent,
-		IssueCommentEvent,
-		IssuesEvent,
-		LabelEvent,
-		MemberEvent,
-		MembershipEvent,
-		MilestoneEvent,
-		OrganizationEvent,
-		OrgBlockEvent,
-		PageBuildEvent,
-		PingEvent,
-		ProjectCardEvent,
-		ProjectColumnEvent,
-		ProjectEvent,
-		PublicEvent,
-		PullRequestEvent,
-		PullRequestReviewEvent,
-		PullRequestReviewCommentEvent,
-		PushEvent,
-		ReleaseEvent,
-		RepositoryEvent,
-		StatusEvent,
-		TeamEvent,
-		TeamAddEvent,
-		WatchEvent,
-	)
-
-	go webhooks.Run(hook, "127.0.0.1:"+strconv.Itoa(port), path)
-	time.Sleep(time.Millisecond * 500)
-
+	var err error
+	hook, err = New(Options.Secret("IsWishesWereHorsesWedAllBeEatingSteak!"))
+	if err != nil {
+		log.Fatal(err)
+	}
 	os.Exit(m.Run())
-
 	// teardown
 }
 
-func TestProvider(t *testing.T) {
-	Equal(t, hook.Provider(), webhooks.GitHub)
+func newServer(handler http.HandlerFunc) *httptest.Server {
+	mux := http.NewServeMux()
+	mux.HandleFunc(path, handler)
+	return httptest.NewServer(mux)
 }
 
 func TestBadNoEventHeader(t *testing.T) {
+	var parseError error
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		_, parseError = hook.Parse(r, CreateEvent)
+	})
+	defer server.Close()
+
 	payload := "{}"
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
-	req.Header.Set("Content-Type", "application/json")
-
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
 	Equal(t, err, nil)
 
+	req.Header.Set("Content-Type", "application/json")
+
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
-	Equal(t, resp.StatusCode, http.StatusBadRequest)
+	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, ErrMissingGithubEventHeader)
 }
 
 func TestUnsubscribedEvent(t *testing.T) {
+	var parseError error
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		_, parseError = hook.Parse(r, CreateEvent)
+	})
+	defer server.Close()
 	payload := "{}"
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
+
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "noneexistant_event")
 
-	Equal(t, err, nil)
-
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, ErrEventNotFound)
 }
 
 func TestBadBody(t *testing.T) {
+	var parseError error
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		_, parseError = hook.Parse(r, CommitCommentEvent)
+	})
+	defer server.Close()
 	payload := ""
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "commit_comment")
 	req.Header.Set("X-Hub-Signature", "sha1=156404ad5f721c53151147f3d3d302329f95a3ab")
@@ -136,16 +107,20 @@ func TestBadBody(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
-	Equal(t, resp.StatusCode, http.StatusInternalServerError)
+	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, ErrParsingPayload)
 }
 
 func TestBadSignatureLength(t *testing.T) {
+	var parseError error
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		_, parseError = hook.Parse(r, CommitCommentEvent)
+	})
+	defer server.Close()
 	payload := "{}"
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "commit_comment")
 	req.Header.Set("X-Hub-Signature", "")
@@ -155,16 +130,20 @@ func TestBadSignatureLength(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
-	Equal(t, resp.StatusCode, http.StatusForbidden)
+	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, ErrMissingHubSignatureHeader)
 }
 
 func TestBadSignatureMatch(t *testing.T) {
+	var parseError error
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		_, parseError = hook.Parse(r, CommitCommentEvent)
+	})
+	defer server.Close()
 	payload := "{}"
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "commit_comment")
 	req.Header.Set("X-Hub-Signature", "sha1=111")
@@ -174,10 +153,8 @@ func TestBadSignatureMatch(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
-	Equal(t, resp.StatusCode, http.StatusForbidden)
+	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, ErrHMACVerificationFailed)
 }
 
 func TestCommitCommentEvent(t *testing.T) {
@@ -323,7 +300,15 @@ func TestCommitCommentEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, CommitCommentEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "commit_comment")
 	req.Header.Set("X-Hub-Signature", "sha1=156404ad5f721c53151147f3d3d302329f95a3ab")
@@ -333,10 +318,10 @@ func TestCommitCommentEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(CommitCommentPayload)
+	Equal(t, ok, true)
 }
 
 func TestCreateEvent(t *testing.T) {
@@ -456,7 +441,15 @@ func TestCreateEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, CreateEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "create")
 	req.Header.Set("X-Hub-Signature", "sha1=77ff16ca116034bbeed77ebfce83b36572a9cbaf")
@@ -466,14 +459,13 @@ func TestCreateEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(CreatePayload)
+	Equal(t, ok, true)
 }
 
 func TestDeleteEvent(t *testing.T) {
-
 	payload := `{
   "ref": "simple-tag",
   "ref_type": "tag",
@@ -587,7 +579,15 @@ func TestDeleteEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, DeleteEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "delete")
 	req.Header.Set("X-Hub-Signature", "sha1=4ddef04fd05b504c7041e294fca3ad1804bc7be1")
@@ -597,14 +597,13 @@ func TestDeleteEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(DeletePayload)
+	Equal(t, ok, true)
 }
 
 func TestDeploymentEvent(t *testing.T) {
-
 	payload := `{
   "deployment": {
     "url": "https://api.github.com/repos/baxterthehacker/public-repo/deployments/710692",
@@ -749,7 +748,15 @@ func TestDeploymentEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, DeploymentEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "deployment")
 	req.Header.Set("X-Hub-Signature", "sha1=bb47dc63ceb764a6b1f14fe123e299e5b814c67c")
@@ -759,14 +766,13 @@ func TestDeploymentEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(DeploymentPayload)
+	Equal(t, ok, true)
 }
 
 func TestDeploymentStatusEvent(t *testing.T) {
-
 	payload := `{
   "deployment_status": {
     "url": "https://api.github.com/repos/baxterthehacker/public-repo/deployments/710692/statuses/1115122",
@@ -940,8 +946,15 @@ func TestDeploymentStatusEvent(t *testing.T) {
   }
 }
 `
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, DeploymentStatusEvent)
+	})
+	defer server.Close()
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "deployment_status")
 	req.Header.Set("X-Hub-Signature", "sha1=1b2ce08e0c3487fdf22bed12c63dc734cf6dc8a4")
@@ -951,14 +964,13 @@ func TestDeploymentStatusEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(DeploymentStatusPayload)
+	Equal(t, ok, true)
 }
 
 func TestForkEvent(t *testing.T) {
-
 	payload := `{
   "forkee": {
     "id": 35129393,
@@ -1156,8 +1168,15 @@ func TestForkEvent(t *testing.T) {
   }
 }
 `
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, ForkEvent)
+	})
+	defer server.Close()
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "fork")
 	req.Header.Set("X-Hub-Signature", "sha1=cec5f8fb7c383514c622d3eb9e121891dfcca848")
@@ -1167,14 +1186,13 @@ func TestForkEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(ForkPayload)
+	Equal(t, ok, true)
 }
 
 func TestGollumEvent(t *testing.T) {
-
 	payload := `{
   "pages": [
     {
@@ -1294,8 +1312,15 @@ func TestGollumEvent(t *testing.T) {
   }
 }
 `
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, GollumEvent)
+	})
+	defer server.Close()
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "gollum")
 	req.Header.Set("X-Hub-Signature", "sha1=a375a6dc8ceac7231ee022211f8eb85e2a84a5b9")
@@ -1305,14 +1330,13 @@ func TestGollumEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(GollumPayload)
+	Equal(t, ok, true)
 }
 
 func TestInstallationEvent(t *testing.T) {
-
 	payload := `{
     "action": "created",
     "installation": {
@@ -1384,8 +1408,15 @@ func TestInstallationEvent(t *testing.T) {
     }
 }
 `
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, InstallationEvent)
+	})
+	defer server.Close()
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "installation")
 	req.Header.Set("X-Hub-Signature", "sha1=987338c6e5c21794ab6c258abe51284f9b1df728")
@@ -1395,14 +1426,13 @@ func TestInstallationEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(InstallationPayload)
+	Equal(t, ok, true)
 }
 
 func TestIntegrationInstallationEvent(t *testing.T) {
-
 	payload := `{
     "action": "created",
     "installation": {
@@ -1474,8 +1504,15 @@ func TestIntegrationInstallationEvent(t *testing.T) {
     }
 }
 `
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, IntegrationInstallationEvent)
+	})
+	defer server.Close()
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "integration_installation")
 	req.Header.Set("X-Hub-Signature", "sha1=987338c6e5c21794ab6c258abe51284f9b1df728")
@@ -1485,14 +1522,13 @@ func TestIntegrationInstallationEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(InstallationPayload)
+	Equal(t, ok, true)
 }
 
 func TestIssueCommentEvent(t *testing.T) {
-
 	payload := `{
   "action": "created",
   "issue": {
@@ -1677,7 +1713,15 @@ func TestIssueCommentEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, IssueCommentEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "issue_comment")
 	req.Header.Set("X-Hub-Signature", "sha1=e724c9f811fcf5f511aac32e4251b08ab1a0fd87")
@@ -1687,10 +1731,10 @@ func TestIssueCommentEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(IssueCommentPayload)
+	Equal(t, ok, true)
 }
 
 func TestIssuesEvent(t *testing.T) {
@@ -1853,7 +1897,15 @@ func TestIssuesEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, IssuesEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "issues")
 	req.Header.Set("X-Hub-Signature", "sha1=dfc9a3428f3df86e4ecd78e34b41c55bba5d0b21")
@@ -1863,10 +1915,10 @@ func TestIssuesEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(IssuesPayload)
+	Equal(t, ok, true)
 }
 
 func TestLabelEvent(t *testing.T) {
@@ -2000,7 +2052,15 @@ func TestLabelEvent(t *testing.T) {
   }
 }
 `
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, LabelEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "label")
 	req.Header.Set("X-Hub-Signature", "sha1=efc13e7ad816235222e4a6b3f96d3fd1e162dbd4")
@@ -2010,10 +2070,10 @@ func TestLabelEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(LabelPayload)
+	Equal(t, ok, true)
 }
 
 func TestMemberEvent(t *testing.T) {
@@ -2148,7 +2208,15 @@ func TestMemberEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, MemberEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "member")
 	req.Header.Set("X-Hub-Signature", "sha1=597e7d6627a6636d4c3283e36631983fbd57bdd0")
@@ -2158,10 +2226,10 @@ func TestMemberEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(MemberPayload)
+	Equal(t, ok, true)
 }
 
 func TestMembershipEvent(t *testing.T) {
@@ -2229,7 +2297,15 @@ func TestMembershipEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, MembershipEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "membership")
 	req.Header.Set("X-Hub-Signature", "sha1=16928c947b3707b0efcf8ceb074a5d5dedc9c76e")
@@ -2239,10 +2315,10 @@ func TestMembershipEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(MembershipPayload)
+	Equal(t, ok, true)
 }
 
 func TestMilestoneEvent(t *testing.T) {
@@ -2407,7 +2483,15 @@ func TestMilestoneEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, MilestoneEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "milestone")
 	req.Header.Set("X-Hub-Signature", "sha1=8b63f58ea58e6a59dcfc5ecbaea0d1741a6bf9ec")
@@ -2417,10 +2501,10 @@ func TestMilestoneEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(MilestonePayload)
+	Equal(t, ok, true)
 }
 
 func TestOrganizationEvent(t *testing.T) {
@@ -2493,7 +2577,15 @@ func TestOrganizationEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, OrganizationEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "organization")
 	req.Header.Set("X-Hub-Signature", "sha1=7e5ad88557be0a05fb89e86c7893d987386aa0d5")
@@ -2503,10 +2595,10 @@ func TestOrganizationEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(OrganizationPayload)
+	Equal(t, ok, true)
 }
 
 func TestOrgBlockEvent(t *testing.T) {
@@ -2567,7 +2659,15 @@ func TestOrgBlockEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, OrgBlockEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "org_block")
 	req.Header.Set("X-Hub-Signature", "sha1=21fe61da3f014c011edb60b0b9dfc9aa7059a24b")
@@ -2577,10 +2677,10 @@ func TestOrgBlockEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(OrgBlockPayload)
+	Equal(t, ok, true)
 }
 
 func TestPageBuildEvent(t *testing.T) {
@@ -2726,7 +2826,15 @@ func TestPageBuildEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, PageBuildEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "page_build")
 	req.Header.Set("X-Hub-Signature", "sha1=b3abad8f9c1b3fc0b01c4eb107447800bb5000f9")
@@ -2736,10 +2844,10 @@ func TestPageBuildEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(PageBuildPayload)
+	Equal(t, ok, true)
 }
 
 func TestPingEvent(t *testing.T) {
@@ -2768,7 +2876,15 @@ func TestPingEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, PingEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "ping")
 	req.Header.Set("X-Hub-Signature", "sha1=f82267eb5c6408d5986209da906747f57c11b33b")
@@ -2778,10 +2894,10 @@ func TestPingEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(PingPayload)
+	Equal(t, ok, true)
 }
 
 func TestProjectCardEvent(t *testing.T) {
@@ -2936,7 +3052,15 @@ func TestProjectCardEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, ProjectCardEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "project_card")
 	req.Header.Set("X-Hub-Signature", "sha1=495dec0d6449d16b71f2ddcd37d595cb9b04b1d8")
@@ -2946,10 +3070,10 @@ func TestProjectCardEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(ProjectCardPayload)
+	Equal(t, ok, true)
 }
 
 func TestProjectColumnEvent(t *testing.T) {
@@ -3084,7 +3208,15 @@ func TestProjectColumnEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, ProjectColumnEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "project_column")
 	req.Header.Set("X-Hub-Signature", "sha1=7d5dd49d9863e982a4f577170717ea8350a69db0")
@@ -3094,10 +3226,10 @@ func TestProjectColumnEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(ProjectColumnPayload)
+	Equal(t, ok, true)
 }
 
 func TestProjectEvent(t *testing.T) {
@@ -3254,7 +3386,15 @@ func TestProjectEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, ProjectEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "project")
 	req.Header.Set("X-Hub-Signature", "sha1=7295ab4f205434208f1b86edf2b55adae34c6c92")
@@ -3264,10 +3404,10 @@ func TestProjectEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(ProjectPayload)
+	Equal(t, ok, true)
 }
 
 func TestPublicEvent(t *testing.T) {
@@ -3382,7 +3522,15 @@ func TestPublicEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, PublicEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "public")
 	req.Header.Set("X-Hub-Signature", "sha1=73edb2a8c69c1ac35efb797ede3dc2cde618c10c")
@@ -3392,10 +3540,10 @@ func TestPublicEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(PublicPayload)
+	Equal(t, ok, true)
 }
 
 func TestPullRequestEvent(t *testing.T) {
@@ -3817,7 +3965,15 @@ func TestPullRequestEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, PullRequestEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "pull_request")
 	req.Header.Set("X-Hub-Signature", "sha1=35712c8d2bc197b7d07621dcf20d2fb44620508f")
@@ -3827,10 +3983,10 @@ func TestPullRequestEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(PullRequestPayload)
+	Equal(t, ok, true)
 }
 
 func TestPullRequestReviewEvent(t *testing.T) {
@@ -4277,7 +4433,15 @@ func TestPullRequestReviewEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, PullRequestReviewEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "pull_request_review")
 	req.Header.Set("X-Hub-Signature", "sha1=55345ce92be7849f97d39b9426b95261d4bd4465")
@@ -4287,10 +4451,10 @@ func TestPullRequestReviewEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(PullRequestReviewPayload)
+	Equal(t, ok, true)
 }
 
 func TestPullRequestReviewCommentEvent(t *testing.T) {
@@ -4743,7 +4907,15 @@ func TestPullRequestReviewCommentEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, PullRequestReviewCommentEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "pull_request_review_comment")
 	req.Header.Set("X-Hub-Signature", "sha1=a9ece15dbcbb85fa5f00a0bf409494af2cbc5b60")
@@ -4753,10 +4925,10 @@ func TestPullRequestReviewCommentEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(PullRequestReviewCommentPayload)
+	Equal(t, ok, true)
 }
 
 func TestPushEvent(t *testing.T) {
@@ -4949,7 +5121,15 @@ func TestPushEvent(t *testing.T) {
   }
 }`
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, PushEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "push")
 	req.Header.Set("X-Hub-Signature", "sha1=0534736f52c2fc5896ef1bd5a043127b20d233ba")
@@ -4959,11 +5139,10 @@ func TestPushEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
-
+	Equal(t, parseError, nil)
+	_, ok := results.(PushPayload)
+	Equal(t, ok, true)
 }
 
 func TestReleaseEvent(t *testing.T) {
@@ -5118,7 +5297,15 @@ func TestReleaseEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, ReleaseEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "release")
 	req.Header.Set("X-Hub-Signature", "sha1=e62bb4c51bc7dde195b9525971c2e3aecb394390")
@@ -5128,10 +5315,10 @@ func TestReleaseEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(ReleasePayload)
+	Equal(t, ok, true)
 }
 
 func TestRepositoryEvent(t *testing.T) {
@@ -5257,7 +5444,15 @@ func TestRepositoryEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, RepositoryEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "repository")
 	req.Header.Set("X-Hub-Signature", "sha1=df442a8af41edd2d42ccdd997938d1d111b0f94e")
@@ -5267,10 +5462,10 @@ func TestRepositoryEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(RepositoryPayload)
+	Equal(t, ok, true)
 }
 
 func TestStatusEvent(t *testing.T) {
@@ -5483,7 +5678,15 @@ func TestStatusEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, StatusEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "status")
 	req.Header.Set("X-Hub-Signature", "sha1=3caa5f062a2deb7cce1482314bb9b4c99bf0ab45")
@@ -5493,10 +5696,10 @@ func TestStatusEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(StatusPayload)
+	Equal(t, ok, true)
 }
 
 func TestTeamEvent(t *testing.T) {
@@ -5549,7 +5752,15 @@ func TestTeamEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, TeamEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "team")
 	req.Header.Set("X-Hub-Signature", "sha1=ff5b5d58faec10bd40fc96834148df408e7a4608")
@@ -5559,10 +5770,10 @@ func TestTeamEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(TeamPayload)
+	Equal(t, ok, true)
 }
 
 func TestTeamAddEvent(t *testing.T) {
@@ -5698,7 +5909,15 @@ func TestTeamAddEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, TeamAddEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "team_add")
 	req.Header.Set("X-Hub-Signature", "sha1=5f3953476e270b79cc6763780346110da880609a")
@@ -5708,10 +5927,10 @@ func TestTeamAddEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(TeamAddPayload)
+	Equal(t, ok, true)
 }
 
 func TestWatchEvent(t *testing.T) {
@@ -5827,7 +6046,15 @@ func TestWatchEvent(t *testing.T) {
 }
 `
 
-	req, err := http.NewRequest("POST", "http://127.0.0.1:3010/webhooks", bytes.NewBuffer([]byte(payload)))
+	var parseError error
+	var results interface{}
+	server := newServer(func(w http.ResponseWriter, r *http.Request) {
+		results, parseError = hook.Parse(r, WatchEvent)
+	})
+	defer server.Close()
+
+	req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
+	Equal(t, err, nil)
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Github-Event", "watch")
 	req.Header.Set("X-Hub-Signature", "sha1=a317bcfe69ccb8bece74c20c7378e5413c4772f1")
@@ -5837,8 +6064,8 @@ func TestWatchEvent(t *testing.T) {
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	Equal(t, err, nil)
-
-	defer resp.Body.Close()
-
 	Equal(t, resp.StatusCode, http.StatusOK)
+	Equal(t, parseError, nil)
+	_, ok := results.(WatchPayload)
+	Equal(t, ok, true)
 }
diff --git a/github/payload.go b/github/payload.go
index f829d11..5971552 100644
--- a/github/payload.go
+++ b/github/payload.go
@@ -376,14 +376,14 @@ type DeletePayload struct {
 // DeploymentPayload contains the information for GitHub's deployment hook
 type DeploymentPayload struct {
 	Deployment struct {
-		URL         string  `json:"url"`
-		ID          int64   `json:"id"`
-		Sha         string  `json:"sha"`
-		Ref         string  `json:"ref"`
-		Task        string  `json:"task"`
-		Payload     string  `json:"payload"`
-		Environment string  `json:"environment"`
-		Description *string `json:"description"`
+		URL         string   `json:"url"`
+		ID          int64    `json:"id"`
+		Sha         string   `json:"sha"`
+		Ref         string   `json:"ref"`
+		Task        string   `json:"task"`
+		Payload     struct{} `json:"payload"`
+		Environment string   `json:"environment"`
+		Description *string  `json:"description"`
 		Creator     struct {
 			Login             string `json:"login"`
 			ID                int64  `json:"id"`
@@ -549,14 +549,14 @@ type DeploymentStatusPayload struct {
 		RepositoryURL string    `json:"repository_url"`
 	} `json:"deployment_status"`
 	Deployment struct {
-		URL         string  `json:"url"`
-		ID          int64   `json:"id"`
-		Sha         string  `json:"sha"`
-		Ref         string  `json:"ref"`
-		Task        string  `json:"task"`
-		Payload     string  `json:"payload"`
-		Environment string  `json:"environment"`
-		Description *string `json:"description"`
+		URL         string   `json:"url"`
+		ID          int64    `json:"id"`
+		Sha         string   `json:"sha"`
+		Ref         string   `json:"ref"`
+		Task        string   `json:"task"`
+		Payload     struct{} `json:"payload"`
+		Environment string   `json:"environment"`
+		Description *string  `json:"description"`
 		Creator     struct {
 			Login             string `json:"login"`
 			ID                int64  `json:"id"`
@@ -2172,7 +2172,7 @@ type PingPayload struct {
 		AppID  int      `json:"app_id"`
 		Config struct {
 			ContentType string `json:"content_type"`
-			InsecureSSL int    `json:"insecure_ssl"`
+			InsecureSSL string `json:"insecure_ssl"`
 			Secret      string `json:"secret"`
 			URL         string `json:"url"`
 		} `json:"config"`
@@ -4230,7 +4230,7 @@ type PushPayload struct {
 		SiteAdmin         bool   `json:"site_admin"`
 	} `json:"sender"`
 	Installation struct {
-		Id int `json:"id"`
+		ID int `json:"id"`
 	} `json:"installation"`
 }
 
diff --git a/gitlab/gitlab.go b/gitlab/gitlab.go
index 4bdc6df..3784e1f 100644
--- a/gitlab/gitlab.go
+++ b/gitlab/gitlab.go
@@ -6,7 +6,7 @@ import (
 	"io/ioutil"
 	"net/http"
 
-	"gopkg.in/go-playground/webhooks.v4"
+	"gopkg.in/go-playground/webhooks.v5"
 )
 
 // Webhook instance contains all methods needed to process events
diff --git a/gitlab/gitlab_test.go b/gitlab/gitlab_test.go
index be916d3..36d09db 100644
--- a/gitlab/gitlab_test.go
+++ b/gitlab/gitlab_test.go
@@ -9,7 +9,7 @@ import (
 	"time"
 
 	. "gopkg.in/go-playground/assert.v1"
-	"gopkg.in/go-playground/webhooks.v4"
+	"gopkg.in/go-playground/webhooks.v5"
 )
 
 // NOTES:
diff --git a/gogs/gogs.go b/gogs/gogs.go
index 28398f8..28b9314 100644
--- a/gogs/gogs.go
+++ b/gogs/gogs.go
@@ -9,8 +9,9 @@ import (
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/hex"
+
 	client "github.com/gogits/go-gogs-client"
-	"gopkg.in/go-playground/webhooks.v4"
+	"gopkg.in/go-playground/webhooks.v5"
 )
 
 // Webhook instance contains all methods needed to process events
diff --git a/webhooks.go b/webhooks.go
index 4ab78b1..55c85aa 100644
--- a/webhooks.go
+++ b/webhooks.go
@@ -1,124 +1,123 @@
 package webhooks
 
 import (
-	"fmt"
 	"net/http"
 )
 
 // Header provides http.Header to minimize imports
 type Header http.Header
 
-// Provider defines the type of webhook
-type Provider int
+// // Provider defines the type of webhook
+// type Provider int
 
-func (p Provider) String() string {
-	switch p {
-	case GitHub:
-		return "GitHub"
-	case Bitbucket:
-		return "Bitbucket"
-	case GitLab:
-		return "GitLab"
-	case Gogs:
-		return "Gogs"
-	default:
-		return "Unknown"
-	}
-}
+// func (p Provider) String() string {
+// 	switch p {
+// 	case GitHub:
+// 		return "GitHub"
+// 	case Bitbucket:
+// 		return "Bitbucket"
+// 	case GitLab:
+// 		return "GitLab"
+// 	case Gogs:
+// 		return "Gogs"
+// 	default:
+// 		return "Unknown"
+// 	}
+// }
 
-// webhooks available providers
-const (
-	GitHub Provider = iota
-	Bitbucket
-	GitLab
-	Gogs
-)
+// // webhooks available providers
+// const (
+// 	GitHub Provider = iota
+// 	Bitbucket
+// 	GitLab
+// 	Gogs
+// )
 
-// Webhook interface defines a webhook to receive events
-type Webhook interface {
-	Provider() Provider
-	ParsePayload(w http.ResponseWriter, r *http.Request)
-}
+// // Webhook interface defines a webhook to receive events
+// type Webhook interface {
+// 	Provider() Provider
+// 	ParsePayload(w http.ResponseWriter, r *http.Request)
+// }
 
-type server struct {
-	hook             Webhook
-	path             string
-	includePathCheck bool
-}
+// type server struct {
+// 	hook             Webhook
+// 	path             string
+// 	includePathCheck bool
+// }
 
 // ProcessPayloadFunc is a common function for payload return values
-type ProcessPayloadFunc func(payload interface{}, header Header)
+type ProcessPayloadFunc func(payload interface{}, header Header) error
 
-// Handler returns the webhook http.Handler for use in your own Mux implementation
-func Handler(hook Webhook) http.Handler {
-	return &server{
-		hook: hook,
-	}
-}
+// // Handler returns the webhook http.Handler for use in your own Mux implementation
+// func Handler(hook Webhook) http.Handler {
+// 	return &server{
+// 		hook: hook,
+// 	}
+// }
 
-// Run runs a server
-func Run(hook Webhook, addr string, path string) error {
-	srv := &server{
-		hook:             hook,
-		path:             path,
-		includePathCheck: true,
-	}
-	s := &http.Server{Addr: addr, Handler: srv}
+// // Run runs a server
+// func Run(hook Webhook, addr string, path string) error {
+// 	srv := &server{
+// 		hook:             hook,
+// 		path:             path,
+// 		includePathCheck: true,
+// 	}
+// 	s := &http.Server{Addr: addr, Handler: srv}
 
-	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", addr, path))
-	return s.ListenAndServe()
-}
+// 	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", addr, path))
+// 	return s.ListenAndServe()
+// }
 
-// RunServer runs a custom server.
-func RunServer(s *http.Server, hook Webhook, path string) error {
+// // RunServer runs a custom server.
+// func RunServer(s *http.Server, hook Webhook, path string) error {
 
-	srv := &server{
-		hook:             hook,
-		path:             path,
-		includePathCheck: true,
-	}
+// 	srv := &server{
+// 		hook:             hook,
+// 		path:             path,
+// 		includePathCheck: true,
+// 	}
 
-	s.Handler = srv
-	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", s.Addr, path))
-	return s.ListenAndServe()
-}
+// 	s.Handler = srv
+// 	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", s.Addr, path))
+// 	return s.ListenAndServe()
+// }
 
-// RunTLSServer runs a custom server with TLS configuration.
-// NOTE: http.Server Handler will be overridden by this library, just set it to nil.
-// Setting the Certificates can be done in the http.Server.TLSConfig.Certificates
-// see example here: https://github.com/go-playground/webhooks/blob/v2/webhooks_test.go#L178
-func RunTLSServer(s *http.Server, hook Webhook, path string) error {
+// // RunTLSServer runs a custom server with TLS configuration.
+// // NOTE: http.Server Handler will be overridden by this library, just set it to nil.
+// // Setting the Certificates can be done in the http.Server.TLSConfig.Certificates
+// // see example here: https://github.com/go-playground/webhooks/blob/v2/webhooks_test.go#L178
+// func RunTLSServer(s *http.Server, hook Webhook, path string) error {
 
-	srv := &server{
-		hook:             hook,
-		path:             path,
-		includePathCheck: true,
-	}
+// 	srv := &server{
+// 		hook:             hook,
+// 		path:             path,
+// 		includePathCheck: true,
+// 	}
 
-	s.Handler = srv
-	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", s.Addr, path))
-	return s.ListenAndServeTLS("", "")
-}
+// 	s.Handler = srv
+// 	DefaultLog.Info(fmt.Sprintf("Listening on addr: %s path: %s", s.Addr, path))
+// 	return s.ListenAndServeTLS("", "")
+// }
 
-// ServeHTTP is the Handler for every posted WebHook Event
-func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	defer r.Body.Close()
-	DefaultLog.Info("Webhook received")
+// // ServeHTTP is the Handler for every posted WebHook Event
+// func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+// 	defer r.Body.Close()
+// 	DefaultLog.Info("Webhook received")
 
-	if r.Method != "POST" {
-		DefaultLog.Error(fmt.Sprintf("405 Method not allowed, attempt made using Method: %s", r.Method))
-		http.Error(w, "405 Method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
+// 	if r.Method != "POST" {
+// 		DefaultLog.Error(fmt.Sprintf("405 Method not allowed, attempt made using Method: %s", r.Method))
+// 		http.Error(w, "405 Method not allowed", http.StatusMethodNotAllowed)
+// 		return
+// 	}
 
-	DefaultLog.Debug(fmt.Sprintf("Include path check: %t", s.includePathCheck))
-	if s.includePathCheck {
-		if r.URL.Path != s.path {
-			DefaultLog.Error(fmt.Sprintf("404 Not found, POST made using path: %s, but expected %s", r.URL.Path, s.path))
-			http.Error(w, "404 Not found", http.StatusNotFound)
-			return
-		}
-	}
+// 	DefaultLog.Debug(fmt.Sprintf("Include path check: %t", s.includePathCheck))
+// 	if s.includePathCheck {
+// 		if r.URL.Path != s.path {
+// 			DefaultLog.Error(fmt.Sprintf("404 Not found, POST made using path: %s, but expected %s", r.URL.Path, s.path))
+// 			http.Error(w, "404 Not found", http.StatusNotFound)
+// 			return
+// 		}
+// 	}
 
-	s.hook.ParsePayload(w, r)
-}
+// 	s.hook.ParsePayload(w, r)
+// }