diff --git a/accounts/accounts.go b/accounts/accounts.go
index 6e473dc16..c7d7a6814 100644
--- a/accounts/accounts.go
+++ b/accounts/accounts.go
@@ -132,12 +132,8 @@ func (aS *AccountS) matchingAccountsForEvent(ctx *context.Context, tnt string, c
 func (aS *AccountS) accountsDebit(ctx *context.Context, acnts []*utils.AccountWithWeight,
 	cgrEv *utils.CGREvent, concretes, store bool) (ec *utils.EventCharges, err error) {
 	var usage *decimal.Big
-	if usage, err = engine.FilterDecimalBigCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), aS.fltrS,
-		aS.cfg.AccountSCfg().Opts.Usage); err != nil {
-		return
-	}
-	if usage, err = cgrEv.OptsAsDecimal(usage, utils.OptsAccountsUsage,
-		utils.MetaUsage); err != nil {
+	if usage, err = engine.GetDecimalBigOpts(ctx, cgrEv.Tenant, cgrEv, aS.fltrS, aS.cfg.AccountSCfg().Opts.Usage,
+		utils.OptsAccountsUsage, utils.MetaUsage); err != nil {
 		return
 	}
 	dbted := decimal.New(0, 0)
@@ -240,11 +236,8 @@ func (aS *AccountS) accountDebit(ctx *context.Context, acnt *utils.Account, usag
 // V1AccountsForEvent returns the matching Accounts for Event
 func (aS *AccountS) V1AccountsForEvent(ctx *context.Context, args *utils.CGREvent, aps *[]*utils.Account) (err error) {
 	var accIDs []string
-	if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
-		aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
-		return
-	}
-	if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
+	if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
+		utils.OptsAccountsAccountIDs); err != nil {
 		return
 	}
 	var acnts utils.AccountsWithWeight
@@ -262,11 +255,8 @@ func (aS *AccountS) V1AccountsForEvent(ctx *context.Context, args *utils.CGREven
 // V1MaxAbstracts returns the maximum abstract units for the event, based on matching Accounts
 func (aS *AccountS) V1MaxAbstracts(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
 	var accIDs []string
-	if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
-		aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
-		return
-	}
-	if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
+	if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
+		utils.OptsAccountsAccountIDs); err != nil {
 		return
 	}
 	var acnts utils.AccountsWithWeight
@@ -294,11 +284,8 @@ func (aS *AccountS) V1MaxAbstracts(ctx *context.Context, args *utils.CGREvent, e
 // V1DebitAbstracts performs debit for the provided event
 func (aS *AccountS) V1DebitAbstracts(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
 	var accIDs []string
-	if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
-		aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
-		return
-	}
-	if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
+	if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
+		utils.OptsAccountsAccountIDs); err != nil {
 		return
 	}
 	var acnts utils.AccountsWithWeight
@@ -327,11 +314,8 @@ func (aS *AccountS) V1DebitAbstracts(ctx *context.Context, args *utils.CGREvent,
 // V1MaxConcretes returns the maximum concrete units for the event, based on matching Accounts
 func (aS *AccountS) V1MaxConcretes(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
 	var accIDs []string
-	if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
-		aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
-		return
-	}
-	if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
+	if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
+		utils.OptsAccountsAccountIDs); err != nil {
 		return
 	}
 	var acnts utils.AccountsWithWeight
@@ -359,11 +343,8 @@ func (aS *AccountS) V1MaxConcretes(ctx *context.Context, args *utils.CGREvent, e
 // V1DebitConcretes performs debit of concrete units for the provided event
 func (aS *AccountS) V1DebitConcretes(ctx *context.Context, args *utils.CGREvent, eEc *utils.ExtEventCharges) (err error) {
 	var accIDs []string
-	if accIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
-		aS.cfg.AccountSCfg().Opts.AccountIDs); err != nil {
-		return
-	}
-	if accIDs, err = args.OptsAsStringSlice(accIDs, utils.OptsAccountsAccountIDs); err != nil {
+	if accIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.AccountSCfg().Opts.AccountIDs,
+		utils.OptsAccountsAccountIDs); err != nil {
 		return
 	}
 	var acnts utils.AccountsWithWeight
diff --git a/actions/actions.go b/actions/actions.go
index f0355ed2a..e40e17a0d 100644
--- a/actions/actions.go
+++ b/actions/actions.go
@@ -261,11 +261,8 @@ func (aS *ActionS) asapExecuteActions(ctx *context.Context, sActs *scheduledActs
 // V1ScheduleActions will be called to schedule actions matching the arguments
 func (aS *ActionS) V1ScheduleActions(ctx *context.Context, args *utils.CGREvent, rpl *string) (err error) {
 	var actPrfIDs []string
-	if actPrfIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
-		aS.cfg.ActionSCfg().Opts.ActionProfileIDs); err != nil {
-		return
-	}
-	if actPrfIDs, err = args.OptsAsStringSlice(actPrfIDs, utils.OptsActionsActionProfileIDs); err != nil {
+	if actPrfIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.ActionSCfg().Opts.ActionProfileIDs,
+		utils.OptsActionsActionProfileIDs); err != nil {
 		return
 	}
 	if err = aS.scheduleActions(ctx, []*utils.CGREvent{args},
@@ -279,11 +276,8 @@ func (aS *ActionS) V1ScheduleActions(ctx *context.Context, args *utils.CGREvent,
 // V1ExecuteActions will be called to execute ASAP action profiles, ignoring their Schedule field
 func (aS *ActionS) V1ExecuteActions(ctx *context.Context, args *utils.CGREvent, rpl *string) (err error) {
 	var actPrfIDs []string
-	if actPrfIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), aS.fltrS,
-		aS.cfg.ActionSCfg().Opts.ActionProfileIDs); err != nil {
-		return
-	}
-	if actPrfIDs, err = args.OptsAsStringSlice(actPrfIDs, utils.OptsActionsActionProfileIDs); err != nil {
+	if actPrfIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, aS.fltrS, aS.cfg.ActionSCfg().Opts.ActionProfileIDs,
+		utils.OptsActionsActionProfileIDs); err != nil {
 		return
 	}
 	var schedActSet []*scheduledActs
diff --git a/engine/attributes.go b/engine/attributes.go
index 38d12f62c..b3c24e126 100644
--- a/engine/attributes.go
+++ b/engine/attributes.go
@@ -133,7 +133,8 @@ func (attrReply *AttrSProcessEventReply) Digest() (rplyDigest string) {
 func (alS *AttributeService) processEvent(ctx *context.Context, tnt string, args *utils.CGREvent, evNm utils.MapStorage, dynDP utils.DataProvider,
 	lastID string, processedPrfNo map[string]int, profileRuns int) (rply *AttrSProcessEventReply, err error) {
 	var attrIDs []string
-	if attrIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsAttributesAttributeIDs); err != nil {
+	if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.AttributeIDs,
+		utils.OptsAttributesAttributeIDs); err != nil {
 		return
 	}
 	var attrPrf *AttributeProfile
@@ -207,7 +208,8 @@ func (alS *AttributeService) V1GetAttributeForEvent(ctx *context.Context, args *
 		tnt = alS.cgrcfg.GeneralCfg().DefaultTenant
 	}
 	var attrIDs []string
-	if attrIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsAttributesAttributeIDs); err != nil {
+	if attrIDs, err = GetStringSliceOpts(ctx, args.Tenant, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.AttributeIDs,
+		utils.OptsAttributesAttributeIDs); err != nil {
 		return
 	}
 	attrPrf, err := alS.attributeProfileForEvent(ctx, tnt, attrIDs, utils.MapStorage{
@@ -236,20 +238,14 @@ func (alS *AttributeService) V1ProcessEvent(ctx *context.Context, args *utils.CG
 	}
 
 	var processRuns int
-	if processRuns, err = FilterIntCfgOpts(ctx, tnt, args.AsDataProvider(), alS.filterS,
-		alS.cgrcfg.AttributeSCfg().Opts.ProcessRuns); err != nil {
-		return
-	}
-	if processRuns, err = args.OptsAsInt(processRuns, utils.OptsAttributesProcessRuns); err != nil {
+	if processRuns, err = GetIntOpts(ctx, tnt, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.ProcessRuns,
+		utils.OptsAttributesProcessRuns); err != nil {
 		return
 	}
 
 	var profileRuns int
-	if profileRuns, err = FilterIntCfgOpts(ctx, tnt, args.AsDataProvider(), alS.filterS,
-		alS.cgrcfg.AttributeSCfg().Opts.ProfileRuns); err != nil {
-		return
-	}
-	if profileRuns, err = args.OptsAsInt(profileRuns, utils.OptsAttributesProfileRuns); err != nil {
+	if profileRuns, err = GetIntOpts(ctx, tnt, args, alS.filterS, alS.cgrcfg.AttributeSCfg().Opts.ProfileRuns,
+		utils.OptsAttributesProfileRuns); err != nil {
 		return
 	}
 	args = args.Clone()
diff --git a/engine/cdrs.go b/engine/cdrs.go
index b5ad5f461..92db9f015 100644
--- a/engine/cdrs.go
+++ b/engine/cdrs.go
@@ -191,12 +191,8 @@ func (cdrS *CDRServer) eeSProcessEvent(ctx *context.Context, cgrEv *utils.CGREve
 func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (evs []*utils.EventWithFlags, err error) {
 	// making the options
 	var attrS bool
-	if v, has := ev.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
-	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
+	if attrS, err = GetBoolOpts(ctx, ev.Tenant, ev, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Attributes,
+		utils.OptsAttributeS); err != nil {
 		return
 	}
 	if attrS {
@@ -211,11 +207,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
 
 	var cgrEvs []*utils.CGREvent
 	var chrgS bool
-	if v, has := ev.APIOpts[utils.OptsChargerS]; !has {
-		if chrgS, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Chargers); err != nil {
-			return
-		}
-	} else if chrgS, err = utils.IfaceAsBool(v); err != nil {
+	if chrgS, err = GetBoolOpts(ctx, ev.Tenant, ev, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Chargers,
+		utils.OptsChargerS); err != nil {
 		return
 	}
 	if chrgS {
@@ -234,12 +227,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
 
 	var rateS bool
 	for _, cgrEv := range cgrEvs {
-		if v, has := cgrEv.APIOpts[utils.OptsRateS]; !has {
-			if rateS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
-				cdrS.cfg.CdrsCfg().Opts.Rates); err != nil {
-				return
-			}
-		} else if rateS, err = utils.IfaceAsBool(v); err != nil {
+		if rateS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Rates,
+			utils.OptsRateS); err != nil {
 			return
 		}
 		if rateS {
@@ -254,12 +243,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
 
 	var acntS bool
 	for _, cgrEv := range cgrEvs {
-		if v, has := cgrEv.APIOpts[utils.OptsAccountS]; !has {
-			if acntS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
-				cdrS.cfg.CdrsCfg().Opts.Accounts); err != nil {
-				return
-			}
-		} else if acntS, err = utils.IfaceAsBool(v); err != nil {
+		if acntS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Accounts,
+			utils.OptsAccountS); err != nil {
 			return
 		}
 		if acntS {
@@ -275,12 +260,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
 	var export bool
 	if len(cdrS.cfg.CdrsCfg().EEsConns) != 0 {
 		for _, cgrEv := range cgrEvs {
-			if v, has := cgrEv.APIOpts[utils.OptsCDRsExport]; !has {
-				if export, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
-					cdrS.cfg.CdrsCfg().Opts.Export); err != nil {
-					return
-				}
-			} else if export, err = utils.IfaceAsBool(v); err != nil {
+			if export, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Export,
+				utils.OptsCDRsExport); err != nil {
 				return
 			}
 			if export {
@@ -300,12 +281,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
 
 	var thdS bool
 	for _, cgrEv := range cgrEvs {
-		if v, has := cgrEv.APIOpts[utils.OptsThresholdS]; !has {
-			if thdS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
-				cdrS.cfg.CdrsCfg().Opts.Thresholds); err != nil {
-				return
-			}
-		} else if thdS, err = utils.IfaceAsBool(v); err != nil {
+		if thdS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Thresholds,
+			utils.OptsThresholdS); err != nil {
 			return
 		}
 		if thdS {
@@ -320,12 +297,8 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (e
 
 	var stS bool
 	for _, cgrEv := range cgrEvs {
-		if v, has := cgrEv.APIOpts[utils.OptsStatS]; !has {
-			if stS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
-				cdrS.cfg.CdrsCfg().Opts.Stats); err != nil {
-				return
-			}
-		} else if stS, err = utils.IfaceAsBool(v); err != nil {
+		if stS, err = GetBoolOpts(ctx, cgrEv.Tenant, cgrEv, cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Stats,
+			utils.OptsStatS); err != nil {
 			return
 		}
 		if stS {
diff --git a/engine/resources.go b/engine/resources.go
index 661fa1b09..199fc0d69 100644
--- a/engine/resources.go
+++ b/engine/resources.go
@@ -672,18 +672,14 @@ func (rS *ResourceService) V1ResourcesForEvent(ctx *context.Context, args *utils
 	}
 
 	var usageID string
-	if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
+		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
-	usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
 
 	var ttl time.Duration
-	if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
-		return
-	}
-	if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
+		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}
 	usageTTL := utils.DurationPointer(ttl)
@@ -734,27 +730,20 @@ func (rS *ResourceService) V1AuthorizeResources(ctx *context.Context, args *util
 	}
 
 	var usageID string
-	if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
+		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
-	usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
 
 	var units float64
-	if units, err = FilterFloat64CfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.Units); err != nil {
-		return
-	}
-	if units, err = args.OptsAsFloat64(units, utils.OptsResourcesUnits); err != nil {
+	if units, err = GetFloat64Opts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.Units,
+		utils.OptsResourcesUnits); err != nil {
 		return
 	}
 
 	var ttl time.Duration
-	if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
-		return
-	}
-	if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
+		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}
 	usageTTL := utils.DurationPointer(ttl)
@@ -817,27 +806,20 @@ func (rS *ResourceService) V1AllocateResources(ctx *context.Context, args *utils
 	}
 
 	var usageID string
-	if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
+		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
-	usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
 
 	var units float64
-	if units, err = FilterFloat64CfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.Units); err != nil {
-		return
-	}
-	if units, err = args.OptsAsFloat64(units, utils.OptsResourcesUnits); err != nil {
+	if units, err = GetFloat64Opts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.Units,
+		utils.OptsResourcesUnits); err != nil {
 		return
 	}
 
 	var ttl time.Duration
-	if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
-		return
-	}
-	if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
+		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}
 	usageTTL := utils.DurationPointer(ttl)
@@ -904,18 +886,14 @@ func (rS *ResourceService) V1ReleaseResources(ctx *context.Context, args *utils.
 	}
 
 	var usageID string
-	if usageID, err = FilterStringCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageID); err != nil {
+	if usageID, err = GetStringOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageID,
+		utils.OptsResourcesUsageID); err != nil {
 		return
 	}
-	usageID = args.OptsAsString(usageID, utils.OptsResourcesUsageID)
 
 	var ttl time.Duration
-	if ttl, err = FilterDurationCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cgrcfg.ResourceSCfg().Opts.UsageTTL); err != nil {
-		return
-	}
-	if ttl, err = args.OptsAsDuration(ttl, utils.OptsResourcesUsageTTL); err != nil {
+	if ttl, err = GetDurationOpts(ctx, args.Tenant, args, rS.filterS, rS.cgrcfg.ResourceSCfg().Opts.UsageTTL,
+		utils.OptsResourcesUsageTTL); err != nil {
 		return
 	}
 	usageTTL := utils.DurationPointer(ttl)
diff --git a/engine/routes.go b/engine/routes.go
index 4d450e609..722b09940 100644
--- a/engine/routes.go
+++ b/engine/routes.go
@@ -185,45 +185,27 @@ func (rpS *RouteService) matchingRouteProfilesForEvent(ctx *context.Context, tnt
 
 func newOptsGetRoutes(ctx *context.Context, ev *utils.CGREvent, fS *FilterS, def *config.RoutesOpts) (opts *optsGetRoutes, err error) {
 	var ignoreErrors bool
-	if ignoreErrors, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
-		def.IgnoreErrors); err != nil {
+	if ignoreErrors, err = GetBoolOpts(ctx, ev.Tenant, ev, fS, def.IgnoreErrors,
+		utils.OptsRoutesIgnoreErrors); err != nil {
 		return
 	}
 	opts = &optsGetRoutes{
-		ignoreErrors: utils.OptAsBoolOrDef(ev.APIOpts, utils.OptsRoutesIgnoreErrors, ignoreErrors),
+		ignoreErrors: ignoreErrors,
 		paginator:    &utils.Paginator{},
 	}
 	var limit int
-	if limit, err = FilterIntCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
-		def.Limit); err != nil {
-		if err == utils.ErrNotFound {
-			if limitOpt, has := ev.APIOpts[utils.OptsRoutesLimit]; has {
-				var limitValue int64
-				limitValue, err = utils.IfaceAsTInt64(limitOpt)
-				if err != nil {
-					return
-				}
-				opts.paginator.Limit = utils.IntPointer(int(limitValue))
-			}
-		} else {
+	if limit, err = GetIntOpts(ctx, ev.Tenant, ev, fS, def.Limit,
+		utils.OptsRoutesLimit); err != nil {
+		if err != utils.ErrNotFound {
 			return
 		}
 	} else {
 		opts.paginator.Limit = utils.IntPointer(limit)
 	}
 	var offset int
-	if offset, err = FilterIntCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
-		def.Offset); err != nil {
-		if err == utils.ErrNotFound {
-			if offsetOpt, has := ev.APIOpts[utils.OptsRoutesOffset]; has {
-				var offsetValue int64
-				offsetValue, err = utils.IfaceAsTInt64(offsetOpt)
-				if err != nil {
-					return
-				}
-				opts.paginator.Offset = utils.IntPointer(int(offsetValue))
-			}
-		} else {
+	if offset, err = GetIntOpts(ctx, ev.Tenant, ev, fS, def.Offset,
+		utils.OptsRoutesOffset); err != nil {
+		if err != utils.ErrNotFound {
 			return
 		}
 	} else {
@@ -231,11 +213,10 @@ func newOptsGetRoutes(ctx *context.Context, ev *utils.CGREvent, fS *FilterS, def
 	}
 
 	var maxCost interface{}
-	if maxCost, err = FilterInterfaceCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), fS,
-		def.MaxCost); err != nil {
+	if maxCost, err = GetInterfaceOpts(ctx, ev.Tenant, ev, fS, def.MaxCost,
+		utils.OptsRoutesMaxCost); err != nil {
 		return
 	}
-	maxCost = ev.OptsAsInterface(maxCost, utils.OptsRoutesMaxCost)
 
 	switch maxCost {
 	case utils.EmptyString, nil:
@@ -289,14 +270,11 @@ func (rpS *RouteService) V1GetRoutes(ctx *context.Context, args *utils.CGREvent,
 		}
 		args.APIOpts[utils.Subsys] = utils.MetaRoutes
 		var context string
-		if context, err = FilterStringCfgOpts(ctx, tnt, args.AsDataProvider(), rpS.filterS,
-			rpS.cfg.RouteSCfg().Opts.Context); err != nil {
+		if context, err = GetStringOpts(ctx, tnt, args, rpS.filterS, rpS.cfg.RouteSCfg().Opts.Context,
+			utils.OptsContext); err != nil {
 			return
 		}
-		args.APIOpts[utils.OptsContext] = utils.FirstNonEmpty(
-			utils.IfaceAsString(args.APIOpts[utils.OptsContext]),
-			context,
-			utils.MetaRoutes)
+		args.APIOpts[utils.OptsContext] = context
 		var rplyEv AttrSProcessEventReply
 		if err := rpS.connMgr.Call(ctx, rpS.cfg.RouteSCfg().AttributeSConns,
 			utils.AttributeSv1ProcessEvent, args, &rplyEv); err == nil && len(rplyEv.AlteredFields) != 0 {
@@ -409,11 +387,8 @@ func (rpS *RouteService) sortedRoutesForEvent(ctx *context.Context, tnt string,
 	}
 	prfCount := len(rPrfs) // if the option is not present return for all profiles
 	var prfCountOpt int
-	if prfCountOpt, err = FilterIntCfgOpts(ctx, tnt, args.AsDataProvider(), rpS.filterS,
-		rpS.cfg.RouteSCfg().Opts.ProfileCount); err != nil {
-		return
-	}
-	if prfCountOpt, err = args.OptsAsInt(prfCountOpt, utils.OptsRoutesProfileCount); err != nil {
+	if prfCountOpt, err = GetIntOpts(ctx, tnt, args, rpS.filterS, rpS.cfg.RouteSCfg().Opts.ProfileCount,
+		utils.OptsRoutesProfileCount); err != nil {
 		return
 	}
 	if prfCount > prfCountOpt { // it has the option and is smaller that the current number of profiles
diff --git a/engine/stats.go b/engine/stats.go
index 346d0e71e..6d378826c 100644
--- a/engine/stats.go
+++ b/engine/stats.go
@@ -337,11 +337,8 @@ func (sS *StatService) processEvent(ctx *context.Context, tnt string, args *Stat
 		utils.MetaOpts: args.APIOpts,
 	}
 	var sqIDs []string
-	if sqIDs, err = FilterStringSliceCfgOpts(ctx, tnt, args.AsDataProvider(), sS.filterS,
-		sS.cgrcfg.StatSCfg().Opts.StatIDs); err != nil {
-		return
-	}
-	if sqIDs, err = args.OptsAsStringSlice(sqIDs, utils.OptsStatsStatIDs); err != nil {
+	if sqIDs, err = GetStringSliceOpts(ctx, tnt, args.CGREvent, sS.filterS, sS.cgrcfg.StatSCfg().Opts.StatIDs,
+		utils.OptsStatsStatIDs); err != nil {
 		return
 	}
 	matchSQs, err := sS.matchingStatQueuesForEvent(ctx, tnt, sqIDs, evNm)
@@ -406,10 +403,8 @@ func (sS *StatService) V1GetStatQueuesForEvent(ctx *context.Context, args *Stats
 		tnt = sS.cgrcfg.GeneralCfg().DefaultTenant
 	}
 	var sqIDs []string
-	if sqIDs, err = FilterStringSliceCfgOpts(ctx, tnt, args.AsDataProvider(), sS.filterS,
-		sS.cgrcfg.StatSCfg().Opts.StatIDs); err != nil {
-	}
-	if sqIDs, err = args.OptsAsStringSlice(sqIDs, utils.OptsStatsStatIDs); err != nil {
+	if sqIDs, err = GetStringSliceOpts(ctx, tnt, args.CGREvent, sS.filterS, sS.cgrcfg.StatSCfg().Opts.StatIDs,
+		utils.OptsStatsStatIDs); err != nil {
 		return
 	}
 	var sQs StatQueues
diff --git a/engine/thresholds.go b/engine/thresholds.go
index 30a4769f3..157ae785c 100644
--- a/engine/thresholds.go
+++ b/engine/thresholds.go
@@ -330,19 +330,11 @@ func (tS *ThresholdService) matchingThresholdsForEvent(ctx *context.Context, tnt
 		utils.MetaOpts: args.APIOpts,
 	}
 	var thIDs []string
-	if thIDs, err = FilterStringSliceCfgOpts(ctx, tnt, args.AsDataProvider(), tS.filterS,
-		tS.cgrcfg.ThresholdSCfg().Opts.ThresholdIDs); err != nil {
-		return
-	}
-	if thIDs, err = args.OptsAsStringSlice(thIDs, utils.OptsThresholdsThresholdIDs); err != nil {
+	if thIDs, err = GetStringSliceOpts(ctx, tnt, args, tS.filterS, tS.cgrcfg.ThresholdSCfg().Opts.ThresholdIDs,
+		utils.OptsThresholdsThresholdIDs); err != nil {
 		return
 	}
 
-	if args.APIOpts[utils.OptsThresholdsThresholdIDs] != nil {
-		if thIDs, err = utils.IfaceAsStringSlice(args.APIOpts[utils.OptsThresholdsThresholdIDs]); err != nil {
-			return
-		}
-	}
 	tIDs := utils.NewStringSet(thIDs)
 	if len(tIDs) == 0 {
 		tIDs, err = MatchingItemIDsForEvent(ctx, evNm,
diff --git a/rates/rates.go b/rates/rates.go
index c05919671..4d00f4fc8 100644
--- a/rates/rates.go
+++ b/rates/rates.go
@@ -178,11 +178,8 @@ func (rS *RateS) rateProfileCostForEvent(ctx *context.Context, rtPfl *utils.Rate
 		return
 	}
 	var usage *decimal.Big
-	if usage, err = engine.FilterDecimalBigCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cfg.RateSCfg().Opts.Usage); err != nil {
-		return
-	}
-	if usage, err = args.OptsAsDecimal(usage, utils.OptsRatesUsage, utils.MetaUsage); err != nil {
+	if usage, err = engine.GetDecimalBigOpts(ctx, args.Tenant, args, rS.filterS, rS.cfg.RateSCfg().Opts.Usage,
+		utils.OptsRatesUsage, utils.MetaUsage); err != nil {
 		return
 	}
 	var ordRts []*orderedRate
@@ -200,11 +197,8 @@ func (rS *RateS) rateProfileCostForEvent(ctx *context.Context, rtPfl *utils.Rate
 		rpCost.MaxCost = rtPfl.MaxCost
 	}
 	var ivalStart *decimal.Big
-	if ivalStart, err = engine.FilterDecimalBigCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cfg.RateSCfg().Opts.IntervalStart); err != nil {
-		return
-	}
-	if ivalStart, err = args.OptsAsDecimal(ivalStart, utils.OptsRatesIntervalStart); err != nil {
+	if ivalStart, err = engine.GetDecimalBigOpts(ctx, args.Tenant, args, rS.filterS, rS.cfg.RateSCfg().Opts.IntervalStart,
+		utils.OptsRatesIntervalStart); err != nil {
 		return
 	}
 	var costIntervals []*utils.RateSInterval
@@ -224,11 +218,8 @@ func (rS *RateS) rateProfileCostForEvent(ctx *context.Context, rtPfl *utils.Rate
 // V1CostForEvent will be called to calculate the cost for an event
 func (rS *RateS) V1CostForEvent(ctx *context.Context, args *utils.CGREvent, rpCost *utils.RateProfileCost) (err error) {
 	var rPfIDs []string
-	if rPfIDs, err = engine.FilterStringSliceCfgOpts(ctx, args.Tenant, args.AsDataProvider(), rS.filterS,
-		rS.cfg.RateSCfg().Opts.RateProfileIDs); err != nil {
-		return
-	}
-	if rPfIDs, err = args.OptsAsStringSlice(rPfIDs, utils.OptsRatesRateProfileIDs); err != nil {
+	if rPfIDs, err = engine.GetStringSliceOpts(ctx, args.Tenant, args, rS.filterS, rS.cfg.RateSCfg().Opts.RateProfileIDs,
+		utils.OptsRatesRateProfileIDs); err != nil {
 		return
 	}
 	var rtPrl *utils.RateProfile