diff --git a/extensions/base/abusefilter.py b/extensions/base/abusefilter.py
index 51097af..edae5a1 100644
--- a/extensions/base/abusefilter.py
+++ b/extensions/base/abusefilter.py
@@ -18,10 +18,12 @@ import logging
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, sanitize_to_url, parse_mediawiki_changes, clean_link, compact_author, \
-	create_article_path, sanitize_to_markdown
+from src.api.util import embed_helper, sanitize_to_url, parse_mediawiki_changes, clean_link, compact_author, sanitize_to_markdown
 
-abusefilter_translatable = lambda string, _, default: {"edit": _("Edit"), "upload": _("Upload"), "move": _("Move"), "stashupload": _("Stash upload"), "delete": _("Deletion"), "createaccount": _("Account creation"), "autocreateaccount": _("Auto account creation"), "": _("None"), "warn": _("Warning issued"), "block": _("**Blocked user**"), "tag": _("Tagged the edit"), "disallow": _("Disallowed the action"), "rangeblock": _("**IP range blocked**"), "throttle": _("Throttled actions"), "blockautopromote": _("Removed autoconfirmed group"), "degroup": _("**Removed from privileged groups**")}.get(string, default)
+# Order results from most drastic first to less drastic last
+abuselog_results = ["degroup", "blockautopromote", "rangeblock", "block", "disallow", "throttle", "warn", "tag", ""]
+abusefilter_results = lambda string, _, default: {"degroup": _("**Removed from privileged groups**"), "blockautopromote": _("Removed autoconfirmed group"), "rangeblock": _("**IP range blocked**"), "block": _("**Blocked user**"), "disallow": _("Disallowed the action"), "throttle": _("Throttled actions"), "warn": _("Warning issued"), "tag": _("Tagged the edit"), "": _("None")}.get(string, default)
+abusefilter_actions = lambda string, _, default: {"edit": _("Edit"), "upload": _("Upload"), "move": _("Move"), "stashupload": _("Stash upload"), "delete": _("Deletion"), "createaccount": _("Account creation"), "autocreateaccount": _("Auto account creation")}.get(string, default)
 
 logger = logging.getLogger("extensions.base")
 
@@ -29,6 +31,15 @@ logger = logging.getLogger("extensions.base")
 # Processing Abuselog LOG events, separate from RC logs
 
 
+def abuselog_action(results):
+	action = "unknown"
+	for result in abuselog_results:
+		if result in results:
+			action = "abuselog/{}".format(result)
+			break
+	return action
+
+
 def abuse_filter_format_user(change, settings):
 	author = change["user"]
 	if settings.get("hide_ips", False):
@@ -43,36 +54,38 @@ def abuse_filter_format_user(change, settings):
 
 @formatter.embed(event="abuselog")
 def embed_abuselog(ctx: Context, change: dict):
-	action = "abuselog/{}".format(change["result"])
-	embed = DiscordMessage(ctx.message_type, action)
+	results = change["result"].split(",")
+	action = abuselog_action(results)
+	embed = DiscordMessage(ctx.message_type, action, ctx.webhook_url)
 	author = abuse_filter_format_user(change, ctx.settings)
 	embed["title"] = ctx._("{user} triggered \"{abuse_filter}\"").format(user=author, abuse_filter=sanitize_to_markdown(change["filter"]))
-	embed.add_field(ctx._("Performed"), abusefilter_translatable(change["action"], ctx._, ctx._("Unknown")))
-	embed.add_field(ctx._("Action taken"), abusefilter_translatable(change["result"], ctx._, ctx._("Unknown")))
+	embed.add_field(ctx._("Performed"), abusefilter_actions(change["action"], ctx._, change["action"]))
 	embed.add_field(ctx._("Title"), sanitize_to_markdown(change.get("title", ctx._("Unknown"))))
+	embed.add_field(ctx._("Action taken"), ctx._(", ").join([abusefilter_results(result, ctx._, result) for result in results]))
 	return embed
 
 
 @formatter.compact(event="abuselog")
 def compact_abuselog(ctx: Context, change: dict):
-	action = "abuselog/{}".format(change["result"])
-	author_url = clean_link(create_article_path("User:{user}".format(user=change["user"])))
+	results = change["result"].split(",")
+	action = abuselog_action(results)
+	author_url = clean_link(ctx.client.create_article_path("User:{user}".format(user=change["user"])))
 	author = abuse_filter_format_user(change, ctx.settings)
 	message = ctx._("[{author}]({author_url}) triggered *{abuse_filter}*, performing the action \"{action}\" on *[{target}]({target_url})* - action taken: {result}.").format(
 		author=author, author_url=author_url, abuse_filter=sanitize_to_markdown(change["filter"]),
-		action=abusefilter_translatable(change["action"], ctx._, ctx._("Unknown")), target=change.get("title", ctx._("Unknown")),
-		target_url=clean_link(create_article_path(sanitize_to_url(change.get("title", ctx._("Unknown"))))),
-		result=abusefilter_translatable(change["result"], ctx._, ctx._("Unknown")))
-	return DiscordMessage(ctx.message_type, action, content=message)
+		action=abusefilter_actions(change["action"], ctx._, change["action"]), target=change.get("title", ctx._("Unknown")),
+		target_url=clean_link(ctx.client.create_article_path(sanitize_to_url(change.get("title", ctx._("Unknown"))))),
+		result=ctx._(", ").join([abusefilter_results(result, ctx._, result) for result in results]))
+	return DiscordMessage(ctx.message_type, action, ctx.webhook_url, content=message)
 
 # abusefilter/modify - AbuseFilter filter modification
 
 
 @formatter.embed(event="abusefilter/modify")
 def embed_abuselog_modify(ctx: Context, change: dict):
-	embed = DiscordMessage(ctx.message_type, ctx.event)
+	embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
 	embed_helper(ctx, embed, change)
-	embed["url"] = create_article_path(
+	embed["url"] = ctx.client.create_article_path(
 		"Special:AbuseFilter/history/{number}/diff/prev/{historyid}".format(number=change["logparams"]['newId'],
 																			historyid=change["logparams"]["historyId"]))
 	embed["title"] = ctx._("Edited abuse filter number {number}").format(number=change["logparams"]['newId'])
@@ -82,7 +95,7 @@ def embed_abuselog_modify(ctx: Context, change: dict):
 @formatter.compact(event="abusefilter/modify")
 def compact_abuselog_modify(ctx: Context, change: dict):
 	author, author_url = compact_author(ctx, change)
-	link = clean_link(create_article_path(
+	link = clean_link(ctx.client.create_article_path(
 		"Special:AbuseFilter/history/{number}/diff/prev/{historyid}".format(number=change["logparams"]['newId'],
 																			historyid=change["logparams"][
 																				"historyId"])))
@@ -93,16 +106,16 @@ def compact_abuselog_modify(ctx: Context, change: dict):
 																										   "logparams"][
 																										   'newId'],
 																									   filter_url=link)
-	return DiscordMessage(ctx.message_type, ctx.event, content=content)
+	return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # abusefilter/create - AbuseFilter filter creation
 
 
 @formatter.embed(event="abusefilter/create")
 def embed_abuselog_create(ctx: Context, change: dict):
-	embed = DiscordMessage(ctx.message_type, ctx.event)
+	embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
 	embed_helper(ctx, embed, change)
-	embed["url"] = create_article_path("Special:AbuseFilter/{number}".format(number=change["logparams"]['newId']))
+	embed["url"] = ctx.client.create_article_path("Special:AbuseFilter/{number}".format(number=change["logparams"]['newId']))
 	embed["title"] = ctx._("Created abuse filter number {number}").format(number=change["logparams"]['newId'])
 	return embed
 
@@ -111,11 +124,11 @@ def embed_abuselog_create(ctx: Context, change: dict):
 def compact_abuselog_create(ctx: Context, change: dict):
 	author, author_url = compact_author(ctx, change)
 	link = clean_link(
-		create_article_path("Special:AbuseFilter/{number}".format(number=change["logparams"]['newId'])))
+		ctx.client.create_article_path("Special:AbuseFilter/{number}".format(number=change["logparams"]['newId'])))
 	content = ctx._("[{author}]({author_url}) created abuse filter [number {number}]({filter_url})").format(author=author,
 																										author_url=author_url,
 																										number=change[
 																											"logparams"][
 																											'newId'],
 																										filter_url=link)
-	return DiscordMessage(ctx.message_type, ctx.event, content=content)
+	return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/cargo.py b/extensions/base/cargo.py
index 06ede38..d7ca0c1 100644
--- a/extensions/base/cargo.py
+++ b/extensions/base/cargo.py
@@ -18,14 +18,14 @@ import re
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, compact_author, create_article_path, sanitize_to_markdown
+from src.api.util import embed_helper, compact_author, sanitize_to_markdown
 
 # Cargo - https://www.mediawiki.org/wiki/Extension:Cargo
 # cargo/createtable - Creation of Cargo table
 
 @formatter.embed(event="cargo/createtable")
 def embed_cargo_createtable(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     table = re.search(r"\[(.*?)]\(<(.*?)>\)", ctx.client.parse_links(change["logparams"]["0"]))
     embed["url"] = table.group(2)
@@ -40,7 +40,7 @@ def compact_cargo_createtable(ctx: Context, change: dict):
     content = ctx._("[{author}]({author_url}) created the Cargo table \"{table}\"").format(author=author,
                                                                                        author_url=author_url,
                                                                                        table=table)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # cargo/recreatetable - Recreating a Cargo table
@@ -48,7 +48,7 @@ def compact_cargo_createtable(ctx: Context, change: dict):
 
 @formatter.embed(event="cargo/recreatetable")
 def embed_cargo_recreatetable(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     table = re.search(r"\[(.*?)]\(<(.*?)>\)", ctx.client.parse_links(change["logparams"]["0"]))
     embed["url"] = table.group(2)
@@ -63,7 +63,7 @@ def compact_cargo_recreatetable(ctx: Context, change: dict):
     content = ctx._("[{author}]({author_url}) recreated the Cargo table \"{table}\"").format(author=author,
                                                                                          author_url=author_url,
                                                                                          table=table)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # cargo/replacetable - Replacing a Cargo table
@@ -71,7 +71,7 @@ def compact_cargo_recreatetable(ctx: Context, change: dict):
 
 @formatter.embed(event="cargo/replacetable")
 def embed_cargo_replacetable(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     table = re.search(r"\[(.*?)]\(<(.*?)>\)", ctx.client.parse_links(change["logparams"]["0"]))
     embed["url"] = table.group(2)
@@ -86,7 +86,7 @@ def compact_cargo_replacetable(ctx: Context, change: dict):
     content = ctx._("[{author}]({author_url}) replaced the Cargo table \"{table}\"").format(author=author,
                                                                                         author_url=author_url,
                                                                                         table=table)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # cargo/deletetable - Deleting a table in Cargo
@@ -94,9 +94,9 @@ def compact_cargo_replacetable(ctx: Context, change: dict):
 
 @formatter.embed(event="cargo/deletetable")
 def embed_cargo_deletetable(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path("Special:CargoTables")
+    embed["url"] = ctx.client.create_article_path("Special:CargoTables")
     embed["title"] = ctx._("Deleted the Cargo table \"{table}\"").format(table=sanitize_to_markdown(change["logparams"]["0"]))
     return embed
 
@@ -107,4 +107,4 @@ def compact_cargo_deletetable(ctx: Context, change: dict):
     content = ctx._("[{author}]({author_url}) deleted the Cargo table \"{table}\"").format(author=author,
                                                                                        author_url=author_url,
                                                                                        table=sanitize_to_markdown(change["logparams"]["0"]))
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/curseprofile.py b/extensions/base/curseprofile.py
index 2b0f0b1..be9b9fb 100644
--- a/extensions/base/curseprofile.py
+++ b/extensions/base/curseprofile.py
@@ -18,7 +18,7 @@ import logging
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, clean_link, compact_author, create_article_path, sanitize_to_markdown, sanitize_to_url
+from src.api.util import embed_helper, clean_link, compact_author, sanitize_to_markdown, sanitize_to_url
 from src.misc import profile_field_name
 
 
@@ -28,7 +28,7 @@ from src.misc import profile_field_name
 
 @formatter.embed(event="curseprofile/profile-edited")
 def embed_curseprofile_profile_edited(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     target_user = change["title"].split(':', 1)[1]
     if target_user != change["user"]:
@@ -39,7 +39,7 @@ def embed_curseprofile_profile_edited(ctx: Context, change: dict) -> DiscordMess
         embed["description"] = ctx._("Cleared the {field} field").format(field=profile_field_name(change["logparams"]['4:section'], True))
     else:
         embed["description"] = ctx._("{field} field changed to: {desc}").format(field=profile_field_name(change["logparams"]['4:section'], True), desc=ctx.parsedcomment)
-    embed["url"] = create_article_path("UserProfile:" + sanitize_to_url(target_user))
+    embed["url"] = ctx.client.create_article_path("UserProfile:" + sanitize_to_url(target_user))
     return embed
 
 
@@ -47,7 +47,7 @@ def embed_curseprofile_profile_edited(ctx: Context, change: dict) -> DiscordMess
 def compact_curseprofile_profile_edited(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
     target_user = change["title"].split(':', 1)[1]
-    link = clean_link(create_article_path("UserProfile:" + sanitize_to_url(target_user)))
+    link = clean_link(ctx.client.create_article_path("UserProfile:" + sanitize_to_url(target_user)))
     if target_user != author:
         if ctx.parsedcomment is None:  # If the field is empty
             edit_clear_message = ctx._("[{author}]({author_url}) cleared the {field} on [{target}]({target_url})'s profile.")
@@ -62,7 +62,7 @@ def compact_curseprofile_profile_edited(ctx: Context, change: dict) -> DiscordMe
             edit_clear_message = ctx._("[{author}]({author_url}) edited the {field} on [their own]({target_url}) profile. *({desc})*")
         content = edit_clear_message.format(author=author, author_url=author_url, target_url=link,
             field=profile_field_name(change["logparams"]['4:section'], False), desc=ctx.parsedcomment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # curseprofile/comment-created - Creating comment on user profile
@@ -70,7 +70,7 @@ def compact_curseprofile_profile_edited(ctx: Context, change: dict) -> DiscordMe
 
 @formatter.embed(event="curseprofile/comment-created")
 def embed_curseprofile_comment_created(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     target_user = change["title"].split(':', 1)[1]
     if target_user != change["user"]:
@@ -79,7 +79,7 @@ def embed_curseprofile_comment_created(ctx: Context, change: dict) -> DiscordMes
         embed["title"] = ctx._("Left a comment on their own profile")
     if ctx.settings["appearance"]["embed"]["show_edit_changes"]:
         embed["description"] = ctx.client.pull_curseprofile_comment(change["logparams"]["4:comment_id"])
-    embed["url"] = create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
+    embed["url"] = ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
     return embed
 
 
@@ -87,13 +87,13 @@ def embed_curseprofile_comment_created(ctx: Context, change: dict) -> DiscordMes
 def compact_curseprofile_comment_created(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
     target_user = change["title"].split(':', 1)[1]
-    link = clean_link(create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
+    link = clean_link(ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
     if target_user != author:
         content = ctx._("[{author}]({author_url}) left a [comment]({comment}) on {target}'s profile.").format(
             author=author, author_url=author_url, comment=link, target=sanitize_to_markdown(target_user))
     else:
         content = ctx._("[{author}]({author_url}) left a [comment]({comment}) on their own profile.").format(author=author, author_url=author_url, comment=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # curseprofile/comment-edited - Editing comment on user profile
@@ -101,7 +101,7 @@ def compact_curseprofile_comment_created(ctx: Context, change: dict) -> DiscordM
 
 @formatter.embed(event="curseprofile/comment-edited")
 def embed_curseprofile_comment_edited(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     target_user = change["title"].split(':', 1)[1]
     if target_user != change["user"]:
@@ -110,7 +110,7 @@ def embed_curseprofile_comment_edited(ctx: Context, change: dict) -> DiscordMess
         embed["title"] = ctx._("Edited a comment on their own profile")
     if ctx.settings["appearance"]["embed"]["show_edit_changes"]:
         embed["description"] = ctx.client.pull_curseprofile_comment(change["logparams"]["4:comment_id"])
-    embed["url"] = create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
+    embed["url"] = ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
     return embed
 
 
@@ -118,13 +118,13 @@ def embed_curseprofile_comment_edited(ctx: Context, change: dict) -> DiscordMess
 def compact_curseprofile_comment_edited(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
     target_user = change["title"].split(':', 1)[1]
-    link = clean_link(create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
+    link = clean_link(ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
     if target_user != author:
         content = ctx._("[{author}]({author_url}) edited a [comment]({comment}) on {target}'s profile.").format(
             author=author, author_url=author_url, comment=link, target=sanitize_to_markdown(target_user))
     else:
         content = ctx._("[{author}]({author_url}) edited a [comment]({comment}) on their own profile.").format(author=author, author_url=author_url, comment=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # curseprofile/comment-replied - Replying to comment on user profile
@@ -132,7 +132,7 @@ def compact_curseprofile_comment_edited(ctx: Context, change: dict) -> DiscordMe
 
 @formatter.embed(event="curseprofile/comment-replied")
 def embed_curseprofile_comment_replied(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     target_user = change["title"].split(':', 1)[1]
     if target_user != change["user"]:
@@ -141,7 +141,7 @@ def embed_curseprofile_comment_replied(ctx: Context, change: dict) -> DiscordMes
         embed["title"] = ctx._("Replied to a comment on their own profile")
     if ctx.settings["appearance"]["embed"]["show_edit_changes"]:
         embed["description"] = ctx.client.pull_curseprofile_comment(change["logparams"]["4:comment_id"])
-    embed["url"] = create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
+    embed["url"] = ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
     return embed
 
 
@@ -149,13 +149,13 @@ def embed_curseprofile_comment_replied(ctx: Context, change: dict) -> DiscordMes
 def compact_curseprofile_comment_replied(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
     target_user = change["title"].split(':', 1)[1]
-    link = clean_link(create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
+    link = clean_link(ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
     if target_user != author:
         content = ctx._("[{author}]({author_url}) replied to a [comment]({comment}) on {target}'s profile.").format(
             author=author, author_url=author_url, comment=link, target=sanitize_to_markdown(target_user))
     else:
         content = ctx._("[{author}]({author_url}) replied to a [comment]({comment}) on their own profile.").format(author=author, author_url=author_url, comment=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # curseprofile/comment-deleted - Deleting comment on user profile
@@ -163,7 +163,7 @@ def compact_curseprofile_comment_replied(ctx: Context, change: dict) -> DiscordM
 
 @formatter.embed(event="curseprofile/comment-deleted")
 def embed_curseprofile_comment_deleted(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     target_user = change["title"].split(':', 1)[1]
     if target_user != change["user"]:
@@ -173,9 +173,9 @@ def embed_curseprofile_comment_deleted(ctx: Context, change: dict) -> DiscordMes
     if ctx.parsedcomment is not None:
         embed["description"] = ctx.parsedcomment
     if "4:comment_id" in change["logparams"]:
-        embed["url"] = create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
+        embed["url"] = ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"]))
     else:
-        embed["url"] = create_article_path("UserProfile:" + sanitize_to_url(target_user))
+        embed["url"] = ctx.client.create_article_path("UserProfile:" + sanitize_to_url(target_user))
     return embed
 
 
@@ -184,9 +184,9 @@ def compact_curseprofile_comment_deleted(ctx: Context, change: dict) -> DiscordM
     author, author_url = compact_author(ctx, change)
     target_user = change["title"].split(':', 1)[1]
     if "4:comment_id" in change["logparams"]:
-        link = clean_link(create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
+        link = clean_link(ctx.client.create_article_path("Special:CommentPermalink/{commentid}".format(commentid=change["logparams"]["4:comment_id"])))
     else:
-        link = clean_link(create_article_path("UserProfile:" + sanitize_to_url(target_user)))
+        link = clean_link(ctx.client.create_article_path("UserProfile:" + sanitize_to_url(target_user)))
     parsed_comment = "" if ctx.parsedcomment is None else " *(" + ctx.parsedcomment + ")*"
     if target_user != author:
         content = ctx._("[{author}]({author_url}) deleted a [comment]({comment}) on {target}'s profile.{reason}").format(
@@ -194,7 +194,7 @@ def compact_curseprofile_comment_deleted(ctx: Context, change: dict) -> DiscordM
     else:
         content = ctx._("[{author}]({author_url}) deleted a [comment]({comment}) on their own profile.{reason}").format(
             author=author, author_url=author_url, comment=link, reason=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # curseprofile/comment-purged - Purging comment on user profile
@@ -202,7 +202,7 @@ def compact_curseprofile_comment_deleted(ctx: Context, change: dict) -> DiscordM
 
 @formatter.embed(event="curseprofile/comment-purged")
 def embed_curseprofile_comment_purged(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     target_user = change["title"].split(':', 1)[1]
     if target_user != change["user"]:
@@ -211,7 +211,7 @@ def embed_curseprofile_comment_purged(ctx: Context, change: dict) -> DiscordMess
         embed["title"] = ctx._("Purged a comment on their own profile")
     if ctx.parsedcomment is not None:
         embed["description"] = ctx.parsedcomment
-    embed["url"] = create_article_path("UserProfile:" + sanitize_to_url(target_user))
+    embed["url"] = ctx.client.create_article_path("UserProfile:" + sanitize_to_url(target_user))
     return embed
 
 
@@ -219,11 +219,11 @@ def embed_curseprofile_comment_purged(ctx: Context, change: dict) -> DiscordMess
 def compact_curseprofile_comment_purged(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
     target_user = change["title"].split(':', 1)[1]
-    link = clean_link(create_article_path("UserProfile:" + sanitize_to_url(target_user)))
+    link = clean_link(ctx.client.create_article_path("UserProfile:" + sanitize_to_url(target_user)))
     parsed_comment = "" if ctx.parsedcomment is None else " *(" + ctx.parsedcomment + ")*"
     if target_user != author:
         content = ctx._("[{author}]({author_url}) purged a comment on [{target}]({link})'s profile.{reason}").format(
             author=author, author_url=author_url, link=link, target=sanitize_to_markdown(target_user), reason=parsed_comment)
     else:
         content = ctx._("[{author}]({author_url}) purged a comment on [their own]({link}) profile.{reason}").format(author=author, author_url=author_url, link=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content, reason=parsed_comment)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content, reason=parsed_comment)
diff --git a/extensions/base/datadump.py b/extensions/base/datadump.py
index ca12d4b..6b30b37 100644
--- a/extensions/base/datadump.py
+++ b/extensions/base/datadump.py
@@ -18,7 +18,7 @@ import logging
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, compact_author, create_article_path, sanitize_to_markdown, sanitize_to_url, compact_summary
+from src.api.util import embed_helper, compact_author, sanitize_to_markdown, sanitize_to_url, compact_summary
 
 
 # DataDumps - https://www.mediawiki.org/wiki/Extension:DataDump
@@ -27,10 +27,10 @@ from src.api.util import embed_helper, compact_author, create_article_path, sani
 
 @formatter.embed(event="datadump/generate")
 def embed_datadump_generate(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     embed["title"] = ctx._("Generated {file} dump").format(file=change["logparams"]["filename"])
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     return embed
 
 
@@ -42,17 +42,17 @@ def compact_datadump_generate(ctx: Context, change: dict):
         author=author, author_url=author_url, file=sanitize_to_markdown(change["logparams"]["filename"]),
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # datadump/delete - Deleting a dump of a wiki
 
 
 @formatter.embed(event="datadump/delete")
 def embed_datadump_delete(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     embed["title"] = ctx._("Deleted {file} dump").format(file=sanitize_to_markdown(change["logparams"]["filename"]))
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     return embed
 
 
@@ -64,4 +64,4 @@ def compact_datadump_delete(ctx: Context, change: dict) -> DiscordMessage:
         author=author, author_url=author_url, file=sanitize_to_markdown(change["logparams"]["filename"]),
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/discussions.py b/extensions/base/discussions.py
index 184df7d..4bb33f5 100644
--- a/extensions/base/discussions.py
+++ b/extensions/base/discussions.py
@@ -18,7 +18,7 @@
 import json
 import datetime, logging
 from urllib.parse import quote_plus
-from src.api.util import create_article_path, clean_link, sanitize_to_markdown
+from src.api.util import clean_link, sanitize_to_markdown
 from src.api.context import Context
 from src.discord.queue import send_to_discord
 from src.discord.message import DiscordMessage, DiscordMessageMetadata
@@ -137,7 +137,7 @@ def common_discussions(post: dict, embed: DiscordMessage, ctx: Context):
 
 @formatter.embed(event="discussion/forum")
 def embed_discussion_forum(ctx: Context, post: dict):
-    embed = DiscordMessage("embed", "discussion")
+    embed = DiscordMessage("embed", "discussion", ctx.settings["fandom_discussions"]["webhookURL"])
     common_discussions(post, embed, ctx)
     author = ctx._("unknown")  # Fail safe
     if post["createdBy"]["name"]:
@@ -181,7 +181,7 @@ def embed_discussion_forum(ctx: Context, post: dict):
         if post["_embedded"]["thread"][0]["tags"]:
             tag_displayname = []
             for tag in post["_embedded"]["thread"][0]["tags"]:
-                tag_displayname.append("[{title}]({url})".format(title=tag["articleTitle"], url=create_article_path(
+                tag_displayname.append("[{title}]({url})".format(title=tag["articleTitle"], url=ctx.client.create_article_path(
                     quote_plus(tag["articleTitle"].replace(" ", "_"), "/:?=&"))))
             if len(", ".join(tag_displayname)) > 1000:
                 embed.add_field(ctx.pgettext("Fandom discussions Tags/Forums", "Tags"), ctx.pgettext("Fandom discussions amount of Tags/Forums", "{} tags").format(len(post["_embedded"]["thread"][0]["tags"])))
@@ -229,7 +229,7 @@ def compact_discussion_forum(ctx: Context, post: dict):
             author=author, author_url=author_url, url=ctx.settings["fandom_discussions"]["wiki_url"],
             threadId=post["threadId"], postId=post["id"], title=post["_embedded"]["thread"][0]["title"],
             forumName=post["forumName"])
-    return DiscordMessage("compact", event_type, content=message)
+    return DiscordMessage("compact", event_type, ctx.webhook_url, content=message)
 
 # discussion/wall - Wall posts/replies
 
@@ -244,7 +244,7 @@ def compact_author_discussions(post: dict, ctx: Context):
     else:
         if post["createdBy"]["name"]:
             author = post["createdBy"]["name"]
-            author_url = clean_link(create_article_path("User:{user}".format(user=author)))
+            author_url = clean_link(ctx.client.create_article_path("User:{user}".format(user=author)))
         else:
             author_url = "<{url}f/u/{creatorId}>".format(url=ctx.settings["fandom_discussions"]["wiki_url"],
                                                      creatorId=post["creatorId"])
@@ -272,7 +272,7 @@ def embed_author_discussions(post: dict, embed: DiscordMessage, ctx: Context):
 
 @formatter.embed(event="discussion/wall")
 def embed_discussion_wall(ctx: Context, post: dict):
-    embed = DiscordMessage("embed", "discussion")
+    embed = DiscordMessage("embed", "discussion", ctx.settings["fandom_discussions"]["webhookURL"])
     common_discussions(post, embed, ctx)
     embed_author_discussions(post, embed, ctx)
     user_wall = ctx._("unknown")  # Fail safe
@@ -313,14 +313,14 @@ def compact_discussion_wall(ctx: Context, post: dict):
             author=author, author_url=author_url, url=ctx.settings["fandom_discussions"]["wiki_url"],
             title=post["_embedded"]["thread"][0]["title"], user=user_wall,
             user_wall=quote_plus(user_wall.replace(" ", "_")), threadId=post["threadId"], replyId=post["id"])
-    return DiscordMessage("compact", event_type, content=message)
+    return DiscordMessage("compact", event_type, ctx.webhook_url, content=message)
 
 # discussion/article_comment - Article comments
 
 
 @formatter.embed(event="discussion/article_comment")
 def embed_discussion_article_comment(ctx: Context, post: dict):
-    embed = DiscordMessage("embed", "discussion")
+    embed = DiscordMessage("embed", "discussion", ctx.settings["fandom_discussions"]["webhookURL"])
     common_discussions(post, embed, ctx)
     embed_author_discussions(post, embed, ctx)
     article_paths = ctx.comment_page
@@ -359,4 +359,4 @@ def compact_discussion_article_comment(ctx: Context, post: dict):
             "[{author}]({author_url}) created a [reply](<{url}?commentId={commentId}&replyId={replyId}>) to a [comment](<{url}?commentId={commentId}>) on [{article}](<{url}>)").format(
             author=author, author_url=author_url, url=article_paths["fullUrl"], article=article_paths["title"],
             commentId=post["threadId"], replyId=post["id"])
-    return DiscordMessage("compact", event_type, content=message)
+    return DiscordMessage("compact", event_type, ctx.webhook_url, content=message)
diff --git a/extensions/base/interwiki.py b/extensions/base/interwiki.py
index 355842f..1522922 100644
--- a/extensions/base/interwiki.py
+++ b/extensions/base/interwiki.py
@@ -18,7 +18,7 @@ import logging
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, clean_link, compact_author, create_article_path, sanitize_to_url, compact_summary
+from src.api.util import embed_helper, clean_link, compact_author, sanitize_to_url, compact_summary
 
 # Interwiki - https://www.mediawiki.org/wiki/Extension:Interwiki
 # interwiki/iw_add - Added entry to interwiki table
@@ -26,9 +26,9 @@ from src.api.util import embed_helper, clean_link, compact_author, create_articl
 
 @formatter.embed(event="interwiki/iw_add", mode="embed")
 def embed_interwiki_iw_add(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path("Special:Interwiki")
+    embed["url"] = ctx.client.create_article_path("Special:Interwiki")
     embed["title"] = ctx._("Added an entry to the interwiki table")
     embed["description"] = ctx._("Prefix: {prefix}, website: {website} | {desc}").format(desc=ctx.parsedcomment,
                                                                                      prefix=change["logparams"]['0'],
@@ -39,13 +39,13 @@ def embed_interwiki_iw_add(ctx: Context, change: dict) -> DiscordMessage:
 @formatter.compact(event="interwiki/iw_add")
 def compact_interwiki_iw_add(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path("Special:Interwiki"))
+    link = clean_link(ctx.client.create_article_path("Special:Interwiki"))
     parsed_comment = compact_summary(ctx)
     content = ctx._(
         "[{author}]({author_url}) added an entry to the [interwiki table]({table_url}) pointing to {website} with {prefix} prefix").format(
         author=author, author_url=author_url, desc=parsed_comment, prefix=change["logparams"]['0'],
         website=change["logparams"]['1'], table_url=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # interwiki/iw_edit - Editing interwiki entry
@@ -53,9 +53,9 @@ def compact_interwiki_iw_add(ctx: Context, change: dict) -> DiscordMessage:
 
 @formatter.embed(event="interwiki/iw_edit", mode="embed")
 def embed_interwiki_iw_edit(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path("Special:Interwiki")
+    embed["url"] = ctx.client.create_article_path("Special:Interwiki")
     embed["title"] = ctx._("Edited an entry in interwiki table")
     embed["description"] = ctx._("Prefix: {prefix}, website: {website} | {desc}").format(desc=ctx.parsedcomment,
                                                                                      prefix=change["logparams"]['0'],
@@ -66,13 +66,13 @@ def embed_interwiki_iw_edit(ctx: Context, change: dict) -> DiscordMessage:
 @formatter.compact(event="interwiki/iw_edit")
 def compact_interwiki_iw_edit(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path("Special:Interwiki"))
+    link = clean_link(ctx.client.create_article_path("Special:Interwiki"))
     parsed_comment = compact_summary(ctx)
     content = ctx._(
         "[{author}]({author_url}) edited an entry in [interwiki table]({table_url}) pointing to {website} with {prefix} prefix").format(
         author=author, author_url=author_url, desc=parsed_comment, prefix=change["logparams"]['0'],
         website=change["logparams"]['1'], table_url=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # interwiki/iw_delete - Deleting interwiki entry
@@ -80,9 +80,9 @@ def compact_interwiki_iw_edit(ctx: Context, change: dict) -> DiscordMessage:
 
 @formatter.embed(event="interwiki/iw_delete", mode="embed")
 def embed_interwiki_iw_delete(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path("Special:Interwiki")
+    embed["url"] = ctx.client.create_article_path("Special:Interwiki")
     embed["title"] = ctx._("Deleted an entry in interwiki table")
     embed["description"] = ctx._("Prefix: {prefix} | {desc}").format(desc=ctx.parsedcomment,
                                                                  prefix=change["logparams"]['0'])
@@ -92,7 +92,7 @@ def embed_interwiki_iw_delete(ctx: Context, change: dict) -> DiscordMessage:
 @formatter.compact(event="interwiki/iw_delete")
 def compact_interwiki_iw_delete(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path("Special:Interwiki"))
+    link = clean_link(ctx.client.create_article_path("Special:Interwiki"))
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) deleted an entry in [interwiki table]({table_url}){desc}").format(
         author=author,
@@ -100,4 +100,4 @@ def compact_interwiki_iw_delete(ctx: Context, change: dict) -> DiscordMessage:
         table_url=link,
         desc=parsed_comment)
 
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/managewiki.py b/extensions/base/managewiki.py
index d743e8f..57ab639 100644
--- a/extensions/base/managewiki.py
+++ b/extensions/base/managewiki.py
@@ -16,7 +16,7 @@
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, compact_author, create_article_path, sanitize_to_markdown, sanitize_to_url, compact_summary
+from src.api.util import embed_helper, compact_author, sanitize_to_markdown, sanitize_to_url, compact_summary
 
 
 # ManageWiki - https://www.mediawiki.org/wiki/Special:MyLanguage/Extension:ManageWiki
@@ -24,9 +24,9 @@ from src.api.util import embed_helper, compact_author, create_article_path, sani
 
 @formatter.embed(event="managewiki/settings")
 def embed_managewiki_settings(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Changed wiki settings")
     if change["logparams"].get("changes", ""):
         embed.add_field("Setting", sanitize_to_markdown(change["logparams"].get("changes")))
@@ -38,16 +38,16 @@ def compact_managewiki_settings(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) changed wiki settings{reason}".format(author=author, author_url=author_url, reason=parsed_comment))
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/delete - Deleting a wiki
 
 
 @formatter.embed(event="managewiki/delete")
 def embed_managewiki_delete(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Deleted a \"{wiki}\" wiki").format(wiki=change["logparams"].get("wiki", ctx._("Unknown")))
     return embed
 
@@ -62,16 +62,16 @@ def compact_managewiki_delete(ctx: Context, change: dict):
                                                                                              "logparams"].get("wiki",
                                                                                                               ctx._("Unknown")),
                                                                                          comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/delete-group - Deleting a group
 
 
 @formatter.embed(event="managewiki/delete-group")
 def embed_managewiki_delete_group(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     group = change["title"].split("/")[-1]
     embed["title"] = ctx._("Deleted a \"{group}\" user group").format(wiki=group)
     return embed
@@ -86,16 +86,16 @@ def compact_managewiki_delete_group(ctx: Context, change: dict) -> DiscordMessag
                                                                                          author_url=author_url,
                                                                                          group=group,
                                                                                          comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/lock - Locking a wiki
 
 
 @formatter.embed(event="managewiki/lock")
 def embed_managewiki_lock(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Locked a \"{wiki}\" wiki").format(wiki=change["logparams"].get("wiki", ctx._("Unknown")))
     return embed
 
@@ -107,16 +107,16 @@ def compact_managewiki_lock(ctx: Context, change: dict):
     content = ctx._("[{author}]({author_url}) locked a wiki *{wiki_name}*{comment}").format(
         author=author, author_url=author_url, wiki_name=change["logparams"].get("wiki", ctx._("Unknown")),
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/namespaces - Modirying a wiki namespace
 
 
 @formatter.embed(event="managewiki/namespaces")
 def embed_managewiki_namespaces(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Modified \"{namespace_name}\" namespace").format(
         namespace_name=change["logparams"].get("namespace", ctx._("Unknown")))
     embed.add_field(ctx._('Wiki'), change["logparams"].get("wiki", ctx._("Unknown")))
@@ -130,16 +130,16 @@ def compact_managewiki_namespaces(ctx: Context, change: dict):
     content = ctx._("[{author}]({author_url}) modified namespace *{namespace_name}* on *{wiki_name}*{comment}").format(
         author=author, author_url=author_url, namespace_name=change["logparams"].get("namespace", ctx._("Unknown")),
         wiki_name=change["logparams"].get("wiki", ctx._("Unknown")), comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/namespaces-delete - Deleteing a namespace
 
 
 @formatter.embed(event="managewiki/namespaces-delete")
 def embed_managewiki_namespaces_delete(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Deleted a \"{namespace_name}\" namespace").format(
         namespace_name=change["logparams"].get("namespace", ctx._("Unknown")))
     embed.add_field(ctx._('Wiki'), change["logparams"].get("wiki", ctx._("Unknown")))
@@ -155,16 +155,16 @@ def compact_managewiki_namespaces_delete(ctx: Context, change: dict):
         author=author, author_url=author_url,
         namespace_name=change["logparams"].get("namespace", ctx._("Unknown")),
         wiki_name=change["logparams"].get("wiki", ctx._("Unknown")), comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/rights - Modifying user groups
 
 
 @formatter.embed(event="managewiki/rights")
 def embed_managewiki_rights(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     group_name = change["title"].split("/permissions/", 1)[1]
     embed["title"] = ctx._("Modified \"{usergroup_name}\" usergroup").format(usergroup_name=group_name)
     return embed
@@ -178,16 +178,16 @@ def compact_managewiki_rights(ctx: Context, change: dict):
     content = ctx._("[{author}]({author_url}) modified user group *{group_name}*{comment}").format(
         author=author, author_url=author_url, group_name=group_name, comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/undelete - Restoring a wiki
 
 
 @formatter.embed(event="managewiki/undelete")
 def embed_managewiki_undelete(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Undeleted a \"{wiki}\" wiki").format(wiki=change["logparams"].get("wiki", ctx._("Unknown")))
     return embed
 
@@ -200,16 +200,16 @@ def compact_managewiki_undelete(ctx: Context, change: dict):
         author=author, author_url=author_url, wiki_name=change["logparams"].get("wiki", ctx._("Unknown")),
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # managewiki/unlock - Unlocking a wiki
 
 
 @formatter.embed(event="managewiki/unlock")
 def embed_managewiki_unlock(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Unlocked a \"{wiki}\" wiki").format(wiki=change["logparams"].get("wiki", ctx._("Unknown")))
     return embed
 
@@ -222,4 +222,4 @@ def compact_managewiki_unlock(ctx: Context, change: dict):
         author=author, author_url=author_url, wiki_name=change["logparams"].get("wiki", ctx._("Unknown")),
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/mediawiki.py b/extensions/base/mediawiki.py
index a33da4e..8b038de 100644
--- a/extensions/base/mediawiki.py
+++ b/extensions/base/mediawiki.py
@@ -23,7 +23,7 @@ from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
 from src.api.util import embed_helper, sanitize_to_url, parse_mediawiki_changes, clean_link, compact_author, \
-    create_article_path, sanitize_to_markdown, compact_summary
+    sanitize_to_markdown, compact_summary
 from src.exceptions import *
 
 logger = logging.getLogger("extensions.base")
@@ -39,7 +39,7 @@ if 1 == 2:  # additional translation strings in unreachable code
 
 @formatter.embed(event="edit", mode="embed", aliases=["new"])
 def embed_edit(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     action = ctx.event
     editsize = change["newlen"] - change["oldlen"]
     if editsize > 0:
@@ -113,14 +113,14 @@ def compact_edit(ctx: Context, change: dict) -> DiscordMessage:
             "[{author}]({author_url}) created [{article}]({edit_link}){comment} {bold}({sign}{edit_size}){bold}").format(
             author=author, author_url=author_url, article=sanitize_to_markdown(change["title"]), edit_link=edit_link, comment=parsed_comment,
             edit_size=edit_size, sign=sign, bold=bold)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # Upload - upload/reupload, upload/upload
 @formatter.embed(event="upload/upload", mode="embed", aliases=["upload/overwrite", "upload/revert"])
 def embed_upload_upload(ctx, change) -> DiscordMessage:
     license = None
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     action = ctx.event
     # Requesting more information on the image
     request_for_image_data = None
@@ -154,7 +154,7 @@ def embed_upload_upload(ctx, change) -> DiscordMessage:
         else:
             logger.warning("Request for additional image information have failed. The preview will not be shown.")
             request_for_image_data = None
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     image_direct_url = None
     # Make a request for file revisions so we can get direct URL to the image for embed
     if request_for_image_data is not None:
@@ -228,29 +228,29 @@ def embed_upload_upload(ctx, change) -> DiscordMessage:
 @formatter.compact(event="upload/revert", mode="compact")
 def compact_upload_revert(ctx, change) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    file_link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    file_link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) reverted a version of [{file}]({file_link}){comment}").format(
         author=author, author_url=author_url, file=sanitize_to_markdown(change["title"]), file_link=file_link,
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 @formatter.compact(event="upload/overwrite", mode="compact")
 def compact_upload_overwrite(ctx, change) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    file_link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    file_link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) uploaded a new version of [{file}]({file_link}){comment}").format(
         author=author, author_url=author_url, file=sanitize_to_markdown(change["title"]), file_link=file_link,
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 @formatter.compact(event="upload/upload", mode="compact")
 def compact_upload_upload(ctx, change) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    file_link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    file_link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) uploaded [{file}]({file_link}){comment}").format(author=author,
                                                                                            author_url=author_url,
@@ -258,15 +258,15 @@ def compact_upload_upload(ctx, change) -> DiscordMessage:
                                                                                                change["title"]),
                                                                                            file_link=file_link,
                                                                                            comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # delete/delete - Page deletion
 @formatter.embed(event="delete/delete", mode="embed")
 def embed_delete_delete(ctx, change) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed['url'] = create_article_path(sanitize_to_url(change["title"]))
+    embed['url'] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Deleted page {article}").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -275,22 +275,22 @@ def embed_delete_delete(ctx, change) -> DiscordMessage:
 def compact_delete_delete(ctx, change) -> DiscordMessage:
     parsed_comment = compact_summary(ctx)
     author, author_url = compact_author(ctx, change)
-    page_link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    page_link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._("[{author}]({author_url}) deleted [{page}]({page_link}){comment}").format(author=author,
                                                                                           author_url=author_url,
                                                                                           page=sanitize_to_markdown(
                                                                                               change["title"]),
                                                                                           page_link=page_link,
                                                                                           comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # delete/delete_redir - Redirect deletion
 @formatter.embed(event="delete/delete_redir", mode="embed")
 def embed_delete_delete_redir(ctx, change) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed['url'] = create_article_path(sanitize_to_url(change["title"]))
+    embed['url'] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Deleted redirect {article} by overwriting").format(
         article=sanitize_to_markdown(change["title"]))
     return embed
@@ -298,13 +298,13 @@ def embed_delete_delete_redir(ctx, change) -> DiscordMessage:
 
 @formatter.compact(event="delete/delete_redir", mode="compact")
 def compact_delete_delete_redir(ctx, change) -> DiscordMessage:
-    page_link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    page_link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) deleted redirect by overwriting [{page}]({page_link}){comment}").format(
         author=author, author_url=author_url, page=sanitize_to_markdown(change["title"]), page_link=page_link,
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # delete/restore - Restoring a page
@@ -312,16 +312,16 @@ def compact_delete_delete_redir(ctx, change) -> DiscordMessage:
 
 @formatter.embed(event="delete/restore", mode="embed")
 def embed_delete_restore(ctx, change) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed['url'] = create_article_path(sanitize_to_url(change["title"]))
+    embed['url'] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Restored {article}").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
 
 @formatter.compact(event="delete/restore", mode="compact")
 def compact_delete_restore(ctx, change) -> DiscordMessage:
-    page_link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    page_link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) restored [{article}]({article_url}){comment}").format(author=author,
@@ -330,7 +330,7 @@ def compact_delete_restore(ctx, change) -> DiscordMessage:
                                                                                                     change["title"]),
                                                                                                 article_url=page_link,
                                                                                                 comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # delete/event - Deleting an event with revdelete feature
@@ -338,9 +338,9 @@ def compact_delete_restore(ctx, change) -> DiscordMessage:
 
 @formatter.embed(event="delete/event", mode="embed")
 def embed_delete_event(ctx, change) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed['url'] = create_article_path("Special:RecentChanges")
+    embed['url'] = ctx.client.create_article_path("Special:RecentChanges")
     embed["title"] = ctx._("Changed visibility of log events")
     return embed
 
@@ -352,17 +352,17 @@ def compact_delete_event(ctx, change) -> DiscordMessage:
     content = ctx._("[{author}]({author_url}) changed visibility of log events{comment}").format(author=author,
                                                                                              author_url=author_url,
                                                                                              comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # delete/revision - Deleting revision information
 
 @formatter.embed(event="delete/revision", mode="embed")
 def embed_delete_revision(ctx, change) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     amount = len(change["logparams"]["ids"])
-    embed['url'] = create_article_path(sanitize_to_url(change["title"]))
+    embed['url'] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx.ngettext("Changed visibility of revision on page {article} ",
                               "Changed visibility of {amount} revisions on page {article} ", amount).format(
         article=sanitize_to_markdown(change["title"]), amount=amount)
@@ -373,14 +373,14 @@ def embed_delete_revision(ctx, change) -> DiscordMessage:
 def compact_delete_revision(ctx, change) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
     amount = len(change["logparams"]["ids"])
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx.ngettext(
         "[{author}]({author_url}) changed visibility of revision on page [{article}]({article_url}){comment}",
         "[{author}]({author_url}) changed visibility of {amount} revisions on page [{article}]({article_url}){comment}",
         amount).format(author=author, author_url=author_url,
                        article=sanitize_to_markdown(change["title"]), article_url=link, amount=amount, comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # move/move - Moving pages
@@ -388,9 +388,9 @@ def compact_delete_revision(ctx, change) -> DiscordMessage:
 
 @formatter.embed(event="move/move", mode="embed")
 def embed_move_move(ctx, change) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path(sanitize_to_url(change["logparams"]['target_title']))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["logparams"]['target_title']))
     embed["description"] = "{supress}. {desc}".format(desc=ctx.parsedcomment,
                                                       supress=ctx._("No redirect has been made") if "suppressredirect" in
                                                               change["logparams"] else ctx._("A redirect has been made"))
@@ -404,7 +404,7 @@ def embed_move_move(ctx, change) -> DiscordMessage:
 @formatter.compact(event="move/move", mode="compact")
 def compact_move_move(ctx, change) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["logparams"]['target_title'])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]['target_title'])))
     redirect_status = ctx._("without making a redirect") if "suppressredirect" in change["logparams"] else ctx._(
         "with a redirect")
     parsed_comment = compact_summary(ctx)
@@ -413,7 +413,7 @@ def compact_move_move(ctx, change) -> DiscordMessage:
         author=author, author_url=author_url, redirect="⤷ " if "redirect" in change else "", article=sanitize_to_markdown(change["title"]),
         target=sanitize_to_markdown(change["logparams"]['target_title']), target_url=link, comment=parsed_comment,
         made_a_redirect=redirect_status)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # move/move_redir - Move over redirect
@@ -421,9 +421,9 @@ def compact_move_move(ctx, change) -> DiscordMessage:
 
 @formatter.embed(event="move/move_redir", mode="embed")
 def embed_move_move_redir(ctx, change) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path(sanitize_to_url(change["logparams"]['target_title']))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["logparams"]['target_title']))
     embed["description"] = "{supress}. {desc}".format(desc=ctx.parsedcomment,
                                                       supress=ctx._("No redirect has been made") if "suppressredirect" in
                                                               change["logparams"] else ctx._("A redirect has been made"))
@@ -436,7 +436,7 @@ def embed_move_move_redir(ctx, change) -> DiscordMessage:
 @formatter.compact(event="move/move_redir", mode="compact")
 def compact_move_move_redir(ctx, change) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["logparams"]['target_title'])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]['target_title'])))
     redirect_status = ctx._("without making a redirect") if "suppressredirect" in change["logparams"] else ctx._(
         "with a redirect")
     parsed_comment = compact_summary(ctx)
@@ -446,7 +446,7 @@ def compact_move_move_redir(ctx, change) -> DiscordMessage:
         article=sanitize_to_markdown(change["title"]),
         target=sanitize_to_markdown(change["logparams"]['target_title']), target_url=link, comment=parsed_comment,
         made_a_redirect=redirect_status)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # protect/move_prot - Moving protection
@@ -454,9 +454,9 @@ def compact_move_move_redir(ctx, change) -> DiscordMessage:
 
 @formatter.embed(event="protect/move_prot", mode="embed")
 def embed_protect_move_prot(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["logparams"]["oldtitle_title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["logparams"]["oldtitle_title"]))
     embed["title"] = ctx._("Moved protection settings from {redirect}{article} to {title}").format(
         redirect="⤷ " if "redirect" in change else "",
         article=sanitize_to_markdown(change["logparams"]["oldtitle_title"]),
@@ -467,14 +467,14 @@ def embed_protect_move_prot(ctx, change):
 @formatter.compact(event="protect/move_prot", mode="compact")
 def compact_protect_move_prot(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["logparams"]["oldtitle_title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]["oldtitle_title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._(
         "[{author}]({author_url}) moved protection settings from {redirect}*{article}* to [{target}]({target_url}){comment}").format(
         author=author, author_url=author_url, redirect="⤷ " if "redirect" in change else "",
         article=sanitize_to_markdown(change["logparams"]["oldtitle_title"]),
         target=sanitize_to_markdown(change["title"]), target_url=link, comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # protect/protect - Creating protection
@@ -482,9 +482,9 @@ def compact_protect_move_prot(ctx, change):
 
 @formatter.embed(event="protect/protect", mode="embed")
 def embed_protect_protect(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Protected {target}").format(target=sanitize_to_markdown(change["title"]))
     embed["description"] = "{settings}{cascade} | {reason}".format(
         settings=sanitize_to_markdown(change["logparams"].get("description", "")),
@@ -496,7 +496,7 @@ def embed_protect_protect(ctx, change):
 @formatter.compact(event="protect/protect", mode="compact")
 def compact_protect_protect(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._(
         "[{author}]({author_url}) protected [{article}]({article_url}) with the following settings: {settings}{comment}").format(
@@ -505,7 +505,7 @@ def compact_protect_protect(ctx, change):
         settings=change["logparams"].get("description", "") + (
             ctx._(" [cascading]") if "cascade" in change["logparams"] else ""),
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # protect/modify - Changing protection settings
@@ -513,9 +513,9 @@ def compact_protect_protect(ctx, change):
 
 @formatter.embed(event="protect/modify", mode="embed")
 def embed_protect_modify(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Changed protection level for {article}").format(article=sanitize_to_markdown(change["title"]))
     embed["description"] = "{settings}{cascade} | {reason}".format(
         settings=sanitize_to_markdown(change["logparams"].get("description", "")),
@@ -527,7 +527,7 @@ def embed_protect_modify(ctx, change):
 @formatter.compact(event="protect/modify", mode="compact")
 def compact_protect_modify(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._(
         "[{author}]({author_url}) modified protection settings of [{article}]({article_url}) to: {settings}{comment}").format(
@@ -536,7 +536,7 @@ def compact_protect_modify(ctx, change):
         settings=sanitize_to_markdown(change["logparams"].get("description", "")) + (
             ctx._(" [cascading]") if "cascade" in change["logparams"] else ""),
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # protect/unprotect - Unprotecting a page
@@ -544,9 +544,9 @@ def compact_protect_modify(ctx, change):
 
 @formatter.embed(event="protect/unprotect", mode="embed")
 def embed_protect_unprotect(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Removed protection from {article}").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -554,12 +554,12 @@ def embed_protect_unprotect(ctx, change):
 @formatter.compact(event="protect/unprotect", mode="compact")
 def compact_protect_unprotect(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) removed protection from [{article}]({article_url}){comment}").format(
         author=author, author_url=author_url, article=sanitize_to_markdown(change["title"]), article_url=link,
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # block/block - Blocking an user
@@ -590,13 +590,13 @@ def block_expiry(change: dict, ctx: Context) -> str:
 
 @formatter.embed(event="block/block", mode="embed")
 def embed_block_block(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     user = change["title"].split(':', 1)[1]
     try:
         ipaddress.ip_address(user)
-        embed["url"] = create_article_path("Special:Contributions/{user}".format(user=user))
+        embed["url"] = ctx.client.create_article_path("Special:Contributions/{user}".format(user=user))
     except ValueError:
-        embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+        embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     if "sitewide" not in change["logparams"]:
         restriction_description = ""
         if "restrictions" in change["logparams"]:
@@ -639,9 +639,9 @@ def compact_block_block(ctx, change):
     parsed_comment = compact_summary(ctx)
     try:
         ipaddress.ip_address(user)
-        link = clean_link(create_article_path("Special:Contributions/{user}".format(user=user)))
+        link = clean_link(ctx.client.create_article_path("Special:Contributions/{user}".format(user=user)))
     except ValueError:
-        link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+        link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     else:
         if "sitewide" not in change["logparams"]:
             if "restrictions" in change["logparams"]:
@@ -676,15 +676,15 @@ def compact_block_block(ctx, change):
                                                                                                           user_url=link,
                                                                                                           restriction_desc=restriction_description,
                                                                                                           comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # block/reblock - Changing settings of a block
 @formatter.embed(event="block/reblock", mode="embed")
 def embed_block_reblock(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     user = change["title"].split(':', 1)[1]
     embed["title"] = ctx._("Changed block settings for {blocked_user}").format(blocked_user=sanitize_to_markdown(user))
     return embed
@@ -693,21 +693,21 @@ def embed_block_reblock(ctx, change):
 @formatter.compact(event="block/reblock")
 def compact_block_reblock(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     user = change["title"].split(':', 1)[1]
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) changed block settings for [{blocked_user}]({user_url}){comment}").format(
         author=author, author_url=author_url, blocked_user=sanitize_to_markdown(user), user_url=link, comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # block/unblock - Unblocking an user
 
 @formatter.embed(event="block/unblock", mode="embed")
 def embed_block_unblock(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     user = change["title"].split(':', 1)[1]
     embed["title"] = ctx._("Unblocked {blocked_user}").format(blocked_user=sanitize_to_markdown(user))
     return embed
@@ -716,7 +716,7 @@ def embed_block_unblock(ctx, change):
 @formatter.compact(event="block/unblock")
 def compact_block_unblock(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     user = change["title"].split(':', 1)[1]
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) unblocked [{blocked_user}]({user_url}){comment}").format(author=author,
@@ -725,7 +725,7 @@ def compact_block_unblock(ctx, change):
                                                                                                    user_url=link,
                                                                                                    comment=parsed_comment)
 
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # suppressed - Custom event for whenever there is limited information available about the event due to revdel
@@ -733,8 +733,8 @@ def compact_block_unblock(ctx, change):
 
 @formatter.embed(event="suppressed", mode="embed")
 def embed_suppressed(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
-    embed["url"] = create_article_path("")
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
+    embed["url"] = ctx.client.create_article_path("")
     embed["title"] = ctx._("Action has been hidden by administration")
     embed["author"]["name"] = ctx._("Unknown")
     return embed
@@ -743,16 +743,16 @@ def embed_suppressed(ctx, change):
 @formatter.compact(event="suppressed", mode="compact")
 def compact_suppressed(ctx, change):
     content = ctx._("An action has been hidden by administration.")
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # import/upload - Importing pages by uploading exported XML files
 
 @formatter.embed(event="import/upload", mode="embed")
 def embed_import_upload(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx.ngettext("Imported {article} with {count} revision",
                               "Imported {article} with {count} revisions", change["logparams"]["count"]).format(
         article=sanitize_to_markdown(change["title"]), count=change["logparams"]["count"])
@@ -761,7 +761,7 @@ def embed_import_upload(ctx, change):
 
 @formatter.compact(event="import/upload", mode="compact")
 def compact_import_upload(ctx, change):
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
     content = ctx.ngettext("[{author}]({author_url}) imported [{article}]({article_url}) with {count} revision{comment}",
@@ -769,7 +769,7 @@ def compact_import_upload(ctx, change):
                        change["logparams"]["count"]).format(
         author=author, author_url=author_url, article=sanitize_to_markdown(change["title"]), article_url=link,
         count=change["logparams"]["count"], comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # import/interwiki - Importing interwiki entries
@@ -777,9 +777,9 @@ def compact_import_upload(ctx, change):
 
 @formatter.embed(event="import/interwiki", mode="embed")
 def embed_import_interwiki(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx.ngettext("Imported {article} with {count} revision from \"{source}\"",
                               "Imported {article} with {count} revisions from \"{source}\"",
                               change["logparams"]["count"]).format(
@@ -790,9 +790,9 @@ def embed_import_interwiki(ctx, change):
 
 @formatter.compact(event="import/interwiki", mode="compact")
 def compact_import_interwiki(ctx, change):
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     author, author_url = compact_author(ctx, change)
-    source_link = clean_link(create_article_path(change["logparams"]["interwiki_title"]))
+    source_link = clean_link(ctx.client.create_article_path(change["logparams"]["interwiki_title"]))
     parsed_comment = compact_summary(ctx)
     content = ctx.ngettext(
         "[{author}]({author_url}) imported [{article}]({article_url}) with {count} revision from [{source}]({source_url}){comment}",
@@ -802,7 +802,7 @@ def compact_import_interwiki(ctx, change):
         count=change["logparams"]["count"], source=sanitize_to_markdown(change["logparams"]["interwiki_title"]),
         source_url=source_link,
         comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # rights/rights - Assigning rights groups
@@ -824,8 +824,8 @@ def get_changed_groups(change: dict, ctx: Context) -> [[str], [str]]:
 
 @formatter.embed(event="rights/rights", aliases=["rights/autopromote"])
 def embed_rights_rights(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
-    embed["url"] = create_article_path(sanitize_to_url("User:{}".format(change["title"].split(":")[1])))
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url("User:{}".format(change["title"].split(":")[1])))
     if ctx.event == "rights/rights":
         embed["title"] = ctx._("Changed group membership for {target}").format(target=sanitize_to_markdown(change["title"].split(":")[1]))
     else:
@@ -845,7 +845,7 @@ def embed_rights_rights(ctx, change):
 
 @formatter.compact(event="rights/rights", aliases=["rights/autopromote"])
 def compact_rights_rights(ctx, change):
-    link = clean_link(create_article_path(sanitize_to_url("User:{user}".format(user=change["title"].split(":")[1]))))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url("User:{user}".format(user=change["title"].split(":")[1]))))
     added, removed = get_changed_groups(change, ctx)
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
@@ -865,16 +865,16 @@ def compact_rights_rights(ctx, change):
         content = ctx._("The system autopromoted [{target}]({target_url}) to {added}.{comment}").format(
             target=sanitize_to_markdown(change["title"].split(":")[1]), target_url=link,
             added=ctx._(", ").join(added), comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # merge/merge - Merging histories of two pages
 
 @formatter.embed(event="merge/merge", mode="embed")
 def embed_merge_merge(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Merged revision histories of {article} into {dest}").format(
         article=sanitize_to_markdown(change["title"]),
         dest=sanitize_to_markdown(change["logparams"][
@@ -886,13 +886,13 @@ def embed_merge_merge(ctx, change):
 def compact_merge_merge(ctx, change):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
-    link_dest = clean_link(create_article_path(sanitize_to_url(change["logparams"]["dest_title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
+    link_dest = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]["dest_title"])))
     content = ctx._(
         "[{author}]({author_url}) merged revision histories of [{article}]({article_url}) into [{dest}]({dest_url}){comment}").format(
         author=author, author_url=author_url, article=sanitize_to_markdown(change["title"]), article_url=link, dest_url=link_dest,
         dest=sanitize_to_markdown(change["logparams"]["dest_title"]), comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # newusers/autocreate - Auto creation of user account
@@ -900,9 +900,9 @@ def compact_merge_merge(ctx, change):
 
 @formatter.embed(event="newusers/autocreate", mode="embed")
 def embed_newusers_autocreate(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Created account automatically")
     return embed
 
@@ -912,7 +912,7 @@ def compact_newusers_autocreate(ctx, change):
     author, author_url = compact_author(ctx, change)
     content = ctx._("Account [{author}]({author_url}) was created automatically").format(author=author,
                                                                                      author_url=author_url)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # newusers/create - Auto creation of user account
@@ -920,9 +920,9 @@ def compact_newusers_autocreate(ctx, change):
 
 @formatter.embed(event="newusers/create", mode="embed")
 def embed_newusers_create(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Created account")
     return embed
 
@@ -931,7 +931,7 @@ def embed_newusers_create(ctx, change):
 def compact_newusers_create(ctx, change):
     author, author_url = compact_author(ctx, change)
     content = ctx._("Account [{author}]({author_url}) was created").format(author=author, author_url=author_url)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # newusers/autocreate - Auto creation of user account
@@ -939,9 +939,9 @@ def compact_newusers_create(ctx, change):
 
 @formatter.embed(event="newusers/create2", mode="embed")
 def embed_newusers_create2(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Created account {article}").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -950,10 +950,10 @@ def embed_newusers_create2(ctx, change):
 def compact_newusers_create2(ctx, change):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._("Account [{article}]({article_url}) was created by [{author}]({author_url}){comment}").format(
         article=sanitize_to_markdown(change["title"]), article_url=link, author=author, author_url=author_url, comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # newusers/byemail - Creation of account by email
@@ -961,9 +961,9 @@ def compact_newusers_create2(ctx, change):
 
 @formatter.embed(event="newusers/byemail", mode="embed")
 def embed_newusers_byemail(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Created account {article} and password was sent by email").format(
         article=sanitize_to_markdown(change["title"]))
     return embed
@@ -973,11 +973,11 @@ def embed_newusers_byemail(ctx, change):
 def compact_newusers_byemail(ctx, change):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._(
         "Account [{article}]({article_url}) was created by [{author}]({author_url}) and password was sent by email{comment}").format(
         article=sanitize_to_markdown(change["title"]), article_url=link, author=author, author_url=author_url, comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # newusers/newusers - New users
@@ -985,9 +985,9 @@ def compact_newusers_byemail(ctx, change):
 
 @formatter.embed(event="newusers/newusers", mode="embed")
 def embed_newusers_newusers(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url("User:{}".format(change["user"])))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url("User:{}".format(change["user"])))
     embed["title"] = ctx._("Created account")
     return embed
 
@@ -996,7 +996,7 @@ def embed_newusers_newusers(ctx, change):
 def compact_newusers_newusers(ctx, change):
     author, author_url = compact_author(ctx, change)
     content = ctx._("Account [{author}]({author_url}) was created").format(author=author, author_url=author_url)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # newusers/reclaim - New user reclaimed
@@ -1004,9 +1004,9 @@ def compact_newusers_newusers(ctx, change):
 
 @formatter.embed(event="newusers/reclaim", mode="embed")
 def embed_newusers_reclaim(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url("User:{}".format(change["user"])))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url("User:{}".format(change["user"])))
     embed["title"] = ctx._("Reclaimed account")
     return embed
 
@@ -1015,7 +1015,7 @@ def embed_newusers_reclaim(ctx, change):
 def compact_newusers_reclaim(ctx, change):
     author, author_url = compact_author(ctx, change)
     content = ctx._("Account [{author}]({author_url}) was reclaimed").format(author=author, author_url=author_url)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # contentmodel/change - Changing the content model of a page
@@ -1023,9 +1023,9 @@ def compact_newusers_reclaim(ctx, change):
 
 @formatter.embed(event="contentmodel/change", mode="embed")
 def embed_contentmodel_change(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Changed the content model of the page {article}").format(
         article=sanitize_to_markdown(change["title"]))
     embed["description"] = ctx._("Model changed from {old} to {new}: {reason}").format(old=change["logparams"]["oldmodel"],
@@ -1037,14 +1037,14 @@ def embed_contentmodel_change(ctx, change):
 @formatter.compact(event="contentmodel/change")
 def compact_contentmodel_change(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._(
         "[{author}]({author_url}) changed the content model of the page [{article}]({article_url}) from {old} to {new}{comment}").format(
         author=author, author_url=author_url, article=sanitize_to_markdown(change["title"]), article_url=link,
         old=change["logparams"]["oldmodel"],
         new=change["logparams"]["newmodel"], comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # contentmodel/new - Creating a page with non-default content model
@@ -1052,9 +1052,9 @@ def compact_contentmodel_change(ctx, change):
 
 @formatter.embed(event="contentmodel/new", mode="embed")
 def embed_contentmodel_new(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change, set_desc=False)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Created the page {article} using a non-default content model").format(
         article=sanitize_to_markdown(change["title"]))
     embed["description"] = ctx._("Created with model {new}: {reason}").format(new=change["logparams"]["newmodel"],
@@ -1065,13 +1065,13 @@ def embed_contentmodel_new(ctx, change):
 @formatter.compact(event="contentmodel/new")
 def compact_contentmodel_new(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._(
         "[{author}]({author_url}) created the page [{article}]({article_url}) using a non-default content model {new}{comment}").format(
         author=author, author_url=author_url, article=sanitize_to_markdown(change["title"]), article_url=link,
         new=change["logparams"]["newmodel"], comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # managetags/create - Creating log tags
@@ -1079,10 +1079,10 @@ def compact_contentmodel_new(ctx, change):
 
 @formatter.embed(event="managetags/create", mode="embed")
 def embed_managetags_create(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     ctx.client.refresh_internal_data()
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Created the tag \"{tag}\"").format(tag=sanitize_to_markdown(change["logparams"]["tag"]))
     return embed
 
@@ -1090,7 +1090,7 @@ def embed_managetags_create(ctx, change):
 @formatter.compact(event="managetags/create")
 def compact_managetags_create(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     ctx.client.refresh_internal_data()
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) created the [tag]({tag_url}) \"{tag}\"{comment}").format(author=author,
@@ -1103,7 +1103,7 @@ def compact_managetags_create(ctx, change):
                                                                                                    tag_url=link,
                                                                                                    comment=parsed_comment)
 
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # managetags/delete - Deleting a tag
@@ -1111,9 +1111,9 @@ def compact_managetags_create(ctx, change):
 
 @formatter.embed(event="managetags/delete", mode="embed")
 def embed_managetags_delete(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     ctx.client.refresh_internal_data()
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Deleted the tag \"{tag}\"").format(tag=sanitize_to_markdown(change["logparams"]["tag"]))
     if change["logparams"]["count"] > 0:
         embed.add_field(ctx._('Removed from'), ctx.ngettext("{} revision or log entry", "{} revisions and/or log entries",
@@ -1125,7 +1125,7 @@ def embed_managetags_delete(ctx, change):
 @formatter.compact(event="managetags/delete")
 def compact_managetags_delete(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     ctx.client.refresh_internal_data()
     parsed_comment = compact_summary(ctx)
     if change["logparams"]["count"] == 0:
@@ -1145,7 +1145,7 @@ def compact_managetags_delete(ctx, change):
                                                  tag=sanitize_to_markdown(change["logparams"]["tag"]),
                                                  tag_url=link, count=change["logparams"]["count"],
                                                  comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # managetags/activate - Activating a tag
@@ -1153,9 +1153,9 @@ def compact_managetags_delete(ctx, change):
 
 @formatter.embed(event="managetags/activate", mode="embed")
 def embed_managetags_activate(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Activated the tag \"{tag}\"").format(tag=sanitize_to_markdown(change["logparams"]["tag"]))
     return embed
 
@@ -1163,7 +1163,7 @@ def embed_managetags_activate(ctx, change):
 @formatter.compact(event="managetags/activate")
 def compact_managetags_activate(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) activated the [tag]({tag_url}) \"{tag}\"{comment}").format(author=author,
                                                                                                      author_url=author_url,
@@ -1173,7 +1173,7 @@ def compact_managetags_activate(ctx, change):
                                                                                                              "tag"]),
                                                                                                      tag_url=link,
                                                                                                      comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # managetags/deactivate - Deactivating a tag
@@ -1181,9 +1181,9 @@ def compact_managetags_activate(ctx, change):
 
 @formatter.embed(event="managetags/deactivate", mode="embed")
 def embed_managetags_deactivate(ctx, change):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Deactivated the tag \"{tag}\"").format(tag=sanitize_to_markdown(change["logparams"]["tag"]))
     return embed
 
@@ -1191,7 +1191,7 @@ def embed_managetags_deactivate(ctx, change):
 @formatter.compact(event="managetags/deactivate")
 def compact_managetags_deactivate(ctx, change):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     parsed_comment = compact_summary(ctx)
     content = ctx._("[{author}]({author_url}) deactivated the [tag]({tag_url}) \"{tag}\"{comment}").format(author=author,
                                                                                                        author_url=author_url,
@@ -1201,4 +1201,4 @@ def compact_managetags_deactivate(ctx, change):
                                                                                                                "tag"]),
                                                                                                        tag_url=link,
                                                                                                        comment=parsed_comment)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/renameuser.py b/extensions/base/renameuser.py
index 0a640d7..54c9556 100644
--- a/extensions/base/renameuser.py
+++ b/extensions/base/renameuser.py
@@ -18,7 +18,7 @@ import logging
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, compact_summary, clean_link, compact_author, create_article_path, sanitize_to_markdown, sanitize_to_url
+from src.api.util import embed_helper, compact_summary, clean_link, compact_author, sanitize_to_markdown, sanitize_to_url
 
 # Renameuser - https://www.mediawiki.org/wiki/Extension:Renameuser
 # renameuser/renameuser - Renaming a user
@@ -26,7 +26,7 @@ from src.api.util import embed_helper, compact_summary, clean_link, compact_auth
 
 @formatter.embed(event="renameuser/renameuser")
 def embed_renameuser_renameuser(ctx: Context, change: dict) -> DiscordMessage:
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
     edits = change["logparams"]["edits"]
     if edits > 0:
@@ -38,14 +38,14 @@ def embed_renameuser_renameuser(ctx: Context, change: dict) -> DiscordMessage:
         embed["title"] = ctx._("Renamed user \"{old_name}\" to \"{new_name}\"").format(
             old_name=sanitize_to_markdown(change["logparams"]["olduser"]),
             new_name=sanitize_to_markdown(change["logparams"]["newuser"]))
-    embed["url"] = create_article_path("User:" + sanitize_to_url(change["logparams"]["newuser"]))
+    embed["url"] = ctx.client.create_article_path("User:" + sanitize_to_url(change["logparams"]["newuser"]))
     return embed
 
 
 @formatter.compact(event="renameuser/renameuser")
 def compact_renameuser_renameuser(ctx: Context, change: dict) -> DiscordMessage:
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path("User:" + sanitize_to_url(change["logparams"]["newuser"])))
+    link = clean_link(ctx.client.create_article_path("User:" + sanitize_to_url(change["logparams"]["newuser"])))
     edits = change["logparams"]["edits"]
     parsed_comment = compact_summary(ctx)
     if edits > 0:
@@ -62,4 +62,4 @@ def compact_renameuser_renameuser(ctx: Context, change: dict) -> DiscordMessage:
             author=author, author_url=author_url, old_name=sanitize_to_markdown(change["logparams"]["olduser"]),
             new_name=sanitize_to_markdown(change["logparams"]["newuser"]), link=link, comment=parsed_comment
         )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/sprite.py b/extensions/base/sprite.py
index e241b5e..7cb44f9 100644
--- a/extensions/base/sprite.py
+++ b/extensions/base/sprite.py
@@ -17,8 +17,7 @@ import logging
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, compact_author, create_article_path, sanitize_to_markdown, sanitize_to_url, \
-    clean_link
+from src.api.util import embed_helper, compact_author, sanitize_to_markdown, sanitize_to_url, clean_link
 
 
 # SpriteSheet - https://www.mediawiki.org/wiki/Extension:SpriteSheet
@@ -27,9 +26,9 @@ from src.api.util import embed_helper, compact_author, create_article_path, sani
 
 @formatter.embed(event="sprite/sprite")
 def embed_sprite_sprite(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Edited the sprite for {article}").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -37,22 +36,22 @@ def embed_sprite_sprite(ctx: Context, change: dict):
 @formatter.compact(event="sprite/sprite")
 def compact_sprite_sprite(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._("[{author}]({author_url}) edited the sprite for [{article}]({article_url})").format(author=author,
                                                                                                     author_url=author_url,
                                                                                                     article=sanitize_to_markdown(change[
                                                                                                         "title"]),
                                                                                                     article_url=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # sprite/sheet - Creating a sprite sheet
 
 
 @formatter.embed(event="sprite/sheet")
 def embed_sprite_sheet(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Created the sprite sheet for {article}").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -60,28 +59,28 @@ def embed_sprite_sheet(ctx: Context, change: dict):
 @formatter.compact(event="sprite/sheet")
 def compact_sprite_sheet(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._("[{author}]({author_url}) created the sprite sheet for [{article}]({article_url})").format(author=author, author_url=author_url, article=sanitize_to_markdown(change["title"]), article_url=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # sprite/slice - Editing a slice
 
 
 @formatter.embed(event="sprite/slice")
 def embed_sprite_slice(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Edited the slice for {article}").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
 @formatter.compact(event="sprite/slice")
 def compact_sprite_slice(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._("[{author}]({author_url}) edited the slice for [{article}]({article_url})").format(author=author,
                                                                                                    author_url=author_url,
                                                                                                    article=sanitize_to_markdown(change[
                                                                                                        "title"]),
                                                                                                    article_url=link)
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/base/translate.py b/extensions/base/translate.py
index aba2652..15b824d 100644
--- a/extensions/base/translate.py
+++ b/extensions/base/translate.py
@@ -17,8 +17,7 @@ import logging
 from src.discord.message import DiscordMessage
 from src.api import formatter
 from src.api.context import Context
-from src.api.util import embed_helper, compact_author, create_article_path, sanitize_to_markdown, sanitize_to_url, \
-    clean_link, compact_summary
+from src.api.util import embed_helper, compact_author, sanitize_to_markdown, sanitize_to_url, clean_link, compact_summary
 
 # I cried when I realized I have to migrate Translate extension logs, but this way I atone for my countless sins
 # Translate - https://www.mediawiki.org/wiki/Extension:Translate
@@ -27,9 +26,9 @@ from src.api.util import embed_helper, compact_author, create_article_path, sani
 
 @formatter.embed(event="pagetranslation/mark")
 def embed_pagetranslation_mark(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    link = create_article_path(sanitize_to_url(change["title"]))
+    link = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     if "?" in link:
         embed["url"] = link + "&oldid={}".format(change["logparams"]["revision"])
     else:
@@ -41,7 +40,7 @@ def embed_pagetranslation_mark(ctx: Context, change: dict):
 @formatter.compact(event="pagetranslation/mark")
 def compact_pagetranslation_mark(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
-    link = create_article_path(sanitize_to_url(change["title"]))
+    link = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     if "?" in link:
         link = link + "&oldid={}".format(change["logparams"]["revision"])
     else:
@@ -53,16 +52,16 @@ def compact_pagetranslation_mark(ctx: Context, change: dict):
         article=sanitize_to_markdown(change["title"]), article_url=link,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/unmark - Removing a page from translation system
 
 
 @formatter.embed(event="pagetranslation/unmark")
 def embed_pagetranslation_unmark(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Removed \"{article}\" from the translation system").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -71,23 +70,23 @@ def embed_pagetranslation_unmark(ctx: Context, change: dict):
 def compact_pagetranslation_unmark(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._(
         "[{author}]({author_url}) removed [{article}]({article_url}) from the translation system{comment}").format(
         author=author, author_url=author_url,
         article=sanitize_to_markdown(change["title"]), article_url=link,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/moveok - Completed moving translation page
 
 
 @formatter.embed(event="pagetranslation/moveok")
 def embed_pagetranslation_moveok(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["logparams"]["target"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["logparams"]["target"]))
     embed["title"] = ctx._("Completed moving translation pages from \"{article}\" to \"{target}\"").format(
         article=sanitize_to_markdown(change["title"]), target=sanitize_to_markdown(change["logparams"]["target"]))
     return embed
@@ -97,23 +96,23 @@ def embed_pagetranslation_moveok(ctx: Context, change: dict):
 def compact_pagetranslation_moveok(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["logparams"]["target"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]["target"])))
     content = ctx._(
         "[{author}]({author_url}) completed moving translation pages from *{article}* to [{target}]({target_url}){comment}").format(
         author=author, author_url=author_url,
         article=sanitize_to_markdown(change["title"]), target=sanitize_to_markdown(change["logparams"]["target"]),
         target_url=link, comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/movenok - Failed while moving translation page
 
 
 @formatter.embed(event="pagetranslation/movenok")
 def embed_pagetranslation_movenok(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Encountered a problem while moving \"{article}\" to \"{target}\"").format(
         article=sanitize_to_markdown(change["title"]), target=sanitize_to_markdown(change["logparams"]["target"]))
     return embed
@@ -123,8 +122,8 @@ def embed_pagetranslation_movenok(ctx: Context, change: dict):
 def compact_pagetranslation_movenok(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
-    target_url = clean_link(create_article_path(sanitize_to_url(change["logparams"]["target"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
+    target_url = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]["target"])))
     content = ctx._(
         "[{author}]({author_url}) encountered a problem while moving [{article}]({article_url}) to [{target}]({target_url}){comment}").format(
         author=author, author_url=author_url,
@@ -132,16 +131,16 @@ def compact_pagetranslation_movenok(ctx: Context, change: dict):
         target=sanitize_to_markdown(change["logparams"]["target"]), target_url=target_url,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/deletefnok - Failure in deletion of translatable page
 
 
 @formatter.embed(event="pagetranslation/deletefnok")
 def embed_pagetranslation_deletefnok(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Failed to delete \"{article}\" which belongs to translatable page \"{target}\"").format(
         article=sanitize_to_markdown(change["title"]), target=sanitize_to_markdown(change["logparams"]["target"]))
     return embed
@@ -151,8 +150,8 @@ def embed_pagetranslation_deletefnok(ctx: Context, change: dict):
 def compact_pagetranslation_deletefnok(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
-    target_url = clean_link(create_article_path(sanitize_to_url(change["logparams"]["target"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
+    target_url = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]["target"])))
     content = ctx._(
         "[{author}]({author_url}) failed to delete [{article}]({article_url}) which belongs to translatable page [{target}]({target_url}){comment}").format(
         author=author, author_url=author_url,
@@ -160,16 +159,16 @@ def compact_pagetranslation_deletefnok(ctx: Context, change: dict):
         target=sanitize_to_markdown(change["logparams"]["target"]), target_url=target_url,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/deletelok - Completion in deleting a page?
 
 
 @formatter.embed(event="pagetranslation/deletelok")
 def embed_pagetranslation_deletelok(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Completed deletion of translation page \"{article}\"").format(
         article=sanitize_to_markdown(change["title"]))
     return embed
@@ -179,23 +178,23 @@ def embed_pagetranslation_deletelok(ctx: Context, change: dict):
 def compact_pagetranslation_deletelok(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._(
         "[{author}]({author_url}) completed deletion of translation page [{article}]({article_url}){comment}").format(
         author=author, author_url=author_url,
         article=sanitize_to_markdown(change["title"]), article_url=link,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/deletelnok - Failure in deletion of article belonging to a translation page
 
 
 @formatter.embed(event="pagetranslation/deletelnok")
 def embed_pagetranslation_deletelnok(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Failed to delete \"{article}\" which belongs to translation page \"{target}\"").format(
         article=sanitize_to_markdown(change["title"]), target=sanitize_to_markdown(change["logparams"]["target"]))
     return embed
@@ -205,8 +204,8 @@ def embed_pagetranslation_deletelnok(ctx: Context, change: dict):
 def compact_pagetranslation_deletelnok(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
-    target_url = clean_link(create_article_path(sanitize_to_url(change["logparams"]["target"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
+    target_url = clean_link(ctx.client.create_article_path(sanitize_to_url(change["logparams"]["target"])))
     content = ctx._(
         "[{author}]({author_url}) failed to delete [{article}]({article_url}) which belongs to translation page [{target}]({target_url}){comment}").format(
         author=author, author_url=author_url,
@@ -214,16 +213,16 @@ def compact_pagetranslation_deletelnok(ctx: Context, change: dict):
         target=sanitize_to_markdown(change["logparams"]["target"]), target_url=target_url,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/encourage - Encouraging to translate an article
 
 
 @formatter.embed(event="pagetranslation/encourage")
 def embed_pagetranslation_encourage(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Encouraged translation of \"{article}\"").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -232,22 +231,22 @@ def embed_pagetranslation_encourage(ctx: Context, change: dict):
 def compact_pagetranslation_encourage(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._("[{author}]({author_url}) encouraged translation of [{article}]({article_url}){comment}").format(
         author=author, author_url=author_url,
         article=sanitize_to_markdown(change["title"]), article_url=link,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/discourage - Discouraging to translate an article
 
 
 @formatter.embed(event="pagetranslation/discourage")
 def embed_pagetranslation_discourage(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Discouraged translation of \"{article}\"").format(article=sanitize_to_markdown(change["title"]))
     return embed
 
@@ -256,22 +255,22 @@ def embed_pagetranslation_discourage(ctx: Context, change: dict):
 def compact_pagetranslation_discourage(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._("[{author}]({author_url}) discouraged translation of [{article}]({article_url}){comment}").format(
         author=author, author_url=author_url,
         article=sanitize_to_markdown(change["title"]), article_url=link,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/prioritylanguages - Changing the priority of translations?
 
 
 @formatter.embed(event="pagetranslation/prioritylanguages")
 def embed_pagetranslation_prioritylanguages(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     if "languages" in change["logparams"]:
         languages = "`, `".join(change["logparams"]["languages"].split(","))
         if change["logparams"]["force"] == "on":
@@ -289,7 +288,7 @@ def embed_pagetranslation_prioritylanguages(ctx: Context, change: dict):
 def compact_pagetranslation_prioritylanguages(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     if "languages" in change["logparams"]:
         languages = "`, `".join(change["logparams"]["languages"].split(","))
         if change["logparams"]["force"] == "on":
@@ -313,7 +312,7 @@ def compact_pagetranslation_prioritylanguages(ctx: Context, change: dict):
             article=sanitize_to_markdown(change["title"]), article_url=link,
             comment=parsed_comment
         )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 
 # pagetranslation/associate - Adding an article to translation group
@@ -321,9 +320,9 @@ def compact_pagetranslation_prioritylanguages(ctx: Context, change: dict):
 
 @formatter.embed(event="pagetranslation/associate")
 def embed_pagetranslation_associate(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Added translatable page \"{article}\" to aggregate group \"{group}\"").format(
         article=sanitize_to_markdown(change["title"]), group=change["logparams"]["aggregategroup"])
     return embed
@@ -333,23 +332,23 @@ def embed_pagetranslation_associate(ctx: Context, change: dict):
 def compact_pagetranslation_associate(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._(
         "[{author}]({author_url}) added translatable page [{article}]({article_url}) to aggregate group \"{group}\"{comment}").format(
         author=author, author_url=author_url,
         article=sanitize_to_markdown(change["title"]), article_url=link,
         group=change["logparams"]["aggregategroup"], comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagetranslation/dissociate - Removing an article from translation group
 
 
 @formatter.embed(event="pagetranslation/dissociate")
 def embed_pagetranslation_dissociate(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Removed translatable page \"{article}\" from aggregate group \"{group}\"").format(
         article=sanitize_to_markdown(change["title"]), group=change["logparams"]["aggregategroup"])
     return embed
@@ -359,23 +358,23 @@ def embed_pagetranslation_dissociate(ctx: Context, change: dict):
 def compact_pagetranslation_dissociate(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     content = ctx._(
         "[{author}]({author_url}) removed translatable page [{article}]({article_url}) from aggregate group \"{group}\"{comment}").format(
         author=author, author_url=author_url,
         article=sanitize_to_markdown(change["title"]), article_url=link,
         group=change["logparams"]["aggregategroup"], comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # translationreview/message - Reviewing translation
 
 
 @formatter.embed(event="translationreview/message")
 def embed_translationreview_message(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    link = create_article_path(sanitize_to_url(change["title"]))
+    link = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     if "?" in link:
         embed["url"] = link + "&oldid={}".format(change["logparams"]["revision"])
     else:
@@ -388,7 +387,7 @@ def embed_translationreview_message(ctx: Context, change: dict):
 def compact_translationreview_message(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = create_article_path(sanitize_to_url(change["title"]))
+    link = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     if "?" in link:
         link = link + "&oldid={}".format(change["logparams"]["revision"])
     else:
@@ -399,16 +398,16 @@ def compact_translationreview_message(ctx: Context, change: dict):
         article=sanitize_to_markdown(change["title"]), article_url=link,
         comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # translationreview/group - Changing of state for group translation?
 
 
 @formatter.embed(event="translationreview/group")
 def embed_translationreview_group(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     embed["title"] = ctx._("Changed the state of `{language}` translations of \"{article}\"").format(
         language=change["logparams"]["language"], article=sanitize_to_markdown(change["title"]))
     if "old-state" in change["logparams"]:
@@ -421,7 +420,7 @@ def embed_translationreview_group(ctx: Context, change: dict):
 def compact_translationreview_group(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     if "old-state" in change["logparams"]:
         content = ctx._(
             "[{author}]({author_url}) changed the state of `{language}` translations of [{article}]({article_url}) from `{old_state}` to `{new_state}`{comment}").format(
@@ -437,7 +436,7 @@ def compact_translationreview_group(ctx: Context, change: dict):
             article=sanitize_to_markdown(change["logparams"]["group-label"]), article_url=link,
             new_state=change["logparams"]["new-state"], comment=parsed_comment
         )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
 
 # pagelang/pagelang - Changing the language of a page
 
@@ -453,9 +452,9 @@ def get_languages(change: dict, ctx: Context):
 
 @formatter.embed(event="pagelang/pagelang")
 def embed_pagelang_pagelang(ctx: Context, change: dict):
-    embed = DiscordMessage(ctx.message_type, ctx.event)
+    embed = DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url)
     embed_helper(ctx, embed, change)
-    embed["url"] = create_article_path(sanitize_to_url(change["title"]))
+    embed["url"] = ctx.client.create_article_path(sanitize_to_url(change["title"]))
     old_lang, new_lang = get_languages(change, ctx)
     embed["title"] = ctx._("Changed the language of \"{article}\"").format(article=sanitize_to_markdown(change["title"]))
     embed.add_field(ctx._("Old language"), old_lang, inline=True)
@@ -467,7 +466,7 @@ def embed_pagelang_pagelang(ctx: Context, change: dict):
 def compact_pagelang_pagelang(ctx: Context, change: dict):
     author, author_url = compact_author(ctx, change)
     parsed_comment = compact_summary(ctx)
-    link = clean_link(create_article_path(sanitize_to_url(change["title"])))
+    link = clean_link(ctx.client.create_article_path(sanitize_to_url(change["title"])))
     old_lang, new_lang = get_languages(change, ctx)
     content = ctx._(
         "[{author}]({author_url}) changed the language of [{article}]({article_url}) from {old_lang} to {new_lang}{comment}").format(
@@ -475,4 +474,4 @@ def compact_pagelang_pagelang(ctx: Context, change: dict):
         article=sanitize_to_markdown(change["title"]), article_url=link,
         old_lang=old_lang, new_lang=new_lang, comment=parsed_comment
     )
-    return DiscordMessage(ctx.message_type, ctx.event, content=content)
+    return DiscordMessage(ctx.message_type, ctx.event, ctx.webhook_url, content=content)
diff --git a/extensions/hooks/__init__.py b/extensions/hooks/__init__.py
index e4d9ae0..727931b 100644
--- a/extensions/hooks/__init__.py
+++ b/extensions/hooks/__init__.py
@@ -13,3 +13,6 @@
 #  You should have received a copy of the GNU General Public License
 #  along with RcGcDw.  If not, see <http://www.gnu.org/licenses/>.
 
+#import extensions.hooks.example_hook
+#import extensions.hooks.usertalk
+#import extensions.hooks.edit_alerts
diff --git a/src/api/client.py b/src/api/client.py
index 35f313a..a0bae05 100644
--- a/src/api/client.py
+++ b/src/api/client.py
@@ -18,7 +18,7 @@ from __future__ import annotations
 from datetime import datetime
 import src.misc
 import sched
-from typing import Union, Callable
+from typing import Union, Callable, Any
 from collections import OrderedDict
 from typing import TYPE_CHECKING, Optional
 
@@ -43,7 +43,7 @@ class Client:
 		self.scheduler: sched.scheduler = sched.scheduler()
 		#self.make_api_request: src.rc.wiki.__recent_changes.api_request = self.__recent_changes.api_request
 
-	def schedule(self, function: Callable, *args: list, every: Optional[float] = None, at: Optional[str] = None,
+	def schedule(self, function: Callable, *args: Any, every: Optional[float] = None, at: Optional[str] = None,
 				 priority: int = 5, **kwargs: dict):
 		"""Schedules a function indefinitely, does not execute function immediately
 
@@ -79,6 +79,10 @@ class Client:
 		"""Refreshes internal storage data for wiki tags and MediaWiki messages."""
 		self.__recent_changes.init_info()
 
+	def create_article_path(self, article: str) -> str:
+		"""Takes the string and creates an URL with it as the article name"""
+		return self.WIKI_ARTICLE_PATH.replace("$1", article)
+
 	@property
 	def namespaces(self) -> dict:
 		"""Return a dict of namespaces, if None return empty dict"""
diff --git a/src/api/context.py b/src/api/context.py
index f50654f..9d98c8e 100644
--- a/src/api/context.py
+++ b/src/api/context.py
@@ -26,7 +26,7 @@ class Context:
 	they are mainly used as a bridge between part that fetches the changes and API's formatters"""
 	def __init__(self, message_type: str, feed_type: str, webhook_urls: list[str], client: Client, language: gettext.GNUTranslations, settings: dict):
 		self.client = client
-		self.webhook_urls = webhook_urls
+		self.webhook_url = webhook_urls
 		self.message_type = message_type
 		self.feed_type = feed_type
 		self.categories = None
@@ -50,4 +50,4 @@ class Context:
 		self.comment_page = page
 
 	def __str__(self):
-		return f"<Context message_type={self.message_type} feed_type={self.feed_type} event={self.event} webhook_urls={self.webhook_urls}"
+		return f"<Context message_type={self.message_type} feed_type={self.feed_type} event={self.event} webhook_urls={self.webhook_url}"
diff --git a/src/api/formatter.py b/src/api/formatter.py
index b13dfec..735a55a 100644
--- a/src/api/formatter.py
+++ b/src/api/formatter.py
@@ -14,7 +14,6 @@
 # along with RcGcDw.  If not, see <http://www.gnu.org/licenses/>.
 import src.api.hooks
 import logging
-from src.configloader import settings
 from src.exceptions import FormatterBreaksAPISpec
 from src.discord.message import DiscordMessage
 from typing import Optional, Callable
diff --git a/src/api/util.py b/src/api/util.py
index 03d3345..731087b 100644
--- a/src/api/util.py
+++ b/src/api/util.py
@@ -19,12 +19,9 @@ from typing import Optional, Callable, TYPE_CHECKING
 
 from src.exceptions import ServerError, MediaWikiError
 from src.discord.message import DiscordMessage
-from src.configloader import settings
+from src.config import settings
 import src.misc
 import logging
-from src.i18n import formatters_i18n
-
-_ = formatters_i18n.gettext
 
 if TYPE_CHECKING:
 	from src.api.context import Context
@@ -58,24 +55,19 @@ def parse_mediawiki_changes(ctx: Context, content: str, embed: DiscordMessage) -
 	edit_diff.feed(content)
 	if edit_diff.small_prev_del:
 		if edit_diff.small_prev_del.replace("~~", "").replace("__", "").isspace():
-			edit_diff.small_prev_del = _('__Only whitespace__')
+			edit_diff.small_prev_del = ctx._('__Only whitespace__')
 		else:
 			edit_diff.small_prev_del = edit_diff.small_prev_del.replace("~~~~", "").replace("____", "")
 	if edit_diff.small_prev_ins:
 		if edit_diff.small_prev_ins.replace("**", "").replace("__", "").isspace():
-			edit_diff.small_prev_ins = _('__Only whitespace__')
+			edit_diff.small_prev_ins = ctx._('__Only whitespace__')
 		else:
 			edit_diff.small_prev_ins = edit_diff.small_prev_ins.replace("****", "").replace("____", "")
 	logger.debug("Changed content: {}".format(edit_diff.small_prev_ins))
 	if edit_diff.small_prev_del and not ctx.event == "new":
-		embed.add_field(_("Removed"), "{data}".format(data=edit_diff.small_prev_del), inline=True)
+		embed.add_field(ctx._("Removed"), "{data}".format(data=edit_diff.small_prev_del), inline=True)
 	if edit_diff.small_prev_ins:
-		embed.add_field(_("Added"), "{data}".format(data=edit_diff.small_prev_ins), inline=True)
-
-
-def create_article_path(article: str) -> str:
-	"""Takes the string and creates an URL with it as the article name"""
-	return src.misc.WIKI_ARTICLE_PATH.replace("$1", article)
+		embed.add_field(ctx._("Added"), "{data}".format(data=edit_diff.small_prev_ins), inline=True)
 
 
 def compact_summary(ctx: Context) -> str:
@@ -88,10 +80,10 @@ def compact_author(ctx: Context, change: dict) -> (Optional[str], Optional[str])
 	"""Returns link to the author and the author itself respecting the settings"""
 	author, author_url = None, None
 	if ctx.event != "suppressed":
-		author_url = clean_link(create_article_path("User:{user}".format(user=sanitize_to_url(change["user"]))))
+		author_url = clean_link(ctx.client.create_article_path("User:{user}".format(user=sanitize_to_url(change["user"]))))
 		if "anon" in change:
 			if settings.get("hide_ips", False):
-				author = _("Unregistered user")
+				author = ctx._("Unregistered user")
 			else:
 				author = change["user"]
 		else:
@@ -111,7 +103,7 @@ def embed_helper(ctx: Context, message: DiscordMessage, change: dict, set_user=T
 	if set_user:
 		author = None
 		if "anon" in change:
-			author_url = create_article_path("Special:Contributions/{user}".format(user=sanitize_to_url(change["user"])))
+			author_url = ctx.client.create_article_path("Special:Contributions/{user}".format(user=sanitize_to_url(change["user"])))
 			ip_mapper = ctx.client.get_ipmapper()
 			logger.debug("current user: {} with cache of IPs: {}".format(change["user"], ip_mapper.keys()))
 			if change["user"] not in list(ip_mapper.keys()):
@@ -123,14 +115,14 @@ def embed_helper(ctx: Context, message: DiscordMessage, change: dict, set_user=T
 				except (ServerError, MediaWikiError):
 					logger.warning("WARNING: Something went wrong when checking amount of contributions for given IP address")
 					if settings.get("hide_ips", False):
-						author = _("Unregistered user")
+						author = ctx._("Unregistered user")
 					else:
 						author = change["user"] + "(?)"
 				else:
 					ip_mapper[change["user"]] = len(contibs)
 					logger.debug("Current params user {} and state of map_ips {}".format(change["user"], ip_mapper))
 					if settings.get("hide_ips", False):
-						author = _("Unregistered user")
+						author = ctx._("Unregistered user")
 					else:
 						author = "{author} ({contribs})".format(author=change["user"], contribs=len(contibs))
 			else:
@@ -138,10 +130,10 @@ def embed_helper(ctx: Context, message: DiscordMessage, change: dict, set_user=T
 				if ctx.event in ("edit", "new"):
 					ip_mapper[change["user"]] += 1
 				author = "{author} ({amount})".format(
-					author=change["user"] if settings.get("hide_ips", False) is False else _("Unregistered user"),
+					author=change["user"] if settings.get("hide_ips", False) is False else ctx._("Unregistered user"),
 					amount=ip_mapper[change["user"]])
 		else:
-			author_url = create_article_path("User:{}".format(sanitize_to_url(change["user"])))
+			author_url = ctx.client.create_article_path("User:{}".format(sanitize_to_url(change["user"])))
 			author = change["user"]
 		message.set_author(author, author_url)
 	if set_edit_meta:
@@ -158,14 +150,14 @@ def embed_helper(ctx: Context, message: DiscordMessage, change: dict, set_user=T
 				else:
 					tag_displayname.append(tag)
 			if tag_displayname:
-				message.add_field(formatters_i18n.pgettext("recent changes Tags", "Tags"), ", ".join(tag_displayname))
+				message.add_field(ctx.pgettext("recent changes Tags", "Tags"), ", ".join(tag_displayname))
 		if ctx.categories is not None and not (len(ctx.categories["new"]) == 0 and len(ctx.categories["removed"]) == 0):
-			new_cat = (_("**Added**: ") + ", ".join(list(ctx.categories["new"])[0:16]) + (
-				"\n" if len(ctx.categories["new"]) <= 15 else _(" and {} more\n").format(
+			new_cat = (ctx._("**Added**: ") + ", ".join(list(ctx.categories["new"])[0:16]) + (
+				"\n" if len(ctx.categories["new"]) <= 15 else ctx._(" and {} more\n").format(
 					len(ctx.categories["new"]) - 15))) if ctx.categories["new"] else ""
-			del_cat = (_("**Removed**: ") + ", ".join(list(ctx.categories["removed"])[0:16]) + (
-				"" if len(ctx.categories["removed"]) <= 15 else _(" and {} more").format(
+			del_cat = (ctx._("**Removed**: ") + ", ".join(list(ctx.categories["removed"])[0:16]) + (
+				"" if len(ctx.categories["removed"]) <= 15 else ctx._(" and {} more").format(
 					len(ctx.categories["removed"]) - 15))) if ctx.categories["removed"] else ""
-			message.add_field(_("Changed categories"), new_cat + del_cat)
+			message.add_field(ctx._("Changed categories"), new_cat + del_cat)
 	if set_desc:
 		message["description"] = ctx.parsedcomment
diff --git a/src/discord/message.py b/src/discord/message.py
index 6c4d246..4283b3c 100644
--- a/src/discord/message.py
+++ b/src/discord/message.py
@@ -12,7 +12,7 @@
 
 # You should have received a copy of the GNU General Public License
 # along with RcGcDw.  If not, see <http://www.gnu.org/licenses/>.
-
+from __future__ import annotations
 import json
 import math
 import random
@@ -47,7 +47,7 @@ class DiscordMessageMetadata:
 
 class DiscordMessage:
 	"""A class defining a typical Discord JSON representation of webhook payload."""
-	def __init__(self, message_type: str, event_type: str, content=None):
+	def __init__(self, message_type: str, event_type: str, webhook_url: list[str], content=None):
 		self.webhook_object = dict(allowed_mentions={"parse": []})
 		self.length = 0
 		self.metadata: Optional[DiscordMessageMetadata] = None
diff --git a/src/discord/queue.py b/src/discord/queue.py
index fc3e3f2..2bd3012 100644
--- a/src/discord/queue.py
+++ b/src/discord/queue.py
@@ -112,7 +112,7 @@ class MessageQueue:
 			if self.compare_message_to_dict(item[1], properties):
 				self._queue.pop(index)
 
-	async def pack_massages(self, messages: list[QueueEntry], current_pack=None) -> AsyncGenerator[tuple[StackedDiscordMessage, int, str]]:
+	async def pack_massages(self, messages: list[QueueEntry], current_pack=None) -> AsyncGenerator[tuple[StackedDiscordMessage, int, str], None]:
 		"""Pack messages into StackedDiscordMessage. It's an async generator"""
 		# TODO Rebuild to support DELETE and PATCH messages
 		for index, message in enumerate(messages):
diff --git a/src/domain.py b/src/domain.py
index d141f1e..67989a6 100644
--- a/src/domain.py
+++ b/src/domain.py
@@ -5,7 +5,7 @@ from collections import OrderedDict
 from src.config import settings
 from typing import TYPE_CHECKING, Optional
 from functools import cache
-from src.discussions import Discussions
+# from src.discussions import Discussions
 from statistics import Log, LogType
 
 logger = logging.getLogger("rcgcdb.domain")
diff --git a/src/exceptions.py b/src/exceptions.py
index c093a61..2c46fb5 100644
--- a/src/exceptions.py
+++ b/src/exceptions.py
@@ -34,6 +34,11 @@ class ServerError(Exception):
 	"""Exception for when a request fails because of Server error"""
 	pass
 
+class FormatterBreaksAPISpec(Exception):
+	def __init__(self, field):
+		self.message = f"Formatter doesn't specify {field}!"
+		super().__init__(self.message)
+
 
 class ClientError(Exception):
 	"""Exception for when a request failes because of Client error"""
diff --git a/src/queue_handler.py b/src/queue_handler.py
index 54f3efa..66c7ac8 100644
--- a/src/queue_handler.py
+++ b/src/queue_handler.py
@@ -19,7 +19,7 @@ class UpdateDB:
 	def clear_list(self):
 		self.updated.clear()
 
-	async def fetch_rows(self, SQLstatement: str, args: Union[str, int]) -> collections.AsyncIterable:
+	async def fetch_rows(self, SQLstatement: str, args: Union[str, int]) -> collections.abc.AsyncIterable:
 		async with db.pool().acquire() as connection:
 			async with connection.transaction():
 				async for row in connection.cursor(SQLstatement, *args):
diff --git a/src/wiki.py b/src/wiki.py
index dddfeb7..18b4d98 100644
--- a/src/wiki.py
+++ b/src/wiki.py
@@ -28,8 +28,8 @@ from typing import Union, Optional, TYPE_CHECKING
 Settings = namedtuple("Settings", ["lang", "display"])
 logger = logging.getLogger("rcgcdb.wiki")
 
-wiki_reamoval_reasons = {410: _("wiki deleted"), 404: _("wiki deleted"), 401: _("wiki inaccessible"),
-				           402: _("wiki inaccessible"), 403: _("wiki inaccessible"), 1000: _("discussions disabled")}
+# wiki_reamoval_reasons = {410: _("wiki deleted"), 404: _("wiki deleted"), 401: _("wiki inaccessible"),
+# 				           402: _("wiki inaccessible"), 403: _("wiki inaccessible"), 1000: _("discussions disabled")}
 
 if TYPE_CHECKING:
 	from src.domain import Domain
@@ -215,8 +215,7 @@ class Wiki:
 					request.url))
 		elif 399 < request.status < 500:
 			logger.error("Request returned ClientError status code on {url}".format(url=request.url))
-			if request.status in wiki_reamoval_reasons:
-				self.statistics.update(Log(type=LogType.HTTP_ERROR, title="{} error".format(request.status), details=str(request.headers) + "\n" + str(request.url)))
+			self.statistics.update(Log(type=LogType.HTTP_ERROR, title="{} error".format(request.status), details=str(request.headers) + "\n" + str(request.url)))
 			raise ClientError(request)
 		else:
 			# JSON Extraction