diff --git a/webhookbot/db.sql b/webhookbot/db.sql
index eb62a95a..5c0233fa 100644
--- a/webhookbot/db.sql
+++ b/webhookbot/db.sql
@@ -2,6 +2,8 @@ CREATE TABLE `hooks` (
   `id` varchar(100) NOT NULL,
   `name` varchar(100) NOT NULL,
   `conv_id` varchar(100) NOT NULL,
+  `template` varchar(10000) NOT NULL,
+  CONSTRAINT hook UNIQUE (`name`,`conv_id`),
   PRIMARY KEY (`id`),
   KEY `conv_id` (`conv_id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
\ No newline at end of file
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
diff --git a/webhookbot/main.go b/webhookbot/main.go
index 51add8a7..e1629049 100644
--- a/webhookbot/main.go
+++ b/webhookbot/main.go
@@ -45,10 +45,20 @@ const back = "`"
 const backs = "```"
 
 func (s *BotServer) makeAdvertisement() kbchat.Advertisement {
-	createExtended := fmt.Sprintf(`Create a new webhook for sending messages into the current conversation. You must supply a name as well to identify the webhook. To use a webhook URL, supply a %smsg%s URL parameter, or a JSON POST body with a field %smsg%s.
+	createExtended := fmt.Sprintf(`Create a new webhook for sending messages into the current conversation. You must supply a name as well to identify the webhook. To use a webhook URL, supply a %smsg%s URL parameter, or a JSON POST body with a field %smsg%s. You can also supply a template, which allows you to customize the message displayed by the webhook, and the URL and/or JSON fields it will accept. For more information on templates, use the %s!webhook help%s command.
 
 	Example:%s
-		!webhook create alerts%s`, back, back, back, back, backs, backs)
+		!webhook create alerts%s
+
+	Example (using custom template):%s
+		!webhook create alerts *{{.title}}*
+		%s{{.body}}%s%s`,
+		back, back, back, back, back, back, backs, backs, backs, back, back, backs)
+	updateExtended := fmt.Sprintf(`Update an existing webhook's template. Leave the template field empty to use the default template. For more information on templates, use the %s!webhook help%s command.
+
+	Example:%s
+		!webhook update alerts *New Alert: {{.title}}*
+		%s{{.body}}%s%s`, back, back, backs, back, back, backs)
 	removeExtended := fmt.Sprintf(`Remove a webhook from the current conversation. You must supply the name of the webhook.
 
 	Example:%s
@@ -57,14 +67,26 @@ func (s *BotServer) makeAdvertisement() kbchat.Advertisement {
 	cmds := []chat1.UserBotCommandInput{
 		{
 			Name:        "webhook create",
+			Usage:       "<name> [<template>]",
 			Description: "Create a new webhook for sending into the current conversation",
 			ExtendedDescription: &chat1.UserBotExtendedDescription{
-				Title: `*!webhook create* <name>
+				Title: `*!webhook create* <name> [<template>]
 Create a webhook`,
 				DesktopBody: createExtended,
 				MobileBody:  createExtended,
 			},
 		},
+		{
+			Name:        "webhook update",
+			Usage:       "<name> [<template>]",
+			Description: "Update the template of an existing webhook in the current conversation",
+			ExtendedDescription: &chat1.UserBotExtendedDescription{
+				Title: `*!webhook update* <name> [<template>]
+Update a webhook's template`,
+				DesktopBody: updateExtended,
+				MobileBody:  updateExtended,
+			},
+		},
 		{
 			Name:        "webhook list",
 			Description: "List active webhooks in the current conversation",
@@ -79,6 +101,10 @@ Remove a webhook`,
 				MobileBody:  removeExtended,
 			},
 		},
+		{
+			Name:        "webhook help",
+			Description: "Get more information about using templates",
+		},
 		base.GetFeedbackCommandAdvertisement(s.kbc.GetUsername()),
 	}
 	return kbchat.Advertisement{
diff --git a/webhookbot/webhookbot/db.go b/webhookbot/webhookbot/db.go
index 88c12006..83fd6b0a 100644
--- a/webhookbot/webhookbot/db.go
+++ b/webhookbot/webhookbot/db.go
@@ -35,7 +35,7 @@ func (d *DB) makeID(name string, convID chat1.ConvIDStr) (string, error) {
 	return base.URLEncoder().EncodeToString(h.Sum(nil)[:20]), nil
 }
 
-func (d *DB) Create(name string, convID chat1.ConvIDStr) (string, error) {
+func (d *DB) Create(name, template string, convID chat1.ConvIDStr) (string, error) {
 	id, err := d.makeID(name, convID)
 	if err != nil {
 		return "", err
@@ -43,10 +43,10 @@ func (d *DB) Create(name string, convID chat1.ConvIDStr) (string, error) {
 	err = d.RunTxn(func(tx *sql.Tx) error {
 		if _, err := tx.Exec(`
 			INSERT INTO hooks
-			(id, name, conv_id)
+			(id, name, template, conv_id)
 			VALUES
-			(?, ?, ?)
-		`, id, name, convID); err != nil {
+			(?, ?, ?, ?)
+		`, id, name, template, convID); err != nil {
 			return err
 		}
 		return nil
@@ -54,20 +54,35 @@ func (d *DB) Create(name string, convID chat1.ConvIDStr) (string, error) {
 	return id, err
 }
 
+func (d *DB) Update(name, template string, convID chat1.ConvIDStr) error {
+	err := d.RunTxn(func(tx *sql.Tx) error {
+		if _, err := tx.Exec(`
+			UPDATE hooks
+			SET template = ?
+			WHERE conv_id = ? AND name = ?
+		`, template, convID, name); err != nil {
+			return err
+		}
+		return nil
+	})
+	return err
+}
+
 func (d *DB) GetHook(id string) (res webhook, err error) {
 	row := d.DB.QueryRow(`
-		SELECT conv_id, name FROM hooks WHERE id = ?
+		SELECT conv_id, name, template FROM hooks WHERE id = ?
 	`, id)
-	if err := row.Scan(&res.convID, &res.name); err != nil {
+	if err := row.Scan(&res.convID, &res.name, &res.template); err != nil {
 		return res, err
 	}
 	return res, nil
 }
 
 type webhook struct {
-	id     string
-	convID chat1.ConvIDStr
-	name   string
+	id       string
+	convID   chat1.ConvIDStr
+	name     string
+	template string
 }
 
 func (d *DB) List(convID chat1.ConvIDStr) (res []webhook, err error) {
diff --git a/webhookbot/webhookbot/handler.go b/webhookbot/webhookbot/handler.go
index f49e8c38..1e40fdb4 100644
--- a/webhookbot/webhookbot/handler.go
+++ b/webhookbot/webhookbot/handler.go
@@ -1,9 +1,11 @@
 package webhookbot
 
 import (
+	"database/sql"
 	"errors"
 	"fmt"
 	"strings"
+	"text/template"
 
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/keybase/go-keybase-chat-bot/kbchat"
@@ -11,6 +13,8 @@ import (
 	"github.com/keybase/managed-bots/base"
 )
 
+const defaultTemplate = "[hook: *{{$webhookName}}*]\n\n{{if eq $webhookMethod \"POST\"}}{{.msg}}{{else}}{{index .msg 0}}{{end}}"
+
 type Handler struct {
 	*base.DebugOutput
 
@@ -54,7 +58,7 @@ func (h *Handler) checkAllowed(msg chat1.MsgSummary) error {
 
 func (h *Handler) handleRemove(cmd string, msg chat1.MsgSummary) (err error) {
 	convID := msg.ConvID
-	toks := strings.Split(cmd, " ")
+	toks := strings.Fields(cmd)
 	if len(toks) != 3 {
 		h.ChatEcho(convID, "invalid number of arguments, must specify a name")
 		return nil
@@ -109,10 +113,39 @@ func (h *Handler) handleList(cmd string, msg chat1.MsgSummary) (err error) {
 	return nil
 }
 
+func validateTemplate(cmd string) (templateSrc string, err error) {
+	toks := strings.Fields(cmd)
+
+	var trigger string
+	switch toks[1] {
+	case "create":
+		trigger = "!webhook create"
+	case "update":
+		trigger = "!webhook update"
+	}
+
+	// templateSrc is whatever remains after removing the trigger (i.e `!webhook create` or
+	// `!webhook update`) followed by the template name, and trimming spaces. if the template
+	// is empty, we'll set a default one
+	name := toks[2]
+	templateSrc = strings.Replace(cmd, trigger, "", 1)
+	templateSrc = strings.Replace(templateSrc, name, "", 1)
+	templateSrc = strings.TrimSpace(templateSrc)
+	if templateSrc == "" {
+		templateSrc = defaultTemplate
+	}
+	tWithVars := injectTemplateVars("testhook1", "POST", templateSrc)
+	_, err = template.New("").Parse(tWithVars)
+	if err != nil {
+		return "", err
+	}
+	return templateSrc, nil
+}
+
 func (h *Handler) handleCreate(cmd string, msg chat1.MsgSummary) (err error) {
 	convID := msg.ConvID
-	toks := strings.Split(cmd, " ")
-	if len(toks) != 3 {
+	toks := strings.Fields(cmd)
+	if len(toks) < 3 {
 		h.ChatEcho(convID, "invalid number of arguments, must specify a name")
 		return nil
 	}
@@ -128,7 +161,13 @@ func (h *Handler) handleCreate(cmd string, msg chat1.MsgSummary) (err error) {
 
 	h.stats.Count("create")
 	name := toks[2]
-	id, err := h.db.Create(name, convID)
+	templateSrc, err := validateTemplate(cmd)
+	if err != nil {
+		h.ChatEcho(convID, "failed to parse template: %v", err)
+		return fmt.Errorf("handleCreate: failed to parse template: %s", err)
+	}
+
+	id, err := h.db.Create(name, templateSrc, convID)
 	if err != nil {
 		return fmt.Errorf("handleCreate: failed to create webhook: %s", err)
 	}
@@ -139,6 +178,63 @@ func (h *Handler) handleCreate(cmd string, msg chat1.MsgSummary) (err error) {
 	return nil
 }
 
+func (h *Handler) handleUpdate(cmd string, msg chat1.MsgSummary) (err error) {
+	convID := msg.ConvID
+	toks := strings.Fields(cmd)
+	if len(toks) < 3 {
+		h.ChatEcho(convID, "invalid number of arguments, must specify a name")
+		return nil
+	}
+	err = h.checkAllowed(msg)
+	switch err {
+	case nil:
+	case errNotAllowed:
+		h.ChatEcho(convID, err.Error())
+		return nil
+	default:
+		return err
+	}
+	h.stats.Count("update")
+	name := toks[2]
+	templateSrc, err := validateTemplate(cmd)
+	if err != nil {
+		h.ChatEcho(convID, "failed to parse template: %v", err)
+		return fmt.Errorf("handleUpdate: failed to parse template: %s", err)
+	}
+
+	err = h.db.Update(name, templateSrc, convID)
+	switch err {
+	case nil:
+	case sql.ErrNoRows:
+	default:
+		h.ChatEcho(convID, "failed to update template: no webhook with that name exists in this conversation. a new webhook can be created with the `!webhook create` command.")
+		return nil
+	}
+	h.ChatEcho(convID, "Success!")
+	return nil
+}
+
+func (h *Handler) handleHelp(msg chat1.MsgSummary) (err error) {
+	h.stats.Count("help")
+	back := "`"
+	backs := "```"
+	convID := msg.ConvID
+	h.ChatEcho(convID, `
+*Templates:*
+	- Information about creating templates, and some examples can be found at https://pkg.go.dev/text/template
+	- You can test your templates against your JSON data at https://play.golang.org/p/vC06kRCQDfX
+
+	There are 2 custom variables you can use in your templates (see the default template below for example usage):
+	  - %s$webhookName%s: The name you gave the webhook
+	  - %s$webhookMethod%s: Whether GET or POST was used when the webhook endpoint was fetched
+
+	If you don't provide a template, this is the default:%s
+	[hook: *{{$webhookName}}*]
+
+	{{if eq $webhookMethod "POST"}}{{.msg}}{{else}}{{index .msg 0}}{{end}}%s`, back, back, back, back, backs, backs)
+	return nil
+}
+
 func (h *Handler) HandleNewConv(conv chat1.ConvSummary) error {
 	welcomeMsg := "I can create generic webhooks into Keybase! Try `!webhook create` to get started."
 	return base.HandleNewTeam(h.stats, h.DebugOutput, h.kbc, conv, welcomeMsg)
@@ -156,6 +252,10 @@ func (h *Handler) HandleCommand(msg chat1.MsgSummary) error {
 		return h.handleList(cmd, msg)
 	case strings.HasPrefix(cmd, "!webhook remove"):
 		return h.handleRemove(cmd, msg)
+	case strings.HasPrefix(cmd, "!webhook update"):
+		return h.handleUpdate(cmd, msg)
+	case strings.HasPrefix(cmd, "!webhook help"):
+		return h.handleHelp(msg)
 	}
 	return nil
 }
diff --git a/webhookbot/webhookbot/http.go b/webhookbot/webhookbot/http.go
index cefe511c..5b17c84b 100644
--- a/webhookbot/webhookbot/http.go
+++ b/webhookbot/webhookbot/http.go
@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"os"
 	"strings"
+	"text/template"
 	"time"
 
 	"github.com/gorilla/mux"
@@ -32,33 +33,59 @@ func NewHTTPSrv(stats *base.StatsRegistry, debugConfig *base.ChatDebugOutputConf
 	return h
 }
 
-type msgPayload struct {
-	Msg string
+func injectTemplateVars(webhookName, webhookMethod, template string) string {
+	return fmt.Sprintf("{{$webhookName := %q}}{{$webhookMethod := %q}} %s", webhookName, webhookMethod, template)
 }
 
-func (h *HTTPSrv) getMessage(r *http.Request) (string, error) {
-	msg := r.URL.Query().Get("msg")
-	if len(msg) > 0 {
-		return msg, nil
+func (h *HTTPSrv) getMessage(r *http.Request, hook webhook) (string, error) {
+	if r.Method == http.MethodGet && len(hook.template) == 0 {
+		j, err := json.Marshal(r.URL.Query())
+		if err != nil {
+			return "", err
+		}
+		return string(j), nil
+	}
+
+	if r.Method == http.MethodPost && len(hook.template) == 0 {
+		defer r.Body.Close()
+		body, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			return "", err
+		}
+		return string(body), nil
 	}
 
-	defer r.Body.Close()
-	body, err := ioutil.ReadAll(r.Body)
+	tWithVars := injectTemplateVars(hook.name, r.Method, hook.template)
+	t, err := template.New("").Parse(tWithVars)
 	if err != nil {
-		return "", err
+		return "`Error: failed to parse template: " + err.Error() + "`", nil
 	}
 
-	var payload msgPayload
-	decoder := json.NewDecoder(bytes.NewReader(body))
-	if err := decoder.Decode(&payload); err == nil && len(payload.Msg) > 0 {
-		return payload.Msg, nil
+	if r.Method == http.MethodGet {
+		buf := new(bytes.Buffer)
+		if err := t.Execute(buf, r.URL.Query()); err == nil {
+			return buf.String(), nil
+		}
 	}
 
-	msg = string(body)
-	if len(msg) > 0 {
-		return msg, nil
+	if r.Method == http.MethodPost {
+		defer r.Body.Close()
+		body, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			return "", err
+		}
+
+		m := map[string]interface{}{}
+		err = json.Unmarshal(body, &m)
+		if err != nil {
+			return "", err
+		}
+		buf := new(bytes.Buffer)
+		if err := t.Execute(buf, m); err == nil && len(buf.String()) > 0 {
+			return buf.String(), nil
+		}
 	}
-	return "`Error: no body found. To use a webhook URL, supply a 'msg' URL parameter, or a JSON POST body with a field 'msg'`", nil
+	return "", nil
 }
 
 func (h *HTTPSrv) handleHook(w http.ResponseWriter, r *http.Request) {
@@ -71,15 +98,19 @@ func (h *HTTPSrv) handleHook(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusNotFound)
 		return
 	}
-	msg, err := h.getMessage(r)
+	msg, err := h.getMessage(r, hook)
 	if err != nil {
 		h.Stats.Count("handle - no message")
 		h.Errorf("handleHook: failed to find message: %s", err)
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
+	if strings.TrimSpace(msg) == "" {
+		h.Stats.Count("handle - empty msg")
+		return
+	}
 	h.Stats.Count("handle - success")
-	if _, err := h.Config().KBC.SendMessageByConvID(hook.convID, "[hook: *%s*]\n\n%s", hook.name, msg); err != nil {
+	if _, err := h.Config().KBC.SendMessageByConvID(hook.convID, " %s", msg); err != nil {
 		if base.IsDeletedConvError(err) {
 			h.Debug("ChatEcho: failed to send echo message: %s", err)
 			return