diff --git a/bgpd/bgp_nht.c b/bgpd/bgp_nht.c
index 60d6f74e1478..9a2166c86bd6 100644
--- a/bgpd/bgp_nht.c
+++ b/bgpd/bgp_nht.c
@@ -897,52 +897,44 @@ void bgp_nht_interface_events(struct peer *peer)
 				bnc->ifindex_ipv6_ll, NULL);
 }
 
-void bgp_parse_nexthop_update(int command, vrf_id_t vrf_id)
+void bgp_nexthop_update(struct vrf *vrf, struct prefix *match,
+			struct zapi_route *nhr)
 {
 	struct bgp_nexthop_cache_head *tree = NULL;
 	struct bgp_nexthop_cache *bnc_nhc, *bnc_import;
 	struct bgp *bgp;
-	struct prefix match;
-	struct zapi_route nhr;
 	afi_t afi;
 
-	bgp = bgp_lookup_by_vrf_id(vrf_id);
-	if (!bgp) {
-		flog_err(
-			EC_BGP_NH_UPD,
-			"parse nexthop update: instance not found for vrf_id %u",
-			vrf_id);
+	if (!vrf->info) {
+		flog_err(EC_BGP_NH_UPD,
+			 "parse nexthop update: instance not found for vrf_id %u",
+			 vrf->vrf_id);
 		return;
 	}
 
-	if (!zapi_nexthop_update_decode(zclient->ibuf, &match, &nhr)) {
-		zlog_err("%s[%s]: Failure to decode nexthop update", __func__,
-			 bgp->name_pretty);
-		return;
-	}
-
-	afi = family2afi(match.family);
+	bgp = (struct bgp *)vrf->info;
+	afi = family2afi(match->family);
 	tree = &bgp->nexthop_cache_table[afi];
 
-	bnc_nhc = bnc_find(tree, &match, nhr.srte_color, 0);
+	bnc_nhc = bnc_find(tree, match, nhr->srte_color, 0);
 	if (!bnc_nhc) {
 		if (BGP_DEBUG(nht, NHT))
-			zlog_debug(
-				"parse nexthop update %pFX(%u)(%s): bnc info not found for nexthop cache",
-				&nhr.prefix, nhr.srte_color, bgp->name_pretty);
+			zlog_debug("parse nexthop update %pFX(%u)(%s): bnc info not found for nexthop cache",
+				   &nhr->prefix, nhr->srte_color,
+				   bgp->name_pretty);
 	} else
-		bgp_process_nexthop_update(bnc_nhc, &nhr, false);
+		bgp_process_nexthop_update(bnc_nhc, nhr, false);
 
 	tree = &bgp->import_check_table[afi];
 
-	bnc_import = bnc_find(tree, &match, nhr.srte_color, 0);
+	bnc_import = bnc_find(tree, match, nhr->srte_color, 0);
 	if (!bnc_import) {
 		if (BGP_DEBUG(nht, NHT))
-			zlog_debug(
-				"parse nexthop update %pFX(%u)(%s): bnc info not found for import check",
-				&nhr.prefix, nhr.srte_color, bgp->name_pretty);
+			zlog_debug("parse nexthop update %pFX(%u)(%s): bnc info not found for import check",
+				   &nhr->prefix, nhr->srte_color,
+				   bgp->name_pretty);
 	} else
-		bgp_process_nexthop_update(bnc_import, &nhr, true);
+		bgp_process_nexthop_update(bnc_import, nhr, true);
 
 	/*
 	 * HACK: if any BGP route is dependant on an SR-policy that doesn't
@@ -955,7 +947,7 @@ void bgp_parse_nexthop_update(int command, vrf_id_t vrf_id)
 	 * which should provide a better infrastructure to solve this issue in
 	 * a more efficient and elegant way.
 	 */
-	if (nhr.srte_color == 0 && bnc_nhc) {
+	if (nhr->srte_color == 0 && bnc_nhc) {
 		struct bgp_nexthop_cache *bnc_iter;
 
 		frr_each (bgp_nexthop_cache, &bgp->nexthop_cache_table[afi],
@@ -965,7 +957,7 @@ void bgp_parse_nexthop_update(int command, vrf_id_t vrf_id)
 			    CHECK_FLAG(bnc_iter->flags, BGP_NEXTHOP_VALID))
 				continue;
 
-			bgp_process_nexthop_update(bnc_iter, &nhr, false);
+			bgp_process_nexthop_update(bnc_iter, nhr, false);
 		}
 	}
 }
diff --git a/bgpd/bgp_nht.h b/bgpd/bgp_nht.h
index 0758a0cf08fc..b9f0f6d46945 100644
--- a/bgpd/bgp_nht.h
+++ b/bgpd/bgp_nht.h
@@ -7,9 +7,10 @@
 #define _BGP_NHT_H
 
 /**
- * bgp_parse_nexthop_update() - parse a nexthop update message from Zebra.
+ * bgp_nexthop_update() - process a nexthop update message from Zebra.
  */
-extern void bgp_parse_nexthop_update(int command, vrf_id_t vrf_id);
+extern void bgp_nexthop_update(struct vrf *vrf, struct prefix *match,
+			       struct zapi_route *nhr);
 
 /**
  * bgp_find_or_add_nexthop() - lookup the nexthop cache table for the bnc
diff --git a/bgpd/bgp_zebra.c b/bgpd/bgp_zebra.c
index 2596c71c16ea..8dad72420b06 100644
--- a/bgpd/bgp_zebra.c
+++ b/bgpd/bgp_zebra.c
@@ -100,13 +100,6 @@ static int bgp_router_id_update(ZAPI_CALLBACK_ARGS)
 	return 0;
 }
 
-/* Nexthop update message from zebra. */
-static int bgp_read_nexthop_update(ZAPI_CALLBACK_ARGS)
-{
-	bgp_parse_nexthop_update(cmd, vrf_id);
-	return 0;
-}
-
 /* Set or clear interface on which unnumbered neighbor is configured. This
  * would in turn cause BGP to initiate or turn off IPv6 RAs on this
  * interface.
@@ -3332,7 +3325,6 @@ static zclient_handler *const bgp_handlers[] = {
 	[ZEBRA_INTERFACE_NBR_ADDRESS_DELETE] = bgp_interface_nbr_address_delete,
 	[ZEBRA_REDISTRIBUTE_ROUTE_ADD] = zebra_read_route,
 	[ZEBRA_REDISTRIBUTE_ROUTE_DEL] = zebra_read_route,
-	[ZEBRA_NEXTHOP_UPDATE] = bgp_read_nexthop_update,
 	[ZEBRA_FEC_UPDATE] = bgp_read_fec_update,
 	[ZEBRA_LOCAL_ES_ADD] = bgp_zebra_process_local_es_add,
 	[ZEBRA_LOCAL_ES_DEL] = bgp_zebra_process_local_es_del,
@@ -3454,6 +3446,7 @@ void bgp_zebra_init(struct event_loop *master, unsigned short instance)
 	zclient_init(zclient, ZEBRA_ROUTE_BGP, 0, &bgpd_privs);
 	zclient->zebra_connected = bgp_zebra_connected;
 	zclient->zebra_capabilities = bgp_zebra_capabilities;
+	zclient->nexthop_update = bgp_nexthop_update;
 	zclient->instance = instance;
 
 	/* Initialize special zclient for synchronous message exchanges. */
diff --git a/lib/zclient.c b/lib/zclient.c
index 47d6c5fbaf8d..a52d092e3b2c 100644
--- a/lib/zclient.c
+++ b/lib/zclient.c
@@ -2269,8 +2269,8 @@ const char *zapi_nexthop2str(const struct zapi_nexthop *znh, char *buf,
 /*
  * Decode the nexthop-tracking update message
  */
-bool zapi_nexthop_update_decode(struct stream *s, struct prefix *match,
-				struct zapi_route *nhr)
+static bool zapi_nexthop_update_decode(struct stream *s, struct prefix *match,
+				       struct zapi_route *nhr)
 {
 	uint32_t i;
 
@@ -4298,6 +4298,28 @@ int zapi_client_close_notify_decode(struct stream *s,
 	return -1;
 }
 
+static int zclient_nexthop_update(ZAPI_CALLBACK_ARGS)
+{
+	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
+	struct prefix match;
+	struct zapi_route route;
+
+	if (!vrf) {
+		zlog_warn("nexthop update for unknown VRF ID %u", vrf_id);
+		return 0;
+	}
+
+	if (!zapi_nexthop_update_decode(zclient->ibuf, &match, &route)) {
+		zlog_err("failed to decode nexthop update");
+		return -1;
+	}
+
+	if (zclient->nexthop_update)
+		zclient->nexthop_update(vrf, &match, &route);
+
+	return 0;
+}
+
 static zclient_handler *const lib_handlers[] = {
 	/* fundamentals */
 	[ZEBRA_CAPABILITIES] = zclient_capability_decode,
@@ -4311,6 +4333,9 @@ static zclient_handler *const lib_handlers[] = {
 	[ZEBRA_INTERFACE_UP] = zclient_interface_up,
 	[ZEBRA_INTERFACE_DOWN] = zclient_interface_down,
 
+	/* NHT pre-decode */
+	[ZEBRA_NEXTHOP_UPDATE] = zclient_nexthop_update,
+
 	/* BFD */
 	[ZEBRA_BFD_DEST_REPLAY] = zclient_bfd_session_replay,
 	[ZEBRA_INTERFACE_BFD_DEST_UPDATE] = zclient_bfd_session_update,
diff --git a/lib/zclient.h b/lib/zclient.h
index f18fc056fce3..73eb6a16d88c 100644
--- a/lib/zclient.h
+++ b/lib/zclient.h
@@ -293,6 +293,8 @@ struct zapi_cap {
 typedef int (zclient_handler)(ZAPI_CALLBACK_ARGS);
 /* clang-format on */
 
+struct zapi_route;
+
 /* Structure for the zebra client. */
 struct zclient {
 	/* The thread master we schedule ourselves on */
@@ -348,6 +350,19 @@ struct zclient {
 	void (*zebra_connected)(struct zclient *);
 	void (*zebra_capabilities)(struct zclient_capabilities *cap);
 
+	/*
+	 * match -> is the prefix that the calling daemon asked to be matched
+	 * against.
+	 * nhr->prefix -> is the actual prefix that was matched against in the
+	 * rib itself.
+	 *
+	 * This distinction is made because a LPM can be made if there is a
+	 * covering route.  This way the upper level protocol can make a
+	 * decision point about whether or not it wants to use the match or not.
+	 */
+	void (*nexthop_update)(struct vrf *vrf, struct prefix *match,
+			       struct zapi_route *nhr);
+
 	int (*handle_error)(enum zebra_error_types error);
 
 	/*
@@ -1123,18 +1138,6 @@ int zapi_nexthop_from_nexthop(struct zapi_nexthop *znh,
 			      const struct nexthop *nh);
 int zapi_backup_nexthop_from_nexthop(struct zapi_nexthop *znh,
 				     const struct nexthop *nh);
-/*
- * match -> is the prefix that the calling daemon asked to be matched
- * against.
- * nhr->prefix -> is the actual prefix that was matched against in the
- * rib itself.
- *
- * This distinction is made because a LPM can be made if there is a
- * covering route.  This way the upper level protocol can make a decision
- * point about whether or not it wants to use the match or not.
- */
-extern bool zapi_nexthop_update_decode(struct stream *s, struct prefix *match,
-				       struct zapi_route *nhr);
 const char *zapi_nexthop2str(const struct zapi_nexthop *znh, char *buf,
 			     int bufsize);
 
diff --git a/ospf6d/ospf6_zebra.c b/ospf6d/ospf6_zebra.c
index 8bd0d8f0b58b..3245578b07f2 100644
--- a/ospf6d/ospf6_zebra.c
+++ b/ospf6d/ospf6_zebra.c
@@ -147,30 +147,22 @@ void ospf6_zebra_import_default_route(struct ospf6 *ospf6, bool unreg)
 			 __func__);
 }
 
-static int ospf6_zebra_import_check_update(ZAPI_CALLBACK_ARGS)
+static void ospf6_zebra_import_check_update(struct vrf *vrf,
+					    struct prefix *matched,
+					    struct zapi_route *nhr)
 {
 	struct ospf6 *ospf6;
-	struct zapi_route nhr;
-	struct prefix matched;
 
-	ospf6 = ospf6_lookup_by_vrf_id(vrf_id);
+	ospf6 = (struct ospf6 *)vrf->info;
 	if (ospf6 == NULL || !IS_OSPF6_ASBR(ospf6))
-		return 0;
-
-	if (!zapi_nexthop_update_decode(zclient->ibuf, &matched, &nhr)) {
-		zlog_err("%s[%u]: Failure to decode route", __func__,
-			 ospf6->vrf_id);
-		return -1;
-	}
+		return;
 
-	if (matched.family != AF_INET6 || matched.prefixlen != 0 ||
-	    nhr.type == ZEBRA_ROUTE_OSPF6)
-		return 0;
+	if (matched->family != AF_INET6 || matched->prefixlen != 0 ||
+	    nhr->type == ZEBRA_ROUTE_OSPF6)
+		return;
 
-	ospf6->nssa_default_import_check.status = !!nhr.nexthop_num;
+	ospf6->nssa_default_import_check.status = !!nhr->nexthop_num;
 	ospf6_abr_nssa_type_7_defaults(ospf6);
-
-	return 0;
 }
 
 static int ospf6_zebra_if_address_update_add(ZAPI_CALLBACK_ARGS)
@@ -763,7 +755,6 @@ static zclient_handler *const ospf6_handlers[] = {
 	[ZEBRA_INTERFACE_ADDRESS_DELETE] = ospf6_zebra_if_address_update_delete,
 	[ZEBRA_REDISTRIBUTE_ROUTE_ADD] = ospf6_zebra_read_route,
 	[ZEBRA_REDISTRIBUTE_ROUTE_DEL] = ospf6_zebra_read_route,
-	[ZEBRA_NEXTHOP_UPDATE] = ospf6_zebra_import_check_update,
 };
 
 void ospf6_zebra_init(struct event_loop *master)
@@ -773,6 +764,7 @@ void ospf6_zebra_init(struct event_loop *master)
 			      array_size(ospf6_handlers));
 	zclient_init(zclient, ZEBRA_ROUTE_OSPF6, 0, &ospf6d_privs);
 	zclient->zebra_connected = ospf6_zebra_connected;
+	zclient->nexthop_update = ospf6_zebra_import_check_update;
 
 	/* Install command element for zebra node. */
 	install_element(VIEW_NODE, &show_ospf6_zebra_cmd);
diff --git a/ospfd/ospf_zebra.c b/ospfd/ospf_zebra.c
index 1af703d88d6d..19d3c9a08306 100644
--- a/ospfd/ospf_zebra.c
+++ b/ospfd/ospf_zebra.c
@@ -1487,30 +1487,20 @@ void ospf_zebra_import_default_route(struct ospf *ospf, bool unreg)
 			 __func__);
 }
 
-static int ospf_zebra_import_check_update(ZAPI_CALLBACK_ARGS)
+static void ospf_zebra_import_check_update(struct vrf *vrf, struct prefix *match,
+					   struct zapi_route *nhr)
 {
-	struct ospf *ospf;
-	struct zapi_route nhr;
-	struct prefix matched;
+	struct ospf *ospf = vrf->info;
 
-	ospf = ospf_lookup_by_vrf_id(vrf_id);
 	if (ospf == NULL || !IS_OSPF_ASBR(ospf))
-		return 0;
-
-	if (!zapi_nexthop_update_decode(zclient->ibuf, &matched, &nhr)) {
-		zlog_err("%s[%u]: Failure to decode route", __func__,
-			 ospf->vrf_id);
-		return -1;
-	}
+		return;
 
-	if (matched.family != AF_INET || matched.prefixlen != 0 ||
-	    nhr.type == ZEBRA_ROUTE_OSPF)
-		return 0;
+	if (match->family != AF_INET || match->prefixlen != 0 ||
+	    nhr->type == ZEBRA_ROUTE_OSPF)
+		return;
 
-	ospf->nssa_default_import_check.status = !!nhr.nexthop_num;
+	ospf->nssa_default_import_check.status = !!nhr->nexthop_num;
 	ospf_abr_nssa_type7_defaults(ospf);
-
-	return 0;
 }
 
 int ospf_distribute_list_out_set(struct ospf *ospf, int type, const char *name)
@@ -2183,7 +2173,6 @@ static zclient_handler *const ospf_handlers[] = {
 
 	[ZEBRA_REDISTRIBUTE_ROUTE_ADD] = ospf_zebra_read_route,
 	[ZEBRA_REDISTRIBUTE_ROUTE_DEL] = ospf_zebra_read_route,
-	[ZEBRA_NEXTHOP_UPDATE] = ospf_zebra_import_check_update,
 
 	[ZEBRA_OPAQUE_MESSAGE] = ospf_opaque_msg_handler,
 
@@ -2197,6 +2186,7 @@ void ospf_zebra_init(struct event_loop *master, unsigned short instance)
 			      array_size(ospf_handlers));
 	zclient_init(zclient, ZEBRA_ROUTE_OSPF, instance, &ospfd_privs);
 	zclient->zebra_connected = ospf_zebra_connected;
+	zclient->nexthop_update = ospf_zebra_import_check_update;
 
 	/* Initialize special zclient for synchronous message exchanges. */
 	struct zclient_options options = zclient_options_default;
diff --git a/pbrd/pbr_zebra.c b/pbrd/pbr_zebra.c
index d47a308ac847..44ccbde0e101 100644
--- a/pbrd/pbr_zebra.c
+++ b/pbrd/pbr_zebra.c
@@ -364,38 +364,30 @@ void route_delete(struct pbr_nexthop_group_cache *pnhgc, afi_t afi)
 	}
 }
 
-static int pbr_zebra_nexthop_update(ZAPI_CALLBACK_ARGS)
+static void pbr_zebra_nexthop_update(struct vrf *vrf, struct prefix *matched,
+				     struct zapi_route *nhr)
 {
-	struct zapi_route nhr;
-	struct prefix matched;
 	uint32_t i;
 
-	if (!zapi_nexthop_update_decode(zclient->ibuf, &matched, &nhr)) {
-		zlog_err("Failure to decode Nexthop update message");
-		return 0;
-	}
-
 	if (DEBUG_MODE_CHECK(&pbr_dbg_zebra, DEBUG_MODE_ALL)) {
-
 		DEBUGD(&pbr_dbg_zebra,
 		       "%s: Received Nexthop update: %pFX against %pFX",
-		       __func__, &matched, &nhr.prefix);
+		       __func__, matched, &nhr->prefix);
 
 		DEBUGD(&pbr_dbg_zebra, "%s:   (Nexthops(%u)", __func__,
-		       nhr.nexthop_num);
+		       nhr->nexthop_num);
 
-		for (i = 0; i < nhr.nexthop_num; i++) {
+		for (i = 0; i < nhr->nexthop_num; i++) {
 			DEBUGD(&pbr_dbg_zebra,
 			       "%s:     Type: %d: vrf: %d, ifindex: %d gate: %pI4",
-			       __func__, nhr.nexthops[i].type,
-			       nhr.nexthops[i].vrf_id, nhr.nexthops[i].ifindex,
-			       &nhr.nexthops[i].gate.ipv4);
+			       __func__, nhr->nexthops[i].type,
+			       nhr->nexthops[i].vrf_id, nhr->nexthops[i].ifindex,
+			       &nhr->nexthops[i].gate.ipv4);
 		}
 	}
 
-	nhr.prefix = matched;
-	pbr_nht_nexthop_update(&nhr);
-	return 1;
+	nhr->prefix = *matched;
+	pbr_nht_nexthop_update(nhr);
 }
 
 extern struct zebra_privs_t pbr_privs;
@@ -405,7 +397,6 @@ static zclient_handler *const pbr_handlers[] = {
 	[ZEBRA_INTERFACE_ADDRESS_DELETE] = interface_address_delete,
 	[ZEBRA_ROUTE_NOTIFY_OWNER] = route_notify_owner,
 	[ZEBRA_RULE_NOTIFY_OWNER] = rule_notify_owner,
-	[ZEBRA_NEXTHOP_UPDATE] = pbr_zebra_nexthop_update,
 };
 
 void pbr_zebra_init(void)
@@ -417,6 +408,7 @@ void pbr_zebra_init(void)
 
 	zclient_init(zclient, ZEBRA_ROUTE_PBR, 0, &pbr_privs);
 	zclient->zebra_connected = zebra_connected;
+	zclient->nexthop_update = pbr_zebra_nexthop_update;
 }
 
 void pbr_zebra_destroy(void)
diff --git a/pimd/pim_nht.c b/pimd/pim_nht.c
index af36caec650b..32cdf4bf8289 100644
--- a/pimd/pim_nht.c
+++ b/pimd/pim_nht.c
@@ -723,7 +723,8 @@ static int pim_ecmp_nexthop_search(struct pim_instance *pim,
 
 /* This API is used to parse Registered address nexthop update coming from Zebra
  */
-int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
+void pim_nexthop_update(struct vrf *vrf, struct prefix *match,
+			struct zapi_route *nhr)
 {
 	struct nexthop *nexthop;
 	struct nexthop *nhlist_head = NULL;
@@ -732,38 +733,27 @@ int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
 	struct pim_rpf rpf;
 	struct pim_nexthop_cache *pnc = NULL;
 	struct interface *ifp = NULL;
-	struct vrf *vrf = vrf_lookup_by_id(vrf_id);
 	struct pim_instance *pim;
-	struct zapi_route nhr;
-	struct prefix match;
 
-	if (!vrf)
-		return 0;
 	pim = vrf->info;
 
-	if (!zapi_nexthop_update_decode(zclient->ibuf, &match, &nhr)) {
-		zlog_err("%s: Decode of nexthop update from zebra failed",
-			 __func__);
-		return 0;
-	}
-
-	rpf.rpf_addr = pim_addr_from_prefix(&match);
+	rpf.rpf_addr = pim_addr_from_prefix(match);
 	pnc = pim_nexthop_cache_find(pim, &rpf);
 	if (!pnc) {
 		if (PIM_DEBUG_PIM_NHT)
 			zlog_debug(
 				"%s: Skipping NHT update, addr %pPA is not in local cached DB.",
 				__func__, &rpf.rpf_addr);
-		return 0;
+		return;
 	}
 
 	pnc->last_update = pim_time_monotonic_usec();
 
-	if (nhr.nexthop_num) {
+	if (nhr->nexthop_num) {
 		pnc->nexthop_num = 0;
 
-		for (i = 0; i < nhr.nexthop_num; i++) {
-			nexthop = nexthop_from_zapi_nexthop(&nhr.nexthops[i]);
+		for (i = 0; i < nhr->nexthop_num; i++) {
+			nexthop = nexthop_from_zapi_nexthop(&nhr->nexthops[i]);
 			switch (nexthop->type) {
 			case NEXTHOP_TYPE_IFINDEX:
 				/*
@@ -842,11 +832,11 @@ int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
 #else
 				pim_addr nhaddr = nexthop->gate.ipv6;
 #endif
-				zlog_debug(
-					"%s: NHT addr %pFX(%s) %d-nhop via %pPA(%s) type %d distance:%u metric:%u ",
-					__func__, &match, pim->vrf->name, i + 1,
-					&nhaddr, ifp->name, nexthop->type,
-					nhr.distance, nhr.metric);
+				zlog_debug("%s: NHT addr %pFX(%s) %d-nhop via %pPA(%s) type %d distance:%u metric:%u ",
+					   __func__, match, pim->vrf->name,
+					   i + 1, &nhaddr, ifp->name,
+					   nexthop->type, nhr->distance,
+					   nhr->metric);
 			}
 
 			if (!ifp->info) {
@@ -887,23 +877,22 @@ int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
 		pnc->nexthop = nhlist_head;
 		if (pnc->nexthop_num) {
 			pnc->flags |= PIM_NEXTHOP_VALID;
-			pnc->distance = nhr.distance;
-			pnc->metric = nhr.metric;
+			pnc->distance = nhr->distance;
+			pnc->metric = nhr->metric;
 		}
 	} else {
 		pnc->flags &= ~PIM_NEXTHOP_VALID;
-		pnc->nexthop_num = nhr.nexthop_num;
+		pnc->nexthop_num = nhr->nexthop_num;
 		nexthops_free(pnc->nexthop);
 		pnc->nexthop = NULL;
 	}
 	SET_FLAG(pnc->flags, PIM_NEXTHOP_ANSWER_RECEIVED);
 
 	if (PIM_DEBUG_PIM_NHT)
-		zlog_debug(
-			"%s: NHT Update for %pFX(%s) num_nh %d num_pim_nh %d vrf:%u up %ld rp %d",
-			__func__, &match, pim->vrf->name, nhr.nexthop_num,
-			pnc->nexthop_num, vrf_id, pnc->upstream_hash->count,
-			listcount(pnc->rp_list));
+		zlog_debug("%s: NHT Update for %pFX(%s) num_nh %d num_pim_nh %d vrf:%u up %ld rp %d",
+			   __func__, match, pim->vrf->name, nhr->nexthop_num,
+			   pnc->nexthop_num, vrf->vrf_id,
+			   pnc->upstream_hash->count, listcount(pnc->rp_list));
 
 	pim_rpf_set_refresh_time(pim);
 
@@ -911,8 +900,6 @@ int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS)
 		pim_update_rp_nh(pim, pnc);
 	if (pnc->upstream_hash->count)
 		pim_update_upstream_nh(pim, pnc);
-
-	return 0;
 }
 
 int pim_ecmp_nexthop_lookup(struct pim_instance *pim,
diff --git a/pimd/pim_nht.h b/pimd/pim_nht.h
index 5a54e1c67ad3..a1feb76e3b73 100644
--- a/pimd/pim_nht.h
+++ b/pimd/pim_nht.h
@@ -45,7 +45,8 @@ struct pnc_hash_walk_data {
 	struct interface *ifp;
 };
 
-int pim_parse_nexthop_update(ZAPI_CALLBACK_ARGS);
+void pim_nexthop_update(struct vrf *vrf, struct prefix *match,
+			struct zapi_route *nhr);
 int pim_find_or_track_nexthop(struct pim_instance *pim, pim_addr addr,
 			      struct pim_upstream *up, struct rp_info *rp,
 			      struct pim_nexthop_cache *out_pnc);
diff --git a/pimd/pim_zebra.c b/pimd/pim_zebra.c
index 62f00dbf865c..73c9df8f891f 100644
--- a/pimd/pim_zebra.c
+++ b/pimd/pim_zebra.c
@@ -428,7 +428,6 @@ static zclient_handler *const pim_handlers[] = {
 	[ZEBRA_INTERFACE_ADDRESS_ADD] = pim_zebra_if_address_add,
 	[ZEBRA_INTERFACE_ADDRESS_DELETE] = pim_zebra_if_address_del,
 
-	[ZEBRA_NEXTHOP_UPDATE] = pim_parse_nexthop_update,
 	[ZEBRA_ROUTER_ID_UPDATE] = pim_router_id_update_zebra,
 
 #if PIM_IPV == 4
@@ -449,6 +448,7 @@ void pim_zebra_init(void)
 
 	zclient->zebra_capabilities = pim_zebra_capabilities;
 	zclient->zebra_connected = pim_zebra_connected;
+	zclient->nexthop_update = pim_nexthop_update;
 
 	zclient_init(zclient, ZEBRA_ROUTE_PIM, 0, &pimd_privs);
 	if (PIM_DEBUG_PIM_TRACE) {
diff --git a/sharpd/sharp_zebra.c b/sharpd/sharp_zebra.c
index fde9f9f544e8..40921ecdd38a 100644
--- a/sharpd/sharp_zebra.c
+++ b/sharpd/sharp_zebra.c
@@ -666,27 +666,20 @@ static int sharp_debug_nexthops(struct zapi_route *api)
 
 	return i;
 }
-static int sharp_nexthop_update(ZAPI_CALLBACK_ARGS)
+
+static void sharp_nexthop_update(struct vrf *vrf, struct prefix *matched,
+				 struct zapi_route *nhr)
 {
 	struct sharp_nh_tracker *nht;
-	struct zapi_route nhr;
-	struct prefix matched;
-
-	if (!zapi_nexthop_update_decode(zclient->ibuf, &matched, &nhr)) {
-		zlog_err("%s: Decode of update failed", __func__);
-		return 0;
-	}
 
 	zlog_debug("Received update for %pFX actual match: %pFX metric: %u",
-		   &matched, &nhr.prefix, nhr.metric);
+		   matched, &nhr->prefix, nhr->metric);
 
-	nht = sharp_nh_tracker_get(&matched);
-	nht->nhop_num = nhr.nexthop_num;
+	nht = sharp_nh_tracker_get(matched);
+	nht->nhop_num = nhr->nexthop_num;
 	nht->updates++;
 
-	sharp_debug_nexthops(&nhr);
-
-	return 0;
+	sharp_debug_nexthops(nhr);
 }
 
 static int sharp_redistribute_route(ZAPI_CALLBACK_ARGS)
@@ -1063,7 +1056,6 @@ static zclient_handler *const sharp_handlers[] = {
 	[ZEBRA_INTERFACE_ADDRESS_ADD] = interface_address_add,
 	[ZEBRA_INTERFACE_ADDRESS_DELETE] = interface_address_delete,
 	[ZEBRA_ROUTE_NOTIFY_OWNER] = route_notify_owner,
-	[ZEBRA_NEXTHOP_UPDATE] = sharp_nexthop_update,
 	[ZEBRA_NHG_NOTIFY_OWNER] = nhg_notify_owner,
 	[ZEBRA_REDISTRIBUTE_ROUTE_ADD] = sharp_redistribute_route,
 	[ZEBRA_REDISTRIBUTE_ROUTE_DEL] = sharp_redistribute_route,
@@ -1088,6 +1080,7 @@ void sharp_zebra_init(void)
 	zclient_init(zclient, ZEBRA_ROUTE_SHARP, 0, &sharp_privs);
 	zclient->zebra_connected = zebra_connected;
 	zclient->zebra_buffer_write_ready = sharp_zclient_buffer_ready;
+	zclient->nexthop_update = sharp_nexthop_update;
 }
 
 void sharp_zebra_terminate(void)
diff --git a/staticd/static_zebra.c b/staticd/static_zebra.c
index 7799cbdee33c..1489f53b5b6e 100644
--- a/staticd/static_zebra.c
+++ b/staticd/static_zebra.c
@@ -186,48 +186,40 @@ static_nexthop_is_local(vrf_id_t vrfid, struct prefix *addr, int family)
 	}
 	return false;
 }
-static int static_zebra_nexthop_update(ZAPI_CALLBACK_ARGS)
+
+static void static_zebra_nexthop_update(struct vrf *vrf, struct prefix *matched,
+					struct zapi_route *nhr)
 {
 	struct static_nht_data *nhtd, lookup;
-	struct zapi_route nhr;
-	struct prefix matched;
 	afi_t afi = AFI_IP;
 
-	if (!zapi_nexthop_update_decode(zclient->ibuf, &matched, &nhr)) {
-		zlog_err("Failure to decode nexthop update message");
-		return 1;
-	}
-
 	if (zclient->bfd_integration)
-		bfd_nht_update(&matched, &nhr);
+		bfd_nht_update(matched, nhr);
 
-	if (matched.family == AF_INET6)
+	if (matched->family == AF_INET6)
 		afi = AFI_IP6;
 
-	if (nhr.type == ZEBRA_ROUTE_CONNECT) {
-		if (static_nexthop_is_local(vrf_id, &matched,
-					    nhr.prefix.family))
-			nhr.nexthop_num = 0;
+	if (nhr->type == ZEBRA_ROUTE_CONNECT) {
+		if (static_nexthop_is_local(vrf->vrf_id, matched,
+					    nhr->prefix.family))
+			nhr->nexthop_num = 0;
 	}
 
 	memset(&lookup, 0, sizeof(lookup));
-	lookup.nh = matched;
-	lookup.nh_vrf_id = vrf_id;
-	lookup.safi = nhr.safi;
+	lookup.nh = *matched;
+	lookup.nh_vrf_id = vrf->vrf_id;
+	lookup.safi = nhr->safi;
 
 	nhtd = static_nht_hash_find(static_nht_hash, &lookup);
 
 	if (nhtd) {
-		nhtd->nh_num = nhr.nexthop_num;
+		nhtd->nh_num = nhr->nexthop_num;
 
-		static_nht_reset_start(&matched, afi, nhr.safi,
-				       nhtd->nh_vrf_id);
-		static_nht_update(NULL, &matched, nhr.nexthop_num, afi,
-				  nhr.safi, nhtd->nh_vrf_id);
+		static_nht_reset_start(matched, afi, nhr->safi, nhtd->nh_vrf_id);
+		static_nht_update(NULL, matched, nhr->nexthop_num, afi,
+				  nhr->safi, nhtd->nh_vrf_id);
 	} else
 		zlog_err("No nhtd?");
-
-	return 1;
 }
 
 static void static_zebra_capabilities(struct zclient_capabilities *cap)
@@ -535,7 +527,6 @@ static zclient_handler *const static_handlers[] = {
 	[ZEBRA_INTERFACE_ADDRESS_ADD] = interface_address_add,
 	[ZEBRA_INTERFACE_ADDRESS_DELETE] = interface_address_delete,
 	[ZEBRA_ROUTE_NOTIFY_OWNER] = route_notify_owner,
-	[ZEBRA_NEXTHOP_UPDATE] = static_zebra_nexthop_update,
 };
 
 void static_zebra_init(void)
@@ -553,6 +544,7 @@ void static_zebra_init(void)
 	zclient_init(zclient, ZEBRA_ROUTE_STATIC, 0, &static_privs);
 	zclient->zebra_capabilities = static_zebra_capabilities;
 	zclient->zebra_connected = zebra_connected;
+	zclient->nexthop_update = static_zebra_nexthop_update;
 
 	static_nht_hash_init(static_nht_hash);
 	static_bfd_initialize(zclient, master);