diff --git a/adapter/internal/oasparser/constants/constants.go b/adapter/internal/oasparser/constants/constants.go
index df863dc5a6..3893d473a0 100644
--- a/adapter/internal/oasparser/constants/constants.go
+++ b/adapter/internal/oasparser/constants/constants.go
@@ -98,6 +98,7 @@ const (
 	SOAP                  string = "SOAP"
 	WS                    string = "WS"
 	GRAPHQL               string = "GraphQL"
+	GRPC                  string = "GRPC"
 	WEBHOOK               string = "WEBHOOK"
 	SSE                   string = "SSE"
 	Prototyped            string = "prototyped"
diff --git a/adapter/internal/oasparser/envoyconf/routes_with_clusters.go b/adapter/internal/oasparser/envoyconf/routes_with_clusters.go
index acb0edb510..dc2b983c3b 100644
--- a/adapter/internal/oasparser/envoyconf/routes_with_clusters.go
+++ b/adapter/internal/oasparser/envoyconf/routes_with_clusters.go
@@ -197,6 +197,73 @@ func CreateRoutesWithClusters(adapterInternalAPI *model.AdapterInternalAPI, inte
 		}
 		return routes, clusters, endpoints, nil
 	}
+	if adapterInternalAPI.GetAPIType() == constants.GRPC {
+		basePath := strings.TrimSuffix(adapterInternalAPI.Endpoints.Endpoints[0].Basepath, "/")
+
+		clusterName := getClusterName(adapterInternalAPI.Endpoints.EndpointPrefix, organizationID, vHost,
+			adapterInternalAPI.GetTitle(), apiVersion, "")
+		adapterInternalAPI.Endpoints.HTTP2BackendEnabled = true
+		cluster, address, err := processEndpoints(clusterName, adapterInternalAPI.Endpoints, timeout, basePath)
+		if err != nil {
+			logger.LoggerOasparser.ErrorC(logging.PrintError(logging.Error2239, logging.MAJOR,
+				"Error while adding grpc endpoints for %s:%v. %v", apiTitle, apiVersion, err.Error()))
+			return nil, nil, nil, fmt.Errorf("error while adding grpc endpoints for %s:%v. %v", apiTitle, apiVersion,
+				err.Error())
+		}
+		clusters = append(clusters, cluster)
+		endpoints = append(endpoints, address...)
+
+		for _, resource := range adapterInternalAPI.GetResources() {
+			var clusterName string
+			resourcePath := resource.GetPath()
+			endpoint := resource.GetEndpoints()
+			endpoint.HTTP2BackendEnabled = true
+			basePath := strings.TrimSuffix(endpoint.Endpoints[0].Basepath, "/")
+			existingClusterName := getExistingClusterName(*endpoint, processedEndpoints)
+
+			if existingClusterName == "" {
+				clusterName = getClusterName(endpoint.EndpointPrefix, organizationID, vHost, adapterInternalAPI.GetTitle(), apiVersion, resource.GetID())
+				cluster, address, err := processEndpoints(clusterName, endpoint, timeout, basePath)
+				if err != nil {
+					logger.LoggerOasparser.ErrorC(logging.PrintError(logging.Error2239, logging.MAJOR, "Error while adding resource level endpoints for %s:%v-%v. %v", apiTitle, apiVersion, resourcePath, err.Error()))
+				} else {
+					clusters = append(clusters, cluster)
+					endpoints = append(endpoints, address...)
+					processedEndpoints[clusterName] = *endpoint
+				}
+			} else {
+				clusterName = existingClusterName
+			}
+			// Create resource level interceptor clusters if required
+			clustersI, endpointsI, operationalReqInterceptors, operationalRespInterceptorVal := createInterceptorResourceClusters(adapterInternalAPI,
+				interceptorCerts, vHost, organizationID, apiRequestInterceptor, apiResponseInterceptor, resource)
+			clusters = append(clusters, clustersI...)
+			endpoints = append(endpoints, endpointsI...)
+			routeParams := genRouteCreateParams(adapterInternalAPI, resource, vHost, basePath, clusterName, *operationalReqInterceptors, *operationalRespInterceptorVal, organizationID,
+				false, false)
+
+			routeP, err := createRoutes(routeParams)
+			if err != nil {
+				logger.LoggerXds.ErrorC(logging.PrintError(logging.Error2231, logging.MAJOR,
+					"Error while creating routes for GRPC API %s %s for path: %s Error: %s", adapterInternalAPI.GetTitle(),
+					adapterInternalAPI.GetVersion(), resource.GetPath(), err.Error()))
+				return nil, nil, nil, fmt.Errorf("error while creating routes. %v", err)
+			}
+			routes = append(routes, routeP...)
+			if adapterInternalAPI.IsDefaultVersion {
+				defaultRoutes, errDefaultPath := createRoutes(genRouteCreateParams(adapterInternalAPI, resource, vHost, basePath, clusterName, *operationalReqInterceptors, *operationalRespInterceptorVal, organizationID,
+					false, true))
+				if errDefaultPath != nil {
+					logger.LoggerXds.ErrorC(logging.PrintError(logging.Error2231, logging.MAJOR, "Error while creating routes for GRPC API %s %s for path: %s Error: %s", adapterInternalAPI.GetTitle(), adapterInternalAPI.GetVersion(), removeFirstOccurrence(resource.GetPath(), adapterInternalAPI.GetVersion()), errDefaultPath.Error()))
+					return nil, nil, nil, fmt.Errorf("error while creating routes. %v", errDefaultPath)
+				}
+				routes = append(routes, defaultRoutes...)
+			}
+
+		}
+
+		return routes, clusters, endpoints, nil
+	}
 	for _, resource := range adapterInternalAPI.GetResources() {
 		var clusterName string
 		resourcePath := resource.GetPath()
@@ -860,8 +927,14 @@ func createRoutes(params *routeCreateParams) (routes []*routev3.Route, err error
 		decorator *routev3.Decorator
 	)
 	if params.createDefaultPath {
-		xWso2Basepath = removeFirstOccurrence(xWso2Basepath, "/"+version)
-		resourcePath = removeFirstOccurrence(resource.GetPath(), "/"+version)
+		//check if basepath is separated from version by a . or /
+		if strings.Contains(basePath, "."+version) {
+			xWso2Basepath = removeFirstOccurrence(basePath, "."+version)
+			resourcePath = removeFirstOccurrence(resource.GetPath(), "."+version)
+		} else {
+			xWso2Basepath = removeFirstOccurrence(xWso2Basepath, "/"+version)
+			resourcePath = removeFirstOccurrence(resource.GetPath(), "/"+version)
+		}
 	}
 
 	if pathMatchType != gwapiv1.PathMatchExact {
@@ -1058,6 +1131,16 @@ func createRoutes(params *routeCreateParams) (routes []*routev3.Route, err error
 		rewritePath := generateRoutePathForReWrite(basePath, resourcePath, pathMatchType)
 		action.Route.RegexRewrite = generateRegexMatchAndSubstitute(rewritePath, resourcePath, pathMatchType)
 
+		if apiType == "GRPC" {
+			match.Headers = nil
+			newRoutePath := "/" + strings.TrimPrefix(resourcePath, basePath+".")
+			if newRoutePath == "/"+resourcePath {
+				temp := removeFirstOccurrence(basePath, "."+version)
+				newRoutePath = "/" + strings.TrimPrefix(resourcePath, temp+".")
+			}
+			action.Route.RegexRewrite = generateRegexMatchAndSubstitute(rewritePath, newRoutePath, pathMatchType)
+		}
+
 		route := generateRouteConfig(xWso2Basepath, match, action, nil, decorator, perRouteFilterConfigs,
 			nil, nil, nil, nil) // general headers to add and remove are included in this methods
 		routes = append(routes, route)
@@ -1209,8 +1292,14 @@ func CreateAPIDefinitionEndpoint(adapterInternalAPI *model.AdapterInternalAPI, v
 
 	matchPath := basePath + endpoint
 	if isDefaultversion {
-		basePathWithoutVersion := removeLastOccurrence(basePath, "/"+version)
-		matchPath = basePathWithoutVersion + endpoint
+		if adapterInternalAPI.GetAPIType() == "GRPC" {
+			basePathWithoutVersion := removeLastOccurrence(basePath, "."+version)
+			matchPath = basePathWithoutVersion + "/" + vHost + endpoint
+		} else {
+			basePathWithoutVersion := removeLastOccurrence(basePath, "/"+version)
+			matchPath = basePathWithoutVersion + endpoint
+
+		}
 	}
 
 	matchPath = strings.Replace(matchPath, basePath, regexp.QuoteMeta(basePath), 1)
diff --git a/adapter/internal/oasparser/model/adapter_internal_api.go b/adapter/internal/oasparser/model/adapter_internal_api.go
index a5318d66a0..0e698a7413 100644
--- a/adapter/internal/oasparser/model/adapter_internal_api.go
+++ b/adapter/internal/oasparser/model/adapter_internal_api.go
@@ -21,6 +21,7 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	gwapiv1a2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	"strconv"
 	"strings"
 	"time"
@@ -940,6 +941,182 @@ func (adapterInternalAPI *AdapterInternalAPI) SetInfoGQLRouteCR(gqlRoute *dpv1al
 	return nil
 }
 
+// SetInfoGRPCRouteCR populates resources and endpoints of adapterInternalAPI. httpRoute.Spec.Rules.Matches
+// are used to create resources and httpRoute.Spec.Rules.BackendRefs are used to create EndpointClusters.
+func (adapterInternalAPI *AdapterInternalAPI) SetInfoGRPCRouteCR(grpcRoute *gwapiv1a2.GRPCRoute, resourceParams ResourceParams) error {
+	var resources []*Resource
+	outputAuthScheme := utils.TieBreaker(utils.GetPtrSlice(maps.Values(resourceParams.AuthSchemes)))
+	outputAPIPolicy := utils.TieBreaker(utils.GetPtrSlice(maps.Values(resourceParams.APIPolicies)))
+	outputRatelimitPolicy := utils.TieBreaker(utils.GetPtrSlice(maps.Values(resourceParams.RateLimitPolicies)))
+
+	disableScopes := true
+	config := config.ReadConfigs()
+
+	var authScheme *dpv1alpha2.Authentication
+	if outputAuthScheme != nil {
+		authScheme = *outputAuthScheme
+	}
+	var apiPolicy *dpv1alpha2.APIPolicy
+	if outputAPIPolicy != nil {
+		apiPolicy = *outputAPIPolicy
+	}
+	var ratelimitPolicy *dpv1alpha1.RateLimitPolicy
+	if outputRatelimitPolicy != nil {
+		ratelimitPolicy = *outputRatelimitPolicy
+	}
+
+	//We are only supporting one backend for now
+	backend := grpcRoute.Spec.Rules[0].BackendRefs[0]
+	backendName := types.NamespacedName{
+		Name:      string(backend.Name),
+		Namespace: utils.GetNamespace(backend.Namespace, grpcRoute.Namespace),
+	}
+	resolvedBackend, ok := resourceParams.BackendMapping[backendName.String()]
+	if ok {
+		endpointConfig := &EndpointConfig{}
+		if resolvedBackend.CircuitBreaker != nil {
+			endpointConfig.CircuitBreakers = &CircuitBreakers{
+				MaxConnections:     int32(resolvedBackend.CircuitBreaker.MaxConnections),
+				MaxRequests:        int32(resolvedBackend.CircuitBreaker.MaxRequests),
+				MaxPendingRequests: int32(resolvedBackend.CircuitBreaker.MaxPendingRequests),
+				MaxRetries:         int32(resolvedBackend.CircuitBreaker.MaxRetries),
+				MaxConnectionPools: int32(resolvedBackend.CircuitBreaker.MaxConnectionPools),
+			}
+		}
+		if resolvedBackend.Timeout != nil {
+			endpointConfig.TimeoutInMillis = resolvedBackend.Timeout.UpstreamResponseTimeout * 1000
+			endpointConfig.IdleTimeoutInSeconds = resolvedBackend.Timeout.DownstreamRequestIdleTimeout
+		}
+		if resolvedBackend.Retry != nil {
+			statusCodes := config.Envoy.Upstream.Retry.StatusCodes
+			if len(resolvedBackend.Retry.StatusCodes) > 0 {
+				statusCodes = resolvedBackend.Retry.StatusCodes
+			}
+			endpointConfig.RetryConfig = &RetryConfig{
+				Count:                int32(resolvedBackend.Retry.Count),
+				StatusCodes:          statusCodes,
+				BaseIntervalInMillis: int32(resolvedBackend.Retry.BaseIntervalMillis),
+			}
+		}
+		adapterInternalAPI.Endpoints = &EndpointCluster{
+			Endpoints: GetEndpoints(backendName, resourceParams.BackendMapping),
+			Config:    endpointConfig,
+		}
+		if resolvedBackend.HealthCheck != nil {
+			adapterInternalAPI.Endpoints.HealthCheck = &HealthCheck{
+				Interval:           resolvedBackend.HealthCheck.Interval,
+				Timeout:            resolvedBackend.HealthCheck.Timeout,
+				UnhealthyThreshold: resolvedBackend.HealthCheck.UnhealthyThreshold,
+				HealthyThreshold:   resolvedBackend.HealthCheck.HealthyThreshold,
+			}
+		}
+
+		var securityConfig []EndpointSecurity
+		switch resolvedBackend.Security.Type {
+		case "Basic":
+			securityConfig = append(securityConfig, EndpointSecurity{
+				Password: string(resolvedBackend.Security.Basic.Password),
+				Username: string(resolvedBackend.Security.Basic.Username),
+				Type:     string(resolvedBackend.Security.Type),
+				Enabled:  true,
+			})
+		}
+		adapterInternalAPI.EndpointSecurity = utils.GetPtrSlice(securityConfig)
+	} else {
+		return fmt.Errorf("backend: %s has not been resolved", backendName)
+	}
+
+	for _, rule := range grpcRoute.Spec.Rules {
+		var policies = OperationPolicies{}
+		var endPoints []Endpoint
+		resourceAuthScheme := authScheme
+		resourceRatelimitPolicy := ratelimitPolicy
+		var scopes []string
+		for _, filter := range rule.Filters {
+			if filter.ExtensionRef != nil && filter.ExtensionRef.Kind == constants.KindAuthentication {
+				if ref, found := resourceParams.ResourceAuthSchemes[types.NamespacedName{
+					Name:      string(filter.ExtensionRef.Name),
+					Namespace: grpcRoute.Namespace,
+				}.String()]; found {
+					resourceAuthScheme = concatAuthSchemes(authScheme, &ref)
+				} else {
+					return fmt.Errorf(`auth scheme: %s has not been resolved, spec.targetRef.kind should be 
+						'Resource' in resource level Authentications`, filter.ExtensionRef.Name)
+				}
+			}
+			if filter.ExtensionRef != nil && filter.ExtensionRef.Kind == constants.KindScope {
+				if ref, found := resourceParams.ResourceScopes[types.NamespacedName{
+					Name:      string(filter.ExtensionRef.Name),
+					Namespace: grpcRoute.Namespace,
+				}.String()]; found {
+					scopes = ref.Spec.Names
+					disableScopes = false
+				} else {
+					return fmt.Errorf("scope: %s has not been resolved in namespace %s", filter.ExtensionRef.Name, grpcRoute.Namespace)
+				}
+			}
+			if filter.ExtensionRef != nil && filter.ExtensionRef.Kind == constants.KindRateLimitPolicy {
+				if ref, found := resourceParams.ResourceRateLimitPolicies[types.NamespacedName{
+					Name:      string(filter.ExtensionRef.Name),
+					Namespace: grpcRoute.Namespace,
+				}.String()]; found {
+					resourceRatelimitPolicy = concatRateLimitPolicies(ratelimitPolicy, &ref)
+				} else {
+					return fmt.Errorf(`ratelimitpolicy: %s has not been resolved, spec.targetRef.kind should be 
+						'Resource' in resource level RateLimitPolicies`, filter.ExtensionRef.Name)
+				}
+			}
+		}
+		resourceAuthScheme = concatAuthSchemes(resourceAuthScheme, nil)
+		resourceRatelimitPolicy = concatRateLimitPolicies(resourceRatelimitPolicy, nil)
+
+		loggers.LoggerOasparser.Debugf("Calculating auths for API ..., API_UUID = %v", adapterInternalAPI.UUID)
+		apiAuth := getSecurity(resourceAuthScheme)
+
+		for _, match := range rule.Matches {
+			resourcePath := adapterInternalAPI.GetXWso2Basepath() + "." + *match.Method.Service + "/" + *match.Method.Method
+			endPoints = append(endPoints, GetEndpoints(backendName, resourceParams.BackendMapping)...)
+			resource := &Resource{path: resourcePath, pathMatchType: "Exact",
+				methods: []*Operation{{iD: uuid.New().String(), method: "post", policies: policies,
+					auth: apiAuth, rateLimitPolicy: parseRateLimitPolicyToInternal(resourceRatelimitPolicy), scopes: scopes}},
+				iD: uuid.New().String(),
+			}
+			endpoints := GetEndpoints(backendName, resourceParams.BackendMapping)
+			resource.endpoints = &EndpointCluster{
+				Endpoints: endpoints,
+			}
+			resources = append(resources, resource)
+		}
+	}
+
+	ratelimitPolicy = concatRateLimitPolicies(ratelimitPolicy, nil)
+	apiPolicy = concatAPIPolicies(apiPolicy, nil)
+	authScheme = concatAuthSchemes(authScheme, nil)
+
+	adapterInternalAPI.RateLimitPolicy = parseRateLimitPolicyToInternal(ratelimitPolicy)
+	adapterInternalAPI.resources = resources
+	adapterInternalAPI.xWso2Cors = getCorsConfigFromAPIPolicy(apiPolicy)
+	if authScheme.Spec.Override != nil && authScheme.Spec.Override.Disabled != nil {
+		adapterInternalAPI.disableAuthentications = *authScheme.Spec.Override.Disabled
+	}
+	authSpec := utils.SelectPolicy(&authScheme.Spec.Override, &authScheme.Spec.Default, nil, nil)
+	if authSpec != nil && authSpec.AuthTypes != nil && authSpec.AuthTypes.Oauth2.Required != "" {
+		adapterInternalAPI.SetXWSO2ApplicationSecurity(authSpec.AuthTypes.Oauth2.Required == "mandatory")
+	} else {
+		adapterInternalAPI.SetXWSO2ApplicationSecurity(true)
+	}
+	adapterInternalAPI.disableScopes = disableScopes
+	// Check whether the API has a backend JWT token
+	if apiPolicy != nil && apiPolicy.Spec.Override != nil && apiPolicy.Spec.Override.BackendJWTPolicy != nil {
+		backendJWTPolicy := resourceParams.BackendJWTMapping[types.NamespacedName{
+			Name:      apiPolicy.Spec.Override.BackendJWTPolicy.Name,
+			Namespace: grpcRoute.Namespace,
+		}.String()].Spec
+		adapterInternalAPI.backendJWTTokenInfo = parseBackendJWTTokenToInternal(backendJWTPolicy)
+	}
+	return nil
+}
+
 func (endpoint *Endpoint) validateEndpoint() error {
 	if endpoint.Port == 0 || endpoint.Port > 65535 {
 		return errors.New("endpoint port value should be between 0 and 65535")
diff --git a/adapter/internal/oasparser/model/common.go b/adapter/internal/oasparser/model/common.go
index d1d3ba6646..8c5c2f54cc 100644
--- a/adapter/internal/oasparser/model/common.go
+++ b/adapter/internal/oasparser/model/common.go
@@ -108,7 +108,7 @@ func getHostandBasepathandPort(apiType string, rawURL string) (*Endpoint, error)
 	rawURL = strings.Trim(rawURL, " ")
 
 	if !strings.Contains(rawURL, "://") {
-		if apiType == constants.REST || apiType == constants.GRAPHQL {
+		if apiType == constants.REST || apiType == constants.GRAPHQL || apiType == constants.GRPC {
 			rawURL = "http://" + rawURL
 		} else if apiType == constants.WS {
 			rawURL = "ws://" + rawURL
diff --git a/adapter/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml b/adapter/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml
index fc4e0a2a9f..c2a1453234 100644
--- a/adapter/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml
+++ b/adapter/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml
@@ -72,7 +72,7 @@ spec:
                 type: array
               apiType:
                 description: APIType denotes the type of the API. Possible values
-                  could be REST, GraphQL, Async
+                  could be REST, GraphQL, GRPC Async
                 enum:
                 - REST
                 type: string
@@ -244,10 +244,11 @@ spec:
                 type: array
               apiType:
                 description: APIType denotes the type of the API. Possible values
-                  could be REST, GraphQL, Async
+                  could be REST, GraphQL, GRPC Async
                 enum:
                 - REST
                 - GraphQL
+                - GRPC
                 type: string
               apiVersion:
                 description: APIVersion is the version number of the API.
diff --git a/adapter/internal/operator/controllers/dp/api_controller.go b/adapter/internal/operator/controllers/dp/api_controller.go
index 0c13b45700..4a18a7b58c 100644
--- a/adapter/internal/operator/controllers/dp/api_controller.go
+++ b/adapter/internal/operator/controllers/dp/api_controller.go
@@ -54,6 +54,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
 	gwapiv1 "sigs.k8s.io/gateway-api/apis/v1"
+	gwapiv1a2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gwapiv1b1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 
 	ctrl "sigs.k8s.io/controller-runtime"
@@ -67,6 +68,7 @@ import (
 )
 
 const (
+	grpcRouteAPIIndex = "grpcRouteAPIIndex"
 	httpRouteAPIIndex = "httpRouteAPIIndex"
 	gqlRouteAPIIndex  = "gqlRouteAPIIndex"
 	// apiAuthenticationIndex Index for API level authentications
@@ -79,6 +81,8 @@ const (
 	apiRateLimitResourceIndex = "apiRateLimitResourceIndex"
 	// gatewayHTTPRouteIndex Index for gateway httproutes
 	gatewayHTTPRouteIndex = "gatewayHTTPRouteIndex"
+	// gatewayGRPCRouteIndex Index for gateway grpcroutes
+	gatewayGRPCRouteIndex = "gatewayGRPCRouteIndex"
 	// apiAPIPolicyIndex Index for API level apipolicies
 	apiAPIPolicyIndex = "apiAPIPolicyIndex"
 	// apiAPIPolicyResourceIndex Index for resource level apipolicies
@@ -86,6 +90,7 @@ const (
 	serviceHTTPRouteIndex            = "serviceHTTPRouteIndex"
 	httprouteScopeIndex              = "httprouteScopeIndex"
 	gqlRouteScopeIndex               = "gqlRouteScopeIndex"
+	grpcRouteScopeIndex              = "grpcRouteScopeIndex"
 	configMapBackend                 = "configMapBackend"
 	configMapAPIDefinition           = "configMapAPIDefinition"
 	secretBackend                    = "secretBackend"
@@ -93,6 +98,7 @@ const (
 	secretAuthentication             = "secretAuthentication"
 	backendHTTPRouteIndex            = "backendHTTPRouteIndex"
 	backendGQLRouteIndex             = "backendGQLRouteIndex"
+	backendGRPCRouteIndex            = "backendGRPCRouteIndex"
 	interceptorServiceAPIPolicyIndex = "interceptorServiceAPIPolicyIndex"
 	backendInterceptorServiceIndex   = "backendInterceptorServiceIndex"
 	backendJWTAPIPolicyIndex         = "backendJWTAPIPolicyIndex"
@@ -157,6 +163,13 @@ func NewAPIController(mgr manager.Manager, operatorDataStore *synchronizer.Opera
 		return err
 	}
 
+	if err := c.Watch(source.Kind(mgr.GetCache(), &gwapiv1a2.GRPCRoute{}), handler.EnqueueRequestsFromMapFunc(apiReconciler.populateAPIReconcileRequestsForGRPCRoute),
+		predicates...); err != nil {
+		//TODO change the error number
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2667, logging.BLOCKER, "Error watching GRPCRoute resources: %v", err))
+		return err
+	}
+
 	if err := c.Watch(source.Kind(mgr.GetCache(), &gwapiv1b1.Gateway{}), handler.EnqueueRequestsFromMapFunc(apiReconciler.getAPIsForGateway),
 		predicates...); err != nil {
 		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2611, logging.BLOCKER, "Error watching API resources: %v", err))
@@ -232,6 +245,9 @@ func NewAPIController(mgr manager.Manager, operatorDataStore *synchronizer.Opera
 // +kubebuilder:rbac:groups=dp.wso2.com,resources=gqlroutes,verbs=get;list;watch;create;update;patch;delete
 // +kubebuilder:rbac:groups=dp.wso2.com,resources=gqlroutes/status,verbs=get;update;patch
 // +kubebuilder:rbac:groups=dp.wso2.com,resources=gqlroutes/finalizers,verbs=update
+// +kubebuilder:rbac:groups=dp.wso2.com,resources=grpcroutes,verbs=get;list;watch;create;update;patch;delete
+// +kubebuilder:rbac:groups=dp.wso2.com,resources=grpcroutes/status,verbs=get;update;patch
+// +kubebuilder:rbac:groups=dp.wso2.com,resources=grpcroutes/finalizers,verbs=update
 // +kubebuilder:rbac:groups=dp.wso2.com,resources=authentications,verbs=get;list;watch;create;update;patch;delete
 // +kubebuilder:rbac:groups=dp.wso2.com,resources=authentications/status,verbs=get;update;patch
 // +kubebuilder:rbac:groups=dp.wso2.com,resources=authentications/finalizers,verbs=update
@@ -419,6 +435,24 @@ func (apiReconciler *APIReconciler) resolveAPIRefs(ctx context.Context, api dpv1
 		}
 	}
 
+	//handle grpc apis
+	if len(prodRouteRefs) > 0 && apiState.APIDefinition.Spec.APIType == "GRPC" {
+		apiState.ProdGRPCRoute = &synchronizer.GRPCRouteState{}
+		if apiState.ProdGRPCRoute, err = apiReconciler.resolveGRPCRouteRefs(ctx, prodRouteRefs,
+			namespace, api); err != nil {
+			return nil, fmt.Errorf("error while resolving production grpcRouteref %s in namespace :%s has not found. %s",
+				prodRouteRefs, namespace, err.Error())
+		}
+	}
+	if len(sandRouteRefs) > 0 && apiState.APIDefinition.Spec.APIType == "GRPC" {
+		apiState.SandGRPCRoute = &synchronizer.GRPCRouteState{}
+		if apiState.SandGRPCRoute, err = apiReconciler.resolveGRPCRouteRefs(ctx, sandRouteRefs,
+			namespace, api); err != nil {
+			return nil, fmt.Errorf("error while resolving sandbox grpcRouteref %s in namespace :%s has not found. %s",
+				sandRouteRefs, namespace, err.Error())
+		}
+	}
+
 	// handle gql apis
 	if len(prodRouteRefs) > 0 && apiState.APIDefinition.Spec.APIType == "GraphQL" {
 		if apiState.ProdGQLRoute, err = apiReconciler.resolveGQLRouteRefs(ctx, prodRouteRefs, namespace,
@@ -495,6 +529,9 @@ func (apiReconciler *APIReconciler) resolveAPIRefs(ctx context.Context, api dpv1
 
 func isAPIPropagatable(apiState *synchronizer.APIState) bool {
 	validOrgs := []string{"carbon.super"}
+	if apiState.APIDefinition.Spec.APIType == "GRPC" {
+		return false
+	}
 	// System APIs should not be propagated to CP
 	if apiState.APIDefinition.Spec.SystemAPI {
 		return false
@@ -516,6 +553,16 @@ func (apiReconciler *APIReconciler) resolveGQLRouteRefs(ctx context.Context, gql
 	return &gqlRouteState, err
 }
 
+func (apiReconciler *APIReconciler) resolveGRPCRouteRefs(ctx context.Context, grpcRouteRefs []string,
+	namespace string, api dpv1alpha2.API) (*synchronizer.GRPCRouteState, error) {
+	grpcRouteState, err := apiReconciler.concatGRPCRoutes(ctx, grpcRouteRefs, namespace, api)
+	if err != nil {
+		return nil, err
+	}
+	grpcRouteState.Scopes, err = apiReconciler.getScopesForGRPCRoute(ctx, grpcRouteState.GRPCRouteCombined, api)
+	return &grpcRouteState, err
+}
+
 // resolveHTTPRouteRefs validates following references related to the API
 // - Authentications
 func (apiReconciler *APIReconciler) resolveHTTPRouteRefs(ctx context.Context, httpRouteState *synchronizer.HTTPRouteState,
@@ -534,7 +581,41 @@ func (apiReconciler *APIReconciler) resolveHTTPRouteRefs(ctx context.Context, ht
 
 	return httpRouteState, err
 }
+func (apiReconciler *APIReconciler) concatGRPCRoutes(ctx context.Context, grpcRouteRefs []string,
+	namespace string, api dpv1alpha2.API) (synchronizer.GRPCRouteState, error) {
+	grpcRouteState := synchronizer.GRPCRouteState{}
+	grpcRoutePartitions := make(map[string]*gwapiv1a2.GRPCRoute)
+	for _, grpcRouteRef := range grpcRouteRefs {
+		var grpcRoute gwapiv1a2.GRPCRoute
+		namespacedName := types.NamespacedName{Namespace: namespace, Name: grpcRouteRef}
+		if err := utils.ResolveRef(ctx, apiReconciler.client, &api, namespacedName, true, &grpcRoute); err != nil {
+			return grpcRouteState, fmt.Errorf("error while getting grpcroute %s in namespace :%s, %s", grpcRouteRef,
+				namespace, err.Error())
+		}
+		grpcRoutePartitions[namespacedName.String()] = &grpcRoute
+		if grpcRouteState.GRPCRouteCombined == nil {
+			grpcRouteState.GRPCRouteCombined = &grpcRoute
+		} else {
+			grpcRouteState.GRPCRouteCombined.Spec.Rules = append(grpcRouteState.GRPCRouteCombined.Spec.Rules,
+				grpcRoute.Spec.Rules...)
 
+		}
+	}
+	grpcRouteState.GRPCRoutePartitions = grpcRoutePartitions
+	backendNamespacedName := types.NamespacedName{
+		//TODO check if this is correct
+		Name:      string(grpcRouteState.GRPCRouteCombined.Spec.Rules[0].BackendRefs[0].BackendRef.Name),
+		Namespace: namespace,
+	}
+	resolvedBackend := utils.GetResolvedBackend(ctx, apiReconciler.client, backendNamespacedName, &api)
+	if resolvedBackend != nil {
+		grpcRouteState.BackendMapping = map[string]*dpv1alpha1.ResolvedBackend{
+			backendNamespacedName.String(): resolvedBackend,
+		}
+		return grpcRouteState, nil
+	}
+	return grpcRouteState, errors.New("error while resolving backend for grpcroute")
+}
 func (apiReconciler *APIReconciler) concatGQLRoutes(ctx context.Context, gqlRouteRefs []string,
 	namespace string, api dpv1alpha2.API) (synchronizer.GQLRouteState, error) {
 	gqlRouteState := synchronizer.GQLRouteState{}
@@ -623,7 +704,25 @@ func (apiReconciler *APIReconciler) getRatelimitPoliciesForAPI(ctx context.Conte
 	}
 	return ratelimitPolicies, nil
 }
-
+func (apiReconciler *APIReconciler) getScopesForGRPCRoute(ctx context.Context,
+	grpcRoute *gwapiv1a2.GRPCRoute, api dpv1alpha2.API) (map[string]dpv1alpha1.Scope, error) {
+	scopes := make(map[string]dpv1alpha1.Scope)
+	for _, rule := range grpcRoute.Spec.Rules {
+		for _, filter := range rule.Filters {
+			if filter.ExtensionRef != nil && filter.ExtensionRef.Kind == constants.KindScope {
+				scope := &dpv1alpha1.Scope{}
+				if err := utils.ResolveRef(ctx, apiReconciler.client, &api,
+					types.NamespacedName{Namespace: grpcRoute.Namespace, Name: string(filter.ExtensionRef.Name)}, false,
+					scope); err != nil {
+					return nil, fmt.Errorf("error while getting scope %s in namespace :%s, %s", filter.ExtensionRef.Name,
+						grpcRoute.Namespace, err.Error())
+				}
+				scopes[utils.NamespacedName(scope).String()] = *scope
+			}
+		}
+	}
+	return scopes, nil
+}
 func (apiReconciler *APIReconciler) getScopesForGQLRoute(ctx context.Context,
 	gqlRoute *dpv1alpha2.GQLRoute, api dpv1alpha2.API) (map[string]dpv1alpha1.Scope, error) {
 	scopes := make(map[string]dpv1alpha1.Scope)
@@ -876,6 +975,12 @@ func (apiReconciler *APIReconciler) populateAPIReconcileRequestsForHTTPRoute(ctx
 	return requests
 }
 
+func (apiReconciler *APIReconciler) populateAPIReconcileRequestsForGRPCRoute(ctx context.Context, obj k8client.Object) []reconcile.Request {
+	requests := apiReconciler.getAPIForGRPCRoute(ctx, obj)
+	apiReconciler.handleOwnerReference(ctx, obj, &requests)
+	return requests
+}
+
 func (apiReconciler *APIReconciler) populateAPIReconcileRequestsForConfigMap(ctx context.Context, obj k8client.Object) []reconcile.Request {
 	requests := apiReconciler.getAPIsForConfigMap(ctx, obj)
 	apiReconciler.handleOwnerReference(ctx, obj, &requests)
@@ -952,6 +1057,16 @@ func (apiReconciler *APIReconciler) traverseAPIStateAndUpdateOwnerReferences(ctx
 			apiReconciler.retriveParentAPIsAndUpdateOwnerReferene(ctx, gqlRoute)
 		}
 	}
+	if apiState.ProdGRPCRoute != nil {
+		for _, grpcRoute := range apiState.ProdGRPCRoute.GRPCRoutePartitions {
+			apiReconciler.retriveParentAPIsAndUpdateOwnerReferene(ctx, grpcRoute)
+		}
+	}
+	if apiState.SandGRPCRoute != nil {
+		for _, grpcRoute := range apiState.SandGRPCRoute.GRPCRoutePartitions {
+			apiReconciler.retriveParentAPIsAndUpdateOwnerReferene(ctx, grpcRoute)
+		}
+	}
 	for _, auth := range apiState.Authentications {
 		apiReconciler.retriveParentAPIsAndUpdateOwnerReferene(ctx, &auth)
 	}
@@ -1001,6 +1116,20 @@ func (apiReconciler *APIReconciler) traverseAPIStateAndUpdateOwnerReferences(ctx
 			}
 		}
 	}
+	if apiState.ProdGRPCRoute != nil {
+		for _, backend := range apiState.ProdGRPCRoute.BackendMapping {
+			if &backend != nil {
+				apiReconciler.retriveParentAPIsAndUpdateOwnerReferene(ctx, &backend.Backend)
+			}
+		}
+	}
+	if apiState.SandGRPCRoute != nil {
+		for _, backend := range apiState.SandGRPCRoute.BackendMapping {
+			if &backend != nil {
+				apiReconciler.retriveParentAPIsAndUpdateOwnerReferene(ctx, &backend.Backend)
+			}
+		}
+	}
 	for _, backendJwt := range apiState.BackendJWTMapping {
 		apiReconciler.retriveParentAPIsAndUpdateOwnerReferene(ctx, &backendJwt)
 	}
@@ -1142,6 +1271,16 @@ func (apiReconciler *APIReconciler) retriveParentAPIsAndUpdateOwnerReferene(ctx
 		}
 		requests = apiReconciler.getAPIForGQLRoute(ctx, &gqlRoute)
 		apiReconciler.handleOwnerReference(ctx, &gqlRoute, &requests)
+	case *gwapiv1a2.GRPCRoute:
+		var grpcRoute gwapiv1a2.GRPCRoute
+		namespaceName := types.NamespacedName{
+			Name:      string(obj.GetName()),
+			Namespace: string(obj.GetNamespace()),
+		}
+		if err := apiReconciler.client.Get(ctx, namespaceName, &grpcRoute); err != nil {
+			loggers.LoggerAPKOperator.Errorf("Unexpected error occured while loading the cr object from cluster %+v", err)
+			return
+		}
 	default:
 		loggers.LoggerAPKOperator.Errorf("Unexpected type found while processing owner reference %+v", obj)
 	}
@@ -1219,6 +1358,44 @@ func (apiReconciler *APIReconciler) getAPIForHTTPRoute(ctx context.Context, obj
 	return requests
 }
 
+// getAPIForGRPCRoute triggers the API controller reconcile method based on the changes detected
+// from GRPCRoute objects. If the changes are done for an API stored in the Operator Data store,
+// a new reconcile event will be created and added to the reconcile event queue.
+func (apiReconciler *APIReconciler) getAPIForGRPCRoute(ctx context.Context, obj k8client.Object) []reconcile.Request {
+	grpcRoute, ok := obj.(*gwapiv1a2.GRPCRoute)
+	if !ok {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2622, logging.TRIVIAL, "Unexpected object type, bypassing reconciliation: %v", grpcRoute))
+		return []reconcile.Request{}
+	}
+
+	apiList := &dpv1alpha2.APIList{}
+
+	if err := apiReconciler.client.List(ctx, apiList, &k8client.ListOptions{
+		FieldSelector: fields.OneTermEqualSelector(grpcRouteAPIIndex, utils.NamespacedName(grpcRoute).String()),
+	}); err != nil {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2623, logging.CRITICAL, "Unable to find associated APIs: %s", utils.NamespacedName(grpcRoute).String()))
+		return []reconcile.Request{}
+	}
+
+	if len(apiList.Items) == 0 {
+		loggers.LoggerAPKOperator.Debugf("APIs for GRPCRoute not found: %s", utils.NamespacedName(grpcRoute).String())
+		return []reconcile.Request{}
+	}
+
+	requests := []reconcile.Request{}
+	for _, api := range apiList.Items {
+		req := reconcile.Request{
+			NamespacedName: types.NamespacedName{
+				Name:      api.Name,
+				Namespace: api.Namespace},
+		}
+		requests = append(requests, req)
+		loggers.LoggerAPKOperator.Infof("Adding reconcile request for API: %s/%s with API UUID: %v", api.Namespace, api.Name,
+			string(api.ObjectMeta.UID))
+	}
+	return requests
+}
+
 // getAPIsForConfigMap triggers the API controller reconcile method based on the changes detected
 // in configMap resources.
 func (apiReconciler *APIReconciler) getAPIsForConfigMap(ctx context.Context, obj k8client.Object) []reconcile.Request {
@@ -1487,6 +1664,22 @@ func (apiReconciler *APIReconciler) getAPIsForScope(ctx context.Context, obj k8c
 		requests = append(requests, apiReconciler.getAPIForGQLRoute(ctx, &httpRoute)...)
 	}
 
+	grpcRouteList := &gwapiv1a2.GRPCRouteList{}
+	if err := apiReconciler.client.List(ctx, grpcRouteList, &k8client.ListOptions{
+		FieldSelector: fields.OneTermEqualSelector(grpcRouteScopeIndex, utils.NamespacedName(scope).String()),
+	}); err != nil {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2625, logging.CRITICAL, "Unable to find associated GRPCRoutes: %s", utils.NamespacedName(scope).String()))
+		return []reconcile.Request{}
+	}
+
+	if len(grpcRouteList.Items) == 0 {
+		loggers.LoggerAPKOperator.Debugf("GRPCRoutes for scope not found: %s", utils.NamespacedName(scope).String())
+	}
+	for item := range grpcRouteList.Items {
+		grpcRoute := grpcRouteList.Items[item]
+		requests = append(requests, apiReconciler.getAPIForGRPCRoute(ctx, &grpcRoute)...)
+	}
+
 	return requests
 }
 
@@ -1507,15 +1700,30 @@ func (apiReconciler *APIReconciler) getAPIsForBackend(ctx context.Context, obj k
 		return []reconcile.Request{}
 	}
 
+	grpcRouteList := &gwapiv1a2.GRPCRouteList{}
+	if err := apiReconciler.client.List(ctx, grpcRouteList, &k8client.ListOptions{
+		FieldSelector: fields.OneTermEqualSelector(backendGRPCRouteIndex, utils.NamespacedName(backend).String()),
+	}); err != nil {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2625, logging.CRITICAL, "Unable to find associated GRPCRoutes: %s", utils.NamespacedName(backend).String()))
+		return []reconcile.Request{}
+	}
+
 	if len(httpRouteList.Items) == 0 {
 		loggers.LoggerAPKOperator.Debugf("HTTPRoutes for Backend not found: %s", utils.NamespacedName(backend).String())
 	}
+	if len(grpcRouteList.Items) == 0 {
+		loggers.LoggerAPKOperator.Debugf("GRPCRoutes for Backend not found: %s", utils.NamespacedName(backend).String())
+	}
 
 	requests := []reconcile.Request{}
 	for item := range httpRouteList.Items {
 		httpRoute := httpRouteList.Items[item]
 		requests = append(requests, apiReconciler.getAPIForHTTPRoute(ctx, &httpRoute)...)
 	}
+	for item := range grpcRouteList.Items {
+		grpcRoute := grpcRouteList.Items[item]
+		requests = append(requests, apiReconciler.getAPIForGRPCRoute(ctx, &grpcRoute)...)
+	}
 
 	gqlRouteList := &dpv1alpha2.GQLRouteList{}
 	if err := apiReconciler.client.List(ctx, gqlRouteList, &k8client.ListOptions{
@@ -1570,17 +1778,33 @@ func (apiReconciler *APIReconciler) getAPIsForGateway(ctx context.Context, obj k
 		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2625, logging.CRITICAL, "Unable to find associated HTTPRoutes: %s", utils.NamespacedName(gateway).String()))
 		return []reconcile.Request{}
 	}
+	grpcRouteList := &gwapiv1a2.GRPCRouteList{}
+	if err := apiReconciler.client.List(ctx, grpcRouteList, &k8client.ListOptions{
+		FieldSelector: fields.OneTermEqualSelector(gatewayGRPCRouteIndex, utils.NamespacedName(gateway).String()),
+	}); err != nil {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2625, logging.CRITICAL, "Unable to find associated GRPCRoutes: %s", utils.NamespacedName(gateway).String()))
+		return []reconcile.Request{}
+	}
 
 	if len(httpRouteList.Items) == 0 {
 		loggers.LoggerAPKOperator.Debugf("HTTPRoutes for Gateway not found: %s", utils.NamespacedName(gateway).String())
 		return []reconcile.Request{}
 	}
+	if len(grpcRouteList.Items) == 0 {
+		loggers.LoggerAPKOperator.Debugf("GRPCRoutes for Gateway not found: %s", utils.NamespacedName(gateway).String())
+		return []reconcile.Request{}
+	}
 
 	requests := []reconcile.Request{}
 	for item := range httpRouteList.Items {
 		httpRoute := httpRouteList.Items[item]
 		requests = append(requests, apiReconciler.getAPIForHTTPRoute(ctx, &httpRoute)...)
 	}
+	for item := range grpcRouteList.Items {
+		grpcRoute := grpcRouteList.Items[item]
+		requests = append(requests, apiReconciler.getAPIForGRPCRoute(ctx, &grpcRoute)...)
+	}
+
 	return requests
 }
 
@@ -1656,6 +1880,40 @@ func addIndexes(ctx context.Context, mgr manager.Manager) error {
 		}); err != nil {
 		return err
 	}
+	if err := mgr.GetFieldIndexer().IndexField(ctx, &dpv1alpha2.API{}, grpcRouteAPIIndex,
+		func(rawObj k8client.Object) []string {
+			//check Spec.Kind
+			api := rawObj.(*dpv1alpha2.API)
+			if api.Spec.APIType != "GRPC" {
+				return nil
+			}
+			var grpcRoutes []string
+			if len(api.Spec.Production) > 0 {
+				for _, ref := range api.Spec.Production[0].RouteRefs {
+					if ref != "" {
+						grpcRoutes = append(grpcRoutes,
+							types.NamespacedName{
+								Namespace: api.Namespace,
+								Name:      ref,
+							}.String())
+					}
+				}
+			}
+			if len(api.Spec.Sandbox) > 0 {
+				for _, ref := range api.Spec.Sandbox[0].RouteRefs {
+					if ref != "" {
+						grpcRoutes = append(grpcRoutes,
+							types.NamespacedName{
+								Namespace: api.Namespace,
+								Name:      ref,
+							}.String())
+					}
+				}
+			}
+			return grpcRoutes
+		}); err != nil {
+		return err
+	}
 
 	if err := mgr.GetFieldIndexer().IndexField(ctx, &dpv1alpha2.API{}, configMapAPIDefinition,
 		func(rawObj k8client.Object) []string {
@@ -1734,6 +1992,27 @@ func addIndexes(ctx context.Context, mgr manager.Manager) error {
 		return err
 	}
 
+	// Backend to GRPCRoute indexer
+	if err := mgr.GetFieldIndexer().IndexField(ctx, &gwapiv1a2.GRPCRoute{}, backendGRPCRouteIndex,
+		func(rawObj k8client.Object) []string {
+			grpcRoute := rawObj.(*gwapiv1a2.GRPCRoute)
+			var backends []string
+			for _, rule := range grpcRoute.Spec.Rules {
+				for _, backendRef := range rule.BackendRefs {
+					if backendRef.Kind != nil && *backendRef.Kind == constants.KindBackend {
+						backends = append(backends, types.NamespacedName{
+							Namespace: utils.GetNamespace(backendRef.Namespace,
+								grpcRoute.ObjectMeta.Namespace),
+							Name: string(backendRef.Name),
+						}.String())
+					}
+				}
+			}
+			return backends
+		}); err != nil {
+		return err
+	}
+
 	// Backend to GQLRoute indexer
 	if err := mgr.GetFieldIndexer().IndexField(ctx, &dpv1alpha2.GQLRoute{}, backendGQLRouteIndex,
 		func(rawObj k8client.Object) []string {
@@ -1771,6 +2050,23 @@ func addIndexes(ctx context.Context, mgr manager.Manager) error {
 		return err
 	}
 
+	//Gateway to GRPCRoute indexer
+	if err := mgr.GetFieldIndexer().IndexField(ctx, &gwapiv1a2.GRPCRoute{}, gatewayGRPCRouteIndex,
+		func(rawObj k8client.Object) []string {
+			grpcRoute := rawObj.(*gwapiv1a2.GRPCRoute)
+			var gateways []string
+			for _, parentRef := range grpcRoute.Spec.ParentRefs {
+				gateways = append(gateways, types.NamespacedName{
+					Namespace: utils.GetNamespace(parentRef.Namespace,
+						grpcRoute.Namespace),
+					Name: string(parentRef.Name),
+				}.String())
+			}
+			return gateways
+		}); err != nil {
+		return err
+	}
+
 	// ConfigMap to Backend indexer
 	if err := mgr.GetFieldIndexer().IndexField(ctx, &dpv1alpha1.Backend{}, configMapBackend,
 		func(rawObj k8client.Object) []string {
diff --git a/adapter/internal/operator/synchronizer/api_state.go b/adapter/internal/operator/synchronizer/api_state.go
index 10e50c2235..cbf42bc2aa 100644
--- a/adapter/internal/operator/synchronizer/api_state.go
+++ b/adapter/internal/operator/synchronizer/api_state.go
@@ -20,6 +20,7 @@ package synchronizer
 import (
 	"github.com/wso2/apk/common-go-libs/apis/dp/v1alpha1"
 	"github.com/wso2/apk/common-go-libs/apis/dp/v1alpha2"
+	gwapiv1a2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	gwapiv1b1 "sigs.k8s.io/gateway-api/apis/v1beta1"
 )
 
@@ -32,6 +33,8 @@ type APIState struct {
 	SandHTTPRoute             *HTTPRouteState
 	ProdGQLRoute              *GQLRouteState
 	SandGQLRoute              *GQLRouteState
+	ProdGRPCRoute             *GRPCRouteState
+	SandGRPCRoute             *GRPCRouteState
 	Authentications           map[string]v1alpha2.Authentication
 	RateLimitPolicies         map[string]v1alpha1.RateLimitPolicy
 	ResourceAuthentications   map[string]v1alpha2.Authentication
@@ -64,3 +67,13 @@ type GQLRouteState struct {
 	BackendMapping     map[string]*v1alpha1.ResolvedBackend
 	Scopes             map[string]v1alpha1.Scope
 }
+
+// GRPCRouteState holds the state of the deployed grpcRoutes. This state is compared with
+// the state of the Kubernetes controller cache to detect updates.
+// +k8s:deepcopy-gen=true
+type GRPCRouteState struct {
+	GRPCRouteCombined   *gwapiv1a2.GRPCRoute
+	GRPCRoutePartitions map[string]*gwapiv1a2.GRPCRoute
+	BackendMapping      map[string]*v1alpha1.ResolvedBackend
+	Scopes              map[string]v1alpha1.Scope
+}
diff --git a/adapter/internal/operator/synchronizer/data_store.go b/adapter/internal/operator/synchronizer/data_store.go
index 9b3afab1da..8c2c23d4b7 100644
--- a/adapter/internal/operator/synchronizer/data_store.go
+++ b/adapter/internal/operator/synchronizer/data_store.go
@@ -18,6 +18,7 @@
 package synchronizer
 
 import (
+	gwapiv1a2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
 	"sync"
 
 	"github.com/wso2/apk/adapter/internal/loggers"
@@ -115,6 +116,23 @@ func (ods *OperatorDataStore) processAPIState(apiNamespacedName types.Namespaced
 		}
 		cachedAPI.ProdGQLRoute = nil
 	}
+	if apiState.ProdGRPCRoute != nil {
+		if cachedAPI.ProdGRPCRoute == nil {
+			cachedAPI.ProdGRPCRoute = apiState.ProdGRPCRoute
+			updated = true
+			events = append(events, "Production")
+		} else if routeEvents, routesUpdated := updateGRPCRoute(apiState.ProdGRPCRoute, cachedAPI.ProdGRPCRoute,
+			"Production"); routesUpdated {
+			updated = true
+			events = append(events, routeEvents...)
+		}
+	} else {
+		if cachedAPI.ProdGRPCRoute != nil {
+			updated = true
+			events = append(events, "Production")
+		}
+		cachedAPI.ProdGRPCRoute = nil
+	}
 	if apiState.SandHTTPRoute != nil {
 		if cachedAPI.SandHTTPRoute == nil {
 			cachedAPI.SandHTTPRoute = apiState.SandHTTPRoute
@@ -147,6 +165,22 @@ func (ods *OperatorDataStore) processAPIState(apiNamespacedName types.Namespaced
 		}
 		cachedAPI.SandGQLRoute = nil
 	}
+	if apiState.SandGRPCRoute != nil {
+		if cachedAPI.SandGRPCRoute == nil {
+			cachedAPI.SandGRPCRoute = apiState.SandGRPCRoute
+			updated = true
+			events = append(events, "Sandbox")
+		} else if routeEvents, routesUpdated := updateGRPCRoute(apiState.SandGRPCRoute, cachedAPI.SandGRPCRoute, "Sandbox"); routesUpdated {
+			updated = true
+			events = append(events, routeEvents...)
+		}
+	} else {
+		if cachedAPI.SandGRPCRoute != nil {
+			updated = true
+			events = append(events, "Sandbox")
+		}
+		cachedAPI.SandGRPCRoute = nil
+	}
 	if len(apiState.Authentications) != len(cachedAPI.Authentications) {
 		cachedAPI.Authentications = apiState.Authentications
 		cachedAPI.MutualSSL = apiState.MutualSSL
@@ -443,6 +477,61 @@ func updateGQLRoute(gqlRoute *GQLRouteState, cachedGQLRoute *GQLRouteState, endp
 	return events, updated
 }
 
+func updateGRPCRoute(grpcRoute *GRPCRouteState, cachedGRPCRoute *GRPCRouteState, endpointType string) ([]string, bool) {
+	var updated bool
+	events := []string{}
+	if cachedGRPCRoute.GRPCRouteCombined == nil || !isEqualGRPCRoutes(cachedGRPCRoute.GRPCRoutePartitions, grpcRoute.GRPCRoutePartitions) {
+		cachedGRPCRoute.GRPCRouteCombined = grpcRoute.GRPCRouteCombined
+		cachedGRPCRoute.GRPCRoutePartitions = grpcRoute.GRPCRoutePartitions
+		updated = true
+		events = append(events, endpointType+" Endpoint")
+	}
+
+	if len(grpcRoute.Scopes) != len(cachedGRPCRoute.Scopes) {
+		cachedGRPCRoute.Scopes = grpcRoute.Scopes
+		updated = true
+		events = append(events, "Resource Scopes")
+	} else {
+		for key, scope := range grpcRoute.Scopes {
+			if existingScope, found := cachedGRPCRoute.Scopes[key]; found {
+				if scope.UID != existingScope.UID || scope.Generation > existingScope.Generation {
+					cachedGRPCRoute.Scopes = grpcRoute.Scopes
+					updated = true
+					events = append(events, "Resource Scopes")
+					break
+				}
+			} else {
+				cachedGRPCRoute.Scopes = grpcRoute.Scopes
+				updated = true
+				events = append(events, "Resource Scopes")
+				break
+			}
+		}
+	}
+
+	if len(grpcRoute.BackendMapping) != len(cachedGRPCRoute.BackendMapping) {
+		cachedGRPCRoute.BackendMapping = grpcRoute.BackendMapping
+		updated = true
+		events = append(events, endpointType+" Backend Properties")
+	} else {
+		for key, backend := range grpcRoute.BackendMapping {
+			if existingBackend, found := cachedGRPCRoute.BackendMapping[key]; found {
+				if backend.Backend.UID != existingBackend.Backend.UID || backend.Backend.Generation > existingBackend.Backend.Generation {
+					cachedGRPCRoute.BackendMapping = grpcRoute.BackendMapping
+					updated = true
+					events = append(events, endpointType+" Backend Properties")
+					break
+				}
+			} else {
+				cachedGRPCRoute.BackendMapping = grpcRoute.BackendMapping
+				updated = true
+				events = append(events, endpointType+" Backend Properties")
+				break
+			}
+		}
+	}
+	return events, updated
+}
 func isEqualHTTPRoutes(cachedHTTPRoutes, newHTTPRoutes map[string]*gwapiv1b1.HTTPRoute) bool {
 	for key, cachedHTTPRoute := range cachedHTTPRoutes {
 		if newHTTPRoutes[key] == nil {
@@ -469,6 +558,19 @@ func isEqualGQLRoutes(cachedGQLRoutes, newGQLRoutes map[string]*dpv1alpha2.GQLRo
 	return true
 }
 
+func isEqualGRPCRoutes(cachedGRPCRoutes, newGRPCRoutes map[string]*gwapiv1a2.GRPCRoute) bool {
+	for key, cachedGRPCRoute := range cachedGRPCRoutes {
+		if newGRPCRoutes[key] == nil {
+			return false
+		}
+		if newGRPCRoutes[key].UID == cachedGRPCRoute.UID &&
+			newGRPCRoutes[key].Generation > cachedGRPCRoute.Generation {
+			return false
+		}
+	}
+	return true
+}
+
 // GetCachedAPI get cached apistate
 func (ods *OperatorDataStore) GetCachedAPI(apiName types.NamespacedName) (APIState, bool) {
 	if cachedAPI, found := ods.apiStore[apiName]; found {
diff --git a/adapter/internal/operator/synchronizer/grpc_api.go b/adapter/internal/operator/synchronizer/grpc_api.go
new file mode 100644
index 0000000000..26c0bd92c4
--- /dev/null
+++ b/adapter/internal/operator/synchronizer/grpc_api.go
@@ -0,0 +1,184 @@
+/*
+ *  Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org) All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+package synchronizer
+
+import (
+	"errors"
+	gwapiv1a2 "sigs.k8s.io/gateway-api/apis/v1alpha2"
+
+	"github.com/wso2/apk/adapter/config"
+	"github.com/wso2/apk/adapter/internal/dataholder"
+	"github.com/wso2/apk/adapter/internal/discovery/xds"
+	"github.com/wso2/apk/adapter/internal/discovery/xds/common"
+	"github.com/wso2/apk/adapter/internal/loggers"
+	"github.com/wso2/apk/adapter/internal/oasparser/model"
+	"github.com/wso2/apk/adapter/pkg/logging"
+	"k8s.io/apimachinery/pkg/types"
+	gwapiv1b1 "sigs.k8s.io/gateway-api/apis/v1beta1"
+)
+
+// extract APIDetails from the GQLRoute
+func updateInternalMapsFromGRPCRoute(apiState APIState, grpcRoute *GRPCRouteState, envType string) (*model.AdapterInternalAPI, map[string]struct{}, error) {
+	adapterInternalAPI, err := generateGRPCAdapterInternalAPI(apiState, grpcRoute, envType)
+	if err != nil {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2632, logging.MAJOR, "Error generating AdapterInternalAPI for GRPCRoute: %v. %v", grpcRoute.GRPCRouteCombined.Name, err))
+		return nil, nil, err
+	}
+
+	vHosts := getVhostsForGRPCAPI(grpcRoute.GRPCRouteCombined)
+	labels := getLabelsForGRPCAPI(grpcRoute.GRPCRouteCombined)
+	listeners, relativeSectionNames := getListenersForGRPCAPI(grpcRoute.GRPCRouteCombined, adapterInternalAPI.UUID)
+	// We dont have a use case where a perticular API's two different grpc routes refer to two different gateway. Hence get the first listener name for the list for processing.
+	if len(listeners) == 0 || len(relativeSectionNames) == 0 {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2633, logging.MINOR, "Failed to find a matching listener for grpc route: %v. ",
+			grpcRoute.GRPCRouteCombined.Name))
+		return nil, nil, errors.New("failed to find matching listener name for the provided grpc route")
+	}
+	listenerName := listeners[0]
+	sectionName := relativeSectionNames[0]
+
+	if len(listeners) > 0 {
+		if err := xds.PopulateInternalMaps(adapterInternalAPI, labels, vHosts, sectionName, listenerName); err != nil {
+			return nil, nil, err
+		}
+	}
+	return adapterInternalAPI, labels, nil
+}
+
+// generateGRPCAdapterInternalAPI this will populate a AdapterInternalAPI representation for an GRPCRoute
+func generateGRPCAdapterInternalAPI(apiState APIState, grpcRoute *GRPCRouteState, envType string) (*model.AdapterInternalAPI, error) {
+	var adapterInternalAPI model.AdapterInternalAPI
+	adapterInternalAPI.SetIsDefaultVersion(apiState.APIDefinition.Spec.IsDefaultVersion)
+	adapterInternalAPI.SetInfoAPICR(*apiState.APIDefinition)
+	adapterInternalAPI.SetAPIDefinitionFile(apiState.APIDefinitionFile)
+	adapterInternalAPI.SetAPIDefinitionEndpoint(apiState.APIDefinition.Spec.DefinitionPath)
+	adapterInternalAPI.SetSubscriptionValidation(apiState.SubscriptionValidation)
+	adapterInternalAPI.EnvType = envType
+
+	environment := apiState.APIDefinition.Spec.Environment
+	if environment == "" {
+		conf := config.ReadConfigs()
+		environment = conf.Adapter.Environment
+	}
+	adapterInternalAPI.SetEnvironment(environment)
+	adapterInternalAPI.SetXWso2RequestBodyPass(true)
+
+	resourceParams := model.ResourceParams{
+		AuthSchemes:               apiState.Authentications,
+		ResourceAuthSchemes:       apiState.ResourceAuthentications,
+		BackendMapping:            grpcRoute.BackendMapping,
+		APIPolicies:               apiState.APIPolicies,
+		ResourceAPIPolicies:       apiState.ResourceAPIPolicies,
+		ResourceScopes:            grpcRoute.Scopes,
+		InterceptorServiceMapping: apiState.InterceptorServiceMapping,
+		BackendJWTMapping:         apiState.BackendJWTMapping,
+		RateLimitPolicies:         apiState.RateLimitPolicies,
+		ResourceRateLimitPolicies: apiState.ResourceRateLimitPolicies,
+	}
+	if err := adapterInternalAPI.SetInfoGRPCRouteCR(grpcRoute.GRPCRouteCombined, resourceParams); err != nil {
+		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2631, logging.MAJOR, "Error setting GRPCRoute CR info to adapterInternalAPI. %v", err))
+		return nil, err
+	}
+	if apiState.MutualSSL != nil && apiState.MutualSSL.Required != "" && !adapterInternalAPI.GetDisableAuthentications() {
+		adapterInternalAPI.SetDisableMtls(apiState.MutualSSL.Disabled)
+		adapterInternalAPI.SetMutualSSL(apiState.MutualSSL.Required)
+		adapterInternalAPI.SetClientCerts(apiState.APIDefinition.Name, apiState.MutualSSL.ClientCertificates)
+	} else {
+		adapterInternalAPI.SetDisableMtls(true)
+	}
+
+	return &adapterInternalAPI, nil
+
+}
+
+// getVhostForAPI returns the vHosts related to an API.
+func getVhostsForGRPCAPI(grpcRoute *gwapiv1a2.GRPCRoute) map[string]struct{} {
+	vHosts := make(map[string]struct{})
+	for _, hostName := range grpcRoute.Spec.Hostnames {
+		vHosts[string(hostName)] = struct{}{}
+	}
+	return vHosts
+}
+
+// getLabelsForAPI returns the labels related to an API.
+func getLabelsForGRPCAPI(grpcRoute *gwapiv1a2.GRPCRoute) map[string]struct{} {
+	labels := make(map[string]struct{})
+	for _, parentRef := range grpcRoute.Spec.ParentRefs {
+		err := xds.SanitizeGateway(string(parentRef.Name), false)
+		if err != nil {
+			loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2653, logging.CRITICAL, "Gateway Label is invalid: %s", string(parentRef.Name)))
+		} else {
+			labels[string(parentRef.Name)] = struct{}{}
+		}
+	}
+	return labels
+}
+
+// getListenersForGRPCAPI returns the listeners related to an API.
+func getListenersForGRPCAPI(grpcRoute *gwapiv1a2.GRPCRoute, apiUUID string) ([]string, []string) {
+	var listeners []string
+	var sectionNames []string
+	for _, parentRef := range grpcRoute.Spec.ParentRefs {
+		namespace := grpcRoute.GetNamespace()
+		if parentRef.Namespace != nil && *parentRef.Namespace != "" {
+			namespace = string(*parentRef.Namespace)
+		}
+		gateway, found := dataholder.GetGatewayMap()[types.NamespacedName{
+			Namespace: namespace,
+			Name:      string(parentRef.Name),
+		}.String()]
+		if found {
+			// find the matching listener
+			matchedListener, listenerFound := common.FindElement(gateway.Spec.Listeners, func(listener gwapiv1b1.Listener) bool {
+				if string(listener.Name) == string(*parentRef.SectionName) {
+					return true
+				}
+				return false
+			})
+			if listenerFound {
+				sectionNames = append(sectionNames, string(matchedListener.Name))
+				listeners = append(listeners, common.GetEnvoyListenerName(string(matchedListener.Protocol), uint32(matchedListener.Port)))
+				continue
+			}
+		}
+		loggers.LoggerAPKOperator.Errorf("Failed to find matching listeners for the grpcroute: %+v", grpcRoute.Name)
+	}
+	return listeners, sectionNames
+}
+
+func deleteGRPCAPIFromEnv(grpcRoute *gwapiv1a2.GRPCRoute, apiState APIState) error {
+	labels := getLabelsForGRPCAPI(grpcRoute)
+	uuid := string(apiState.APIDefinition.ObjectMeta.UID)
+	return xds.DeleteAPI(uuid, labels)
+}
+
+// undeployGRPCAPIInGateway undeploys the related API in CREATE and UPDATE events.
+func undeployGRPCAPIInGateway(apiState APIState) error {
+	var err error
+	if apiState.ProdGRPCRoute != nil {
+		err = deleteGRPCAPIFromEnv(apiState.ProdGRPCRoute.GRPCRouteCombined, apiState)
+	}
+	if err != nil {
+		loggers.LoggerXds.ErrorC(logging.PrintError(logging.Error2630, logging.MAJOR, "Error undeploying prod grpcRoute of API : %v in Organization %v from environments."+
+			" Hence not checking on deleting the sand grpcRoute of the API", string(apiState.APIDefinition.ObjectMeta.UID), apiState.APIDefinition.Spec.Organization))
+		return err
+	}
+	if apiState.SandGRPCRoute != nil {
+		err = deleteGRPCAPIFromEnv(apiState.SandGRPCRoute.GRPCRouteCombined, apiState)
+	}
+	return err
+}
diff --git a/adapter/internal/operator/synchronizer/synchronizer.go b/adapter/internal/operator/synchronizer/synchronizer.go
index a61aa181ca..0ce9bbea73 100644
--- a/adapter/internal/operator/synchronizer/synchronizer.go
+++ b/adapter/internal/operator/synchronizer/synchronizer.go
@@ -117,12 +117,16 @@ func undeployAPIInGateway(apiEvent *APIEvent) error {
 	if apiState.APIDefinition.Spec.APIType == "GraphQL" {
 		err = undeployGQLAPIInGateway(apiState)
 	}
+	if apiState.APIDefinition.Spec.APIType == "GRPC" {
+		return undeployGRPCAPIInGateway(apiState)
+	}
 	if err != nil {
 		loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2629, logging.CRITICAL,
 			"API deployment failed for %s event : %v, %v", apiEvent.EventType, apiState.APIDefinition.Name, err))
 	} else if config.ReadConfigs().PartitionServer.Enabled {
 		paritionCh <- apiEvent
 	}
+
 	return nil
 }
 
@@ -199,6 +203,34 @@ func deployMultipleAPIsInGateway(event *APIEvent, successChannel *chan SuccessEv
 				}
 			}
 		}
+		if apiState.APIDefinition.Spec.APIType == "GRPC" {
+			if apiState.ProdGRPCRoute != nil {
+				_, updatedLabels, err := updateInternalMapsFromGRPCRoute(apiState, apiState.ProdGRPCRoute, constants.Production)
+				if err != nil {
+					loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2665, logging.CRITICAL,
+						"Error deploying prod grpcRoute of API : %v in Organization %v from environments %v. Error: %v",
+						string(apiState.APIDefinition.Spec.APIName), apiState.APIDefinition.Spec.Organization,
+						getLabelsForGRPCAPI(apiState.ProdGRPCRoute.GRPCRouteCombined), err))
+					continue
+				}
+				for label := range updatedLabels {
+					updatedLabelsMap[label] = struct{}{}
+				}
+			}
+			if apiState.SandGRPCRoute != nil {
+				_, updatedLabels, err := updateInternalMapsFromGRPCRoute(apiState, apiState.SandGRPCRoute, constants.Sandbox)
+				if err != nil {
+					loggers.LoggerAPKOperator.ErrorC(logging.PrintError(logging.Error2665, logging.CRITICAL,
+						"Error deploying sand grpcRoute of API : %v in Organization %v from environments %v. Error: %v",
+						string(apiState.APIDefinition.Spec.APIName), apiState.APIDefinition.Spec.Organization,
+						getLabelsForGRPCAPI(apiState.SandGRPCRoute.GRPCRouteCombined), err))
+					continue
+				}
+				for label := range updatedLabels {
+					updatedLabelsMap[label] = struct{}{}
+				}
+			}
+		}
 		updatedAPIs = append(updatedAPIs, utils.NamespacedName(apiState.APIDefinition))
 	}
 
@@ -254,6 +286,13 @@ func SendEventToPartitionServer() {
 				for _, hostName := range httpRoute.HTTPRouteCombined.Spec.Hostnames {
 					hostNames = append(hostNames, string(hostName))
 				}
+				grpcRoute := api.ProdGRPCRoute
+				if grpcRoute == nil {
+					grpcRoute = api.SandGRPCRoute
+				}
+				for _, hostName := range grpcRoute.GRPCRouteCombined.Spec.Hostnames {
+					hostNames = append(hostNames, string(hostName))
+				}
 				data := PartitionEvent{
 					EventType:    eventType,
 					BasePath:     basePath,
diff --git a/common-controller/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml b/common-controller/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml
index 304529c66f..a674ff1d2c 100644
--- a/common-controller/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml
+++ b/common-controller/internal/operator/config/crd/bases/dp.wso2.com_apis.yaml
@@ -247,6 +247,7 @@ spec:
                 enum:
                 - REST
                 - GraphQL
+                - GRPC
                 type: string
               apiVersion:
                 description: APIVersion is the version number of the API.
diff --git a/common-go-libs/apis/dp/v1alpha2/api_types.go b/common-go-libs/apis/dp/v1alpha2/api_types.go
index 4579e5e0b9..2943fa784c 100644
--- a/common-go-libs/apis/dp/v1alpha2/api_types.go
+++ b/common-go-libs/apis/dp/v1alpha2/api_types.go
@@ -80,16 +80,15 @@ type APISpec struct {
 	Sandbox []EnvConfig `json:"sandbox"`
 
 	// APIType denotes the type of the API.
-	// Possible values could be REST, GraphQL, Async
+	// Possible values could be REST, GraphQL, Async, GRPC etc.
 	//
-	// +kubebuilder:validation:Enum=REST;GraphQL
+	// +kubebuilder:validation:Enum=REST;GraphQL;GRPC
 	APIType string `json:"apiType"`
 
 	// BasePath denotes the basepath of the API.
 	// e.g: /pet-store-api/1.0.6
 	//
 	// +kubectl:validation:MaxLength=232
-	// +kubebuilder:validation:Pattern=^[/][a-zA-Z0-9~/_.-]*$
 	BasePath string `json:"basePath"`
 
 	// Organization denotes the organization.
diff --git a/common-go-libs/apis/dp/v1alpha2/api_webhook.go b/common-go-libs/apis/dp/v1alpha2/api_webhook.go
index 2e3348be35..67faddea5a 100644
--- a/common-go-libs/apis/dp/v1alpha2/api_webhook.go
+++ b/common-go-libs/apis/dp/v1alpha2/api_webhook.go
@@ -24,6 +24,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"regexp"
 	"strings"
 
 	gqlparser "github.com/vektah/gqlparser"
@@ -103,6 +104,8 @@ func (r *API) validateAPI() error {
 
 	if r.Spec.BasePath == "" {
 		allErrs = append(allErrs, field.Required(field.NewPath("spec").Child("basePath"), "API basePath is required"))
+	} else if errMsg := validateAPIBasePathRegex(r.Spec.BasePath, r.Spec.APIType); errMsg != "" {
+		allErrs = append(allErrs, field.Invalid(field.NewPath("spec").Child("basePath"), r.Spec.BasePath, errMsg))
 	} else if errMsg := validateAPIBasePathFormat(r.Spec.BasePath, r.Spec.APIVersion); errMsg != "" {
 		allErrs = append(allErrs, field.Invalid(field.NewPath("spec").Child("basePath"), r.Spec.BasePath, errMsg))
 	} else if err := r.validateAPIBasePathExistsAndDefaultVersion(); err != nil {
@@ -250,6 +253,23 @@ func validateAPIBasePathFormat(basePath string, apiVersion string) string {
 	return ""
 }
 
+func validateAPIBasePathRegex(basePath, apiType string) string {
+	var pattern string
+	if apiType == "GRPC" {
+		pattern = `^[/][a-zA-Z][a-zA-Z0-9_.]*$`
+	} else {
+		pattern = `^[/][a-zA-Z0-9~/_.-]*$`
+	}
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return "Failed to compile basePath regex pattern"
+	}
+	if !re.MatchString(basePath) {
+		return "API basePath is not in a valid format for the specified API type"
+	}
+	return ""
+}
+
 // getBasePathWithoutVersion returns the basePath without version
 func getBasePathWithoutVersion(basePath string) string {
 	lastIndex := strings.LastIndex(basePath, "/")
diff --git a/common-go-libs/config/crd/bases/dp.wso2.com_apis.yaml b/common-go-libs/config/crd/bases/dp.wso2.com_apis.yaml
index 7846de3caa..385c45e7e4 100644
--- a/common-go-libs/config/crd/bases/dp.wso2.com_apis.yaml
+++ b/common-go-libs/config/crd/bases/dp.wso2.com_apis.yaml
@@ -243,10 +243,11 @@ spec:
                 type: array
               apiType:
                 description: APIType denotes the type of the API. Possible values
-                  could be REST, GraphQL, Async
+                  could be REST, GraphQL, Async, GRPC etc.
                 enum:
                 - REST
                 - GraphQL
+                - GRPC
                 type: string
               apiVersion:
                 description: APIVersion is the version number of the API.
@@ -256,7 +257,6 @@ spec:
                 type: string
               basePath:
                 description: 'BasePath denotes the basepath of the API. e.g: /pet-store-api/1.0.6'
-                pattern: ^[/][a-zA-Z0-9~/_.-]*$
                 type: string
               definitionFileRef:
                 description: DefinitionFileRef contains the definition of the API
diff --git a/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/api/APIFactory.java b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/api/APIFactory.java
index 58c9c3dd28..0b21aaf781 100644
--- a/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/api/APIFactory.java
+++ b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/api/APIFactory.java
@@ -78,6 +78,11 @@ public void addApis(List<Api> apis) {
                 graphQLAPI.init(api);
                 String apiKey = getApiKey(graphQLAPI);
                 newApis.put(apiKey, graphQLAPI);
+             } else if (APIConstants.ApiType.GRPC.equals(api.getApiType())) {
+                  GRPCAPI grpcAPI = new GRPCAPI();
+                  grpcAPI.init(api);
+                  String apiKey = getApiKey(grpcAPI);
+                  newApis.put(apiKey, grpcAPI);
             } else {
                 RestAPI enforcerApi = new RestAPI();
                 enforcerApi.init(api);
@@ -133,6 +138,11 @@ public byte[] getAPIDefinition(final String basePath, final String version, fina
 
     public ResourceConfig getMatchedResource(API api, String matchedResourcePath, String method) {
         List<ResourceConfig> resourceConfigList = api.getAPIConfig().getResources();
+        if (APIConstants.ApiType.GRPC.equals(api.getAPIConfig().getApiType())) {
+            return resourceConfigList.stream()
+                    .filter(resourceConfig -> resourceConfig.getPath().equals(matchedResourcePath))
+                    .findFirst().orElse(null);
+        }
         return resourceConfigList.stream()
                 .filter(resourceConfig -> resourceConfig.getPath().equals(matchedResourcePath)).
                 filter(resourceConfig -> (method == null) || resourceConfig.getMethod()
diff --git a/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/api/GRPCAPI.java b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/api/GRPCAPI.java
new file mode 100644
index 0000000000..0ec44ae717
--- /dev/null
+++ b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/api/GRPCAPI.java
@@ -0,0 +1,212 @@
+package org.wso2.apk.enforcer.api;
+
+import graphql.schema.idl.SchemaParser;
+import graphql.schema.idl.TypeDefinitionRegistry;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.wso2.apk.enforcer.analytics.AnalyticsFilter;
+import org.wso2.apk.enforcer.commons.Filter;
+import org.wso2.apk.enforcer.commons.dto.ClaimValueDTO;
+import org.wso2.apk.enforcer.commons.dto.JWTConfigurationDto;
+import org.wso2.apk.enforcer.commons.model.APIConfig;
+import org.wso2.apk.enforcer.commons.model.ResourceConfig;
+import org.wso2.apk.enforcer.commons.model.EndpointSecurity;
+import org.wso2.apk.enforcer.commons.model.RequestContext;
+import org.wso2.apk.enforcer.commons.model.EndpointCluster;
+import org.wso2.apk.enforcer.config.ConfigHolder;
+import org.wso2.apk.enforcer.config.EnforcerConfig;
+import org.wso2.apk.enforcer.constants.APIConstants;
+import org.wso2.apk.enforcer.constants.HttpConstants;
+import org.wso2.apk.enforcer.cors.CorsFilter;
+import org.wso2.apk.enforcer.discovery.api.Api;
+import org.wso2.apk.enforcer.discovery.api.Resource;
+import org.wso2.apk.enforcer.discovery.api.Operation;
+import org.wso2.apk.enforcer.discovery.api.BackendJWTTokenInfo;
+import org.wso2.apk.enforcer.discovery.api.Claim;
+import org.wso2.apk.enforcer.security.AuthFilter;
+import org.wso2.apk.enforcer.security.mtls.MtlsUtils;
+import org.wso2.apk.enforcer.server.swagger.APIDefinitionUtils;
+import org.wso2.apk.enforcer.util.EndpointUtils;
+import org.wso2.apk.enforcer.util.FilterUtils;
+
+import java.io.IOException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class GRPCAPI implements  API{
+
+    private static final Logger logger = LogManager.getLogger(GRPCAPI.class);
+    private final List<Filter> filters = new ArrayList<>();
+    private APIConfig apiConfig;
+    @Override
+    public List<Filter> getFilters() {
+        return filters;
+    }
+
+    @Override
+    public String init(Api api) {
+        String vhost = api.getVhost();
+        String basePath = api.getBasePath();
+        String name = api.getTitle();
+        String version = api.getVersion();
+        String apiType = api.getApiType();
+        List<ResourceConfig> resources = new ArrayList<>();
+        Map<String, String> mtlsCertificateTiers = new HashMap<>();
+        String mutualSSL = api.getMutualSSL();
+        boolean applicationSecurity = api.getApplicationSecurity();
+
+        EndpointCluster endpoints = Utils.processEndpoints(api.getEndpoints());
+        EndpointSecurity[] endpointSecurity = APIProcessUtils.convertProtoEndpointSecurity(
+                api.getEndpointSecurityList());
+
+        for (Resource res : api.getResourcesList()) {
+            for (Operation operation : res.getMethodsList()) {
+                ResourceConfig resConfig = Utils.buildResource(operation, res.getPath(), endpointSecurity);
+                resConfig.setEndpoints(endpoints);
+                resConfig.setPolicyConfig(Utils.genPolicyConfig(operation.getPolicies()));
+                resources.add(resConfig);
+            }
+        }
+
+        KeyStore trustStore;
+        try {
+            trustStore = MtlsUtils.createTrustStore(api.getClientCertificatesList());
+        } catch (KeyStoreException e) {
+            throw new SecurityException(e);
+        }
+
+        BackendJWTTokenInfo backendJWTTokenInfo = api.getBackendJWTTokenInfo();
+        JWTConfigurationDto jwtConfigurationDto = new JWTConfigurationDto();
+
+        // If backendJWTTokeInfo is available
+        if (api.hasBackendJWTTokenInfo()) {
+            Map<String, Claim> claims = backendJWTTokenInfo.getCustomClaimsMap();
+            Map<String, ClaimValueDTO> claimsMap = new HashMap<>();
+            for (Map.Entry<String, Claim> claimEntry : claims.entrySet()) {
+                Claim claim = claimEntry.getValue();
+                ClaimValueDTO claimVal = new ClaimValueDTO(claim.getValue(), claim.getType());
+                claimsMap.put(claimEntry.getKey(), claimVal);
+            }
+            EnforcerConfig enforcerConfig = ConfigHolder.getInstance().getConfig();
+            jwtConfigurationDto.populateConfigValues(backendJWTTokenInfo.getEnabled(),
+                    backendJWTTokenInfo.getHeader(), backendJWTTokenInfo.getSigningAlgorithm(),
+                    backendJWTTokenInfo.getEncoding(), enforcerConfig.getJwtConfigurationDto().getPublicCert(),
+                    enforcerConfig.getJwtConfigurationDto().getPrivateKey(), backendJWTTokenInfo.getTokenTTL(),
+                    claimsMap, enforcerConfig.getJwtConfigurationDto().useKid(),
+                    enforcerConfig.getJwtConfigurationDto().getKidValue());
+        }
+
+
+        SchemaParser schemaParser = new SchemaParser();
+
+        byte[] apiDefinition = api.getApiDefinitionFile().toByteArray();
+        TypeDefinitionRegistry registry;
+
+
+        String apiLifeCycleState = api.getApiLifeCycleState();
+        this.apiConfig = new APIConfig.Builder(name).uuid(api.getId()).vhost(vhost).basePath(basePath).version(version)
+                .resources(resources).apiType(apiType).apiLifeCycleState(apiLifeCycleState).tier(api.getTier())
+                .envType(api.getEnvType()).disableAuthentication(api.getDisableAuthentications())
+                .disableScopes(api.getDisableScopes()).trustStore(trustStore).organizationId(api.getOrganizationId())
+                .mutualSSL(mutualSSL)
+                .applicationSecurity(applicationSecurity).jwtConfigurationDto(jwtConfigurationDto)
+                .apiDefinition(apiDefinition).environment(api.getEnvironment())
+                .environment(api.getEnvironment())
+                .subscriptionValidation(api.getSubscriptionValidation()).build();
+        initFilters();
+        logger.info("APIConfig: " + this.apiConfig);
+        return basePath;
+    }
+
+    @Override
+    public ResponseObject process(RequestContext requestContext) {
+
+        ResponseObject responseObject = new ResponseObject(requestContext.getRequestID());
+        responseObject.setRequestPath(requestContext.getRequestPath());
+        boolean analyticsEnabled = ConfigHolder.getInstance().getConfig().getAnalyticsConfig().isEnabled();
+
+        Utils.handleCommonHeaders(requestContext);
+        boolean isExistsMatchedOperations = requestContext.getMatchedResourcePaths() != null &&
+                requestContext.getMatchedResourcePaths().size() > 0;
+        // This flag is used to apply CORS filter
+        boolean isOptionCall = requestContext.getRequestMethod().contains(HttpConstants.OPTIONS);
+
+        // handle other not allowed && non option request && not yet handled error
+        // scenarios.
+        if ((!isOptionCall && !isExistsMatchedOperations) && !requestContext.getProperties()
+                .containsKey(APIConstants.MessageFormat.ERROR_CODE)) {
+            requestContext.getProperties()
+                    .put(APIConstants.MessageFormat.STATUS_CODE, APIConstants.StatusCodes.NOTFOUND.getCode());
+            requestContext.getProperties().put(APIConstants.MessageFormat.ERROR_CODE,
+                    APIConstants.StatusCodes.NOTFOUND.getValue());
+            requestContext.getProperties().put(APIConstants.MessageFormat.ERROR_MESSAGE,
+                    APIConstants.NOT_FOUND_MESSAGE);
+            requestContext.getProperties().put(APIConstants.MessageFormat.ERROR_DESCRIPTION,
+                    APIConstants.NOT_FOUND_DESCRIPTION);
+        }
+
+        if ((isExistsMatchedOperations || isOptionCall) && executeFilterChain(requestContext)) {
+            EndpointUtils.updateClusterHeaderAndCheckEnv(requestContext);
+            responseObject.setOrganizationId(requestContext.getMatchedAPI().getOrganizationId());
+            responseObject.setRemoveHeaderMap(requestContext.getRemoveHeaders());
+            responseObject.setQueryParamsToRemove(requestContext.getQueryParamsToRemove());
+            responseObject.setRemoveAllQueryParams(requestContext.isRemoveAllQueryParams());
+            responseObject.setQueryParamsToAdd(requestContext.getQueryParamsToAdd());
+            responseObject.setQueryParamMap(requestContext.getQueryParameters());
+            responseObject.setStatusCode(APIConstants.StatusCodes.OK.getCode());
+            if (requestContext.getAddHeaders() != null && requestContext.getAddHeaders().size() > 0) {
+                responseObject.setHeaderMap(requestContext.getAddHeaders());
+            }
+            if (analyticsEnabled) {
+                AnalyticsFilter.getInstance().handleSuccessRequest(requestContext);
+            }
+            // set metadata for interceptors
+            responseObject.setMetaDataMap(requestContext.getMetadataMap());
+        } else {
+            // If enforcer stops with a false, it will be passed directly to the client.
+            responseObject.setDirectResponse(true);
+            responseObject.setStatusCode(Integer.parseInt(
+                    requestContext.getProperties().get(APIConstants.MessageFormat.STATUS_CODE).toString()));
+            if (requestContext.getProperties().containsKey(APIConstants.MessageFormat.ERROR_CODE)) {
+                responseObject.setErrorCode(
+                        requestContext.getProperties().get(APIConstants.MessageFormat.ERROR_CODE).toString());
+            }
+            if (requestContext.getProperties().get(APIConstants.MessageFormat.ERROR_MESSAGE) != null) {
+                responseObject.setErrorMessage(requestContext.getProperties()
+                        .get(APIConstants.MessageFormat.ERROR_MESSAGE).toString());
+            }
+            if (requestContext.getProperties().get(APIConstants.MessageFormat.ERROR_DESCRIPTION) != null) {
+                responseObject.setErrorDescription(requestContext.getProperties()
+                        .get(APIConstants.MessageFormat.ERROR_DESCRIPTION).toString());
+            }
+            if (requestContext.getAddHeaders() != null && requestContext.getAddHeaders().size() > 0) {
+                responseObject.setHeaderMap(requestContext.getAddHeaders());
+            }
+            if (analyticsEnabled && !FilterUtils.isSkippedAnalyticsFaultEvent(responseObject.getErrorCode())) {
+                AnalyticsFilter.getInstance().handleFailureRequest(requestContext);
+                responseObject.setMetaDataMap(new HashMap<>(0));
+            }
+        }
+
+        return responseObject;
+    }
+
+    @Override
+    public APIConfig getAPIConfig() {
+        return this.apiConfig;
+    }
+
+    private void initFilters() {
+        AuthFilter authFilter = new AuthFilter();
+        authFilter.init(apiConfig, null);
+        this.filters.add(authFilter);
+
+        // CORS filter is added as the first filter, and it is not customizable.
+        CorsFilter corsFilter = new CorsFilter();
+        this.filters.add(0, corsFilter);
+    }
+}
diff --git a/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/constants/APIConstants.java b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/constants/APIConstants.java
index 348f291501..a911a06af1 100644
--- a/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/constants/APIConstants.java
+++ b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/constants/APIConstants.java
@@ -270,6 +270,7 @@ public static class ApiType {
 
         public static final String WEB_SOCKET = "WS";
         public static final String GRAPHQL = "GraphQL";
+        public static final String GRPC = "GRPC";
     }
 
     /**
diff --git a/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/server/swagger/SwaggerServerHandler.java b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/server/swagger/SwaggerServerHandler.java
index 16538f4d0f..04d6cd2200 100644
--- a/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/server/swagger/SwaggerServerHandler.java
+++ b/gateway/enforcer/org.wso2.apk.enforcer/src/main/java/org/wso2/apk/enforcer/server/swagger/SwaggerServerHandler.java
@@ -16,8 +16,11 @@
 import org.wso2.apk.enforcer.constants.AdminConstants;
 import org.wso2.apk.enforcer.constants.HttpConstants;
 import org.wso2.apk.enforcer.models.ResponsePayload;
+
 import java.util.HashMap;
 import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public class SwaggerServerHandler extends SimpleChannelInboundHandler<HttpObject> {
 
@@ -43,17 +46,34 @@ public void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Excep
 
         boolean isSwagger = false;
 
-        String [] params = request.uri().split("/");
-        final String basePath = "/" + params[1] + "/" + params[2];
-        final String vHost = params[3].split("\\?")[0];
-        final String queryParam = params[3].split("\\?")[1];
+        //check if it's GRPC request using the header
+        String header = request.headers().get("ApiType");
+        String[] params = request.uri().split("/");
+        final String basePath;
+        final String vHost;
+        final String queryParam;
+        final String version;
+        //if len params is 3, then it's a GRPC request else other
+        final String type = params.length == 3 ? "GRPC" : "REST";
+        if (type.equals("GRPC")) {
+            basePath = "/" + params[1];
+            vHost = params[2].split("\\?")[0];
+            queryParam = params[2].split("\\?")[1];
+            version = extractVersionFromGrpcBasePath(params[1]);
+        } else {
+            basePath = "/" + params[1] + "/" + params[2];
+            vHost = params[3].split("\\?")[0];
+            queryParam = params[3].split("\\?")[1];
+            version = params[2];
+        }
+
 
         if (APIDefinitionConstants.SWAGGER_DEFINITION.equalsIgnoreCase(queryParam)) {
             isSwagger = true;
         }
         if(isSwagger){
             // load the corresponding swagger definition from the API name
-            byte[] apiDefinition = apiFactory.getAPIDefinition(basePath, params[2], vHost);
+            byte[] apiDefinition = apiFactory.getAPIDefinition(basePath, version, vHost);
             if (apiDefinition == null || apiDefinition.length == 0) {
                 String error = AdminConstants.ErrorMessages.NOT_FOUND;
                 responsePayload = new ResponsePayload();
@@ -91,4 +111,15 @@ private void buildAndSendResponse(ChannelHandlerContext ctx, ResponsePayload res
         httpResponse.headers().set(HTTP.CONTENT_LEN, httpResponse.content().readableBytes());
         ctx.writeAndFlush(httpResponse);
     }
+
+    private static String extractVersionFromGrpcBasePath(String input) {
+        // Pattern to match '.v' followed by digits and optional periods followed by more digits
+        Pattern pattern = Pattern.compile("\\.v\\d+(\\.\\d+)*");
+        Matcher matcher = pattern.matcher(input);
+
+        if (matcher.find()) {
+            return matcher.group().substring(1); // Returns the matched version
+        }
+        return "";
+    }
 }
diff --git a/gateway/router/.gitignore b/gateway/router/.gitignore
new file mode 100644
index 0000000000..e47e1b33a7
--- /dev/null
+++ b/gateway/router/.gitignore
@@ -0,0 +1 @@
+/resources
diff --git a/helm-charts/templates/crds/dp.wso2.com_apis.yaml b/helm-charts/templates/crds/dp.wso2.com_apis.yaml
index 399c0c01fc..c398f39883 100644
--- a/helm-charts/templates/crds/dp.wso2.com_apis.yaml
+++ b/helm-charts/templates/crds/dp.wso2.com_apis.yaml
@@ -256,10 +256,11 @@ spec:
                 type: array
               apiType:
                 description: APIType denotes the type of the API. Possible values
-                  could be REST, GraphQL, Async
+                  could be REST, GraphQL, Async, GRPC etc.
                 enum:
                 - REST
                 - GraphQL
+                - GRPC
                 type: string
               apiVersion:
                 description: APIVersion is the version number of the API.
diff --git a/helm-charts/templates/serviceAccount/apk-cluster-role.yaml b/helm-charts/templates/serviceAccount/apk-cluster-role.yaml
index ccbb849a5d..428ce7abf8 100644
--- a/helm-charts/templates/serviceAccount/apk-cluster-role.yaml
+++ b/helm-charts/templates/serviceAccount/apk-cluster-role.yaml
@@ -24,7 +24,7 @@ rules:
     resources: ["services","configmaps","secrets"]
     verbs: ["get","list","watch","update","delete","create"]
   - apiGroups: ["gateway.networking.k8s.io"]
-    resources: ["httproutes","gateways","gatewayclasses"]
+    resources: ["httproutes","gateways","grpcroutes","gatewayclasses"]
     verbs: ["get","list","watch","update","delete","create"]
   - apiGroups: [ "gateway.networking.k8s.io" ]
     resources: [ "gateways/status","gatewayclasses/status","httproutes/status" ]
@@ -122,6 +122,15 @@ rules:
   - apiGroups: ["dp.wso2.com"]
     resources: ["gqlroutes/status"]
     verbs: ["get","patch","update"]
+  - apiGroups: ["dp.wso2.com"]
+    resources: ["grpcroutes"]
+    verbs: ["get","list","watch","update","delete","create"]
+  - apiGroups: ["dp.wso2.com"]
+    resources: ["grpcroutes/finalizers"]
+    verbs: ["update"]
+  - apiGroups: ["dp.wso2.com"]
+    resources: ["grpcroutes/status"]
+    verbs: ["get","patch","update"]
   - apiGroups: ["cp.wso2.com"]
     resources: ["applications"]
     verbs: ["get","list","watch","update","delete","create"]
diff --git a/runtime/config-deployer-service/ballerina/APIClient.bal b/runtime/config-deployer-service/ballerina/APIClient.bal
index 5fcdd78eec..549ae64233 100644
--- a/runtime/config-deployer-service/ballerina/APIClient.bal
+++ b/runtime/config-deployer-service/ballerina/APIClient.bal
@@ -46,7 +46,7 @@ public class APIClient {
             encodedString = encodedString.substring(0, encodedString.length() - 1);
         }
         APKConf apkConf = {
-            name: api.getName(),
+            name:  api.getType() == API_TYPE_GRPC ? self.getUniqueNameForGrpcApi(api.getName()) : api.getName(),
             basePath: api.getBasePath().length() > 0 ? api.getBasePath() : encodedString,
             version: api.getVersion(),
             'type: api.getType() == "" ? API_TYPE_REST : api.getType().toUpperAscii()
@@ -280,6 +280,14 @@ public class APIClient {
         return fullBasePath;
     }
 
+    isolated function returnFullGRPCBasePath(string basePath, string 'version) returns string {
+        string fullBasePath = basePath;
+        if (!string:endsWith(basePath, 'version)) {
+            fullBasePath = string:'join(".", basePath, 'version);
+        }
+        return fullBasePath;
+    }
+
     private isolated function constructURlFromK8sService(K8sService 'k8sService) returns string {
         return <string>k8sService.protocol + "://" + string:'join(".", <string>k8sService.name, <string>k8sService.namespace, "svc.cluster.local") + ":" + k8sService.port.toString();
     }
@@ -442,6 +450,19 @@ public class APIClient {
                     sandboxRoutes.push(gqlRoute.metadata.name);
                 }
             }
+        } else if apkConf.'type == API_TYPE_GRPC{
+            k8sAPI.spec.basePath =  self.returnFullGRPCBasePath(apkConf.basePath, apkConf.'version);
+            foreach model:GRPCRoute grpcRoute in apiArtifact.productionGrpcRoutes {
+                if grpcRoute.spec.rules.length() > 0 {
+                    productionRoutes.push(grpcRoute.metadata.name);
+                }
+            }
+            foreach model:GRPCRoute grpcRoute in apiArtifact.sandboxGrpcRoutes {
+                if grpcRoute.spec.rules.length() > 0 {
+                    sandboxRoutes.push(grpcRoute.metadata.name);
+                }
+            }
+
         } else {
             foreach model:HTTPRoute httpRoute in apiArtifact.productionHttpRoutes {
                 if httpRoute.spec.rules.length() > 0 {
@@ -532,6 +553,26 @@ public class APIClient {
                     apiArtifact.sandboxGqlRoutes.push(gqlRoute);
                 }
             }
+        } else if apkConf.'type == API_TYPE_GRPC {
+            model:GRPCRoute grpcRoute = {
+                metadata:
+                {
+                    name: uniqueId + "-" + endpointType + "-grpcroute-" + count.toString(),
+                    labels: self.getLabels(apkConf, organization)
+                },
+                spec: {
+                    parentRefs: self.generateAndRetrieveParentRefs(apkConf, uniqueId),
+                    rules: check self.generateGRPCRouteRules(apiArtifact, apkConf, endpoint, endpointType, organization),
+                    hostnames: self.getHostNames(apkConf, uniqueId, endpointType, organization)
+                }
+            };
+            if grpcRoute.spec.rules.length() > 0 {
+                if endpointType == PRODUCTION_TYPE {
+                    apiArtifact.productionGrpcRoutes.push(grpcRoute);
+                } else {
+                    apiArtifact.sandboxGrpcRoutes.push(grpcRoute);
+                }
+            }
         } else {
             model:HTTPRoute httpRoute = {
                 metadata:
@@ -553,10 +594,10 @@ public class APIClient {
                 }
             }
         }
-
         return;
     }
 
+
     private isolated function generateAndRetrieveParentRefs(APKConf apkConf, string uniqueId) returns model:ParentReference[] {
         string gatewayName = gatewayConfiguration.name;
         string listenerName = gatewayConfiguration.listenerName;
@@ -571,7 +612,7 @@ public class APIClient {
         APKOperations[]? operations = apkConf.operations;
         if operations is APKOperations[] {
             foreach APKOperations operation in operations {
-                model:HTTPRouteRule|model:GQLRouteRule|() routeRule = check self.generateRouteRule(apiArtifact, apkConf, endpoint, operation, endpointType, organization);
+                model:HTTPRouteRule|model:GQLRouteRule|model:GRPCRouteRule|() routeRule = check self.generateRouteRule(apiArtifact, apkConf, endpoint, operation, endpointType, organization);
                 if routeRule is model:HTTPRouteRule {
                     model:HTTPRouteFilter[]? filters = routeRule.filters;
                     if filters is () {
@@ -625,12 +666,72 @@ public class APIClient {
         return httpRouteRules;
     }
 
+    private isolated function generateGRPCRouteRules(model:APIArtifact apiArtifact, APKConf apkConf, model:Endpoint? endpoint, string endpointType, commons:Organization organization) returns model:GRPCRouteRule[]|commons:APKError|error {
+        model:GRPCRouteRule[] grpcRouteRules = [];
+        APKOperations[]? operations = apkConf.operations;
+        if operations is APKOperations[] {
+            foreach APKOperations operation in operations {
+                model:HTTPRouteRule|model:GQLRouteRule|model:GRPCRouteRule|() routeRule = check self.generateRouteRule(apiArtifact, apkConf, endpoint, operation, endpointType, organization);
+                if routeRule is model:GRPCRouteRule {
+                    model:GRPCRouteFilter[]? filters = routeRule.filters;
+                    if filters is () {
+                        filters = [];
+                        routeRule.filters = filters;
+                    }
+                    string disableAuthenticationRefName = self.retrieveDisableAuthenticationRefName(apkConf, endpointType, organization);
+                    if !(operation.secured ?: true) {
+                        if !apiArtifact.authenticationMap.hasKey(disableAuthenticationRefName) {
+                            model:Authentication generateDisableAuthenticationCR = self.generateDisableAuthenticationCR(apiArtifact, apkConf, endpointType, organization);
+                            apiArtifact.authenticationMap[disableAuthenticationRefName] = generateDisableAuthenticationCR;
+                        }
+                        model:GRPCRouteFilter disableAuthenticationFilter = {'type: "ExtensionRef", extensionRef: {group: "dp.wso2.com", kind: "Authentication", name: disableAuthenticationRefName}};
+                        (<model:GRPCRouteFilter[]>filters).push(disableAuthenticationFilter);
+                    }
+                    string[]? scopes = operation.scopes;
+                    if scopes is string[] {
+                        int count = 1;
+                        foreach string scope in scopes {
+                            model:Scope scopeCr;
+                            if apiArtifact.scopes.hasKey(scope) {
+                                scopeCr = apiArtifact.scopes.get(scope);
+                            } else {
+                                scopeCr = self.generateScopeCR(apiArtifact, apkConf, organization, scope, count);
+                                count = count + 1;
+                            }
+                            model:GRPCRouteFilter scopeFilter = {'type: "ExtensionRef", extensionRef: {group: "dp.wso2.com", kind: scopeCr.kind, name: scopeCr.metadata.name}};
+                            (<model:GRPCRouteFilter[]>filters).push(scopeFilter);
+                        }
+                    }
+                    if operation.rateLimit != () {
+                        model:RateLimitPolicy? rateLimitPolicyCR = self.generateRateLimitPolicyCR(apkConf, operation.rateLimit, apiArtifact.uniqueId, operation, organization);
+                        if rateLimitPolicyCR != () {
+                            apiArtifact.rateLimitPolicies[rateLimitPolicyCR.metadata.name] = rateLimitPolicyCR;
+                            model:GRPCRouteFilter rateLimitPolicyFilter = {'type: "ExtensionRef", extensionRef: {group: "dp.wso2.com", kind: "RateLimitPolicy", name: rateLimitPolicyCR.metadata.name}};
+                            (<model:GRPCRouteFilter[]>filters).push(rateLimitPolicyFilter);
+                        }
+                    }
+                    if operation.operationPolicies != () {
+                        model:APIPolicy? apiPolicyCR = check self.generateAPIPolicyAndBackendCR(apiArtifact, apkConf, operation, operation.operationPolicies, organization, apiArtifact.uniqueId);
+                        if apiPolicyCR != () {
+                            apiArtifact.apiPolicies[apiPolicyCR.metadata.name] = apiPolicyCR;
+                            model:GRPCRouteFilter apiPolicyFilter = {'type: "ExtensionRef", extensionRef: {group: "dp.wso2.com", kind: "APIPolicy", name: apiPolicyCR.metadata.name}};
+                            (<model:GRPCRouteFilter[]>filters).push(apiPolicyFilter);
+                        }
+                    }
+                    grpcRouteRules.push(routeRule);
+                }
+            }
+        }
+        return grpcRouteRules;
+    }
+    
+
     private isolated function generateGQLRouteRules(model:APIArtifact apiArtifact, APKConf apkConf, model:Endpoint? endpoint, string endpointType, commons:Organization organization) returns model:GQLRouteRule[]|commons:APKError|error {
         model:GQLRouteRule[] gqlRouteRules = [];
         APKOperations[]? operations = apkConf.operations;
         if operations is APKOperations[] {
             foreach APKOperations operation in operations {
-                model:HTTPRouteRule|model:GQLRouteRule|() routeRule = check self.generateRouteRule(apiArtifact, apkConf, endpoint, operation, endpointType, organization);
+                model:HTTPRouteRule|model:GQLRouteRule|model:GRPCRouteRule|() routeRule = check self.generateRouteRule(apiArtifact, apkConf, endpoint, operation, endpointType, organization);
                 if routeRule is model:GQLRouteRule {
                     model:GQLRouteFilter[]? filters = routeRule.filters;
                     if filters is () {
@@ -754,7 +855,7 @@ public class APIClient {
         return authentication;
     }
 
-    private isolated function generateRouteRule(model:APIArtifact apiArtifact, APKConf apkConf, model:Endpoint? endpoint, APKOperations operation, string endpointType, commons:Organization organization) returns model:HTTPRouteRule|model:GQLRouteRule|()|commons:APKError {
+    private isolated function generateRouteRule(model:APIArtifact apiArtifact, APKConf apkConf, model:Endpoint? endpoint, APKOperations operation, string endpointType, commons:Organization organization) returns model:HTTPRouteRule|model:GQLRouteRule|model:GRPCRouteRule|()|commons:APKError {
         do {
             EndpointConfigurations? endpointConfig = operation.endpointConfigurations;
             model:Endpoint? endpointToUse = ();
@@ -778,7 +879,16 @@ public class APIClient {
                     } else {
                         return e909022("Provided Type currently not supported for GraphQL APIs.", error("Provided Type currently not supported for GraphQL APIs."));
                     }
-                } else {
+                } else if apkConf.'type == API_TYPE_GRPC {
+                    model:GRPCRouteMatch[]|error routeMatches = self.retrieveGRPCMatches(apkConf, operation, organization);
+                    if routeMatches is model:GRPCRouteMatch[] && routeMatches.length() > 0 {
+                        model:GRPCRouteRule grpcRouteRule = {matches: routeMatches, backendRefs: self.retrieveGeneratedBackend(apkConf, endpointToUse, endpointType)};
+                        return grpcRouteRule;
+                    } else {
+                        return e909022("Provided Type currently not supported for GRPC APIs.", error("Provided Type currently not supported for GRPC APIs."));
+                    }
+                }
+                else {
                     model:HTTPRouteRule httpRouteRule = {matches: self.retrieveHTTPMatches(apkConf, operation, organization), backendRefs: self.retrieveGeneratedBackend(apkConf, endpointToUse, endpointType), filters: self.generateFilters(apiArtifact, apkConf, endpointToUse, operation, endpointType, organization)};
                     return httpRouteRule;
                 }
@@ -923,6 +1033,13 @@ public class APIClient {
         return gqlRouteMatch;
 
     }
+    
+    private isolated function retrieveGRPCMatches(APKConf apkConf, APKOperations apiOperation, commons:Organization organization) returns model:GRPCRouteMatch[] {
+        model:GRPCRouteMatch[] grpcRouteMatch = [];
+        model:GRPCRouteMatch grpcRoute = self.retrieveGRPCRouteMatch(apiOperation);
+        grpcRouteMatch.push(grpcRoute);
+        return grpcRouteMatch;
+    }
 
     private isolated function retrieveHttpRouteMatch(APKConf apkConf, APKOperations apiOperation, commons:Organization organization) returns model:HTTPRouteMatch {
         return {method: <string>apiOperation.verb, path: {'type: "RegularExpression", value: self.retrievePathPrefix(apkConf.basePath, apkConf.'version, apiOperation.target ?: "/*", organization)}};
@@ -937,6 +1054,17 @@ public class APIClient {
         }
     }
 
+    private isolated function retrieveGRPCRouteMatch(APKOperations apiOperation) returns model:GRPCRouteMatch {
+        model:GRPCRouteMatch grpcRouteMatch = {
+            method: {
+                'type: "Exact",
+                'service:  <string>apiOperation.target,
+                method: <string>apiOperation.verb
+            }
+        };
+        return grpcRouteMatch;
+    }
+
     isolated function retrieveGeneratedSwaggerDefinition(APKConf apkConf, string? definition) returns string|json|commons:APKError|error {
         runtimeModels:API api1 = runtimeModels:newAPI1();
         api1.setName(apkConf.name);
@@ -973,6 +1101,10 @@ public class APIClient {
             api1.setGraphQLSchema(definition);
             return definition;
         }
+        if apkConf.'type == API_TYPE_GRPC && definition is string {
+            api1.setProtoDefinition(definition);
+            return definition;
+        }
         if definition is string && definition.toString().trim().length() > 0 {
             retrievedDefinition = runtimeUtil:RuntimeAPICommonUtil_generateDefinition2(api1, definition);
         } else {
@@ -1547,6 +1679,11 @@ public class APIClient {
         return hashedValue.toBase16();
     }
 
+    public isolated function getUniqueNameForGrpcApi(string concatanatedServices) returns string {
+        byte[] hashedValue = crypto:hashSha1(concatanatedServices.toBytes());
+        return hashedValue.toBase16();
+    }
+
     public isolated function retrieveHttpRouteRefName(APKConf apkConf, string 'type, commons:Organization organization) returns string {
         return uuid:createType1AsString();
     }
@@ -1644,7 +1781,7 @@ public class APIClient {
                 } else if definitionFile.fileName.endsWith(".json") {
                     apiDefinition = definitionFileContent;
                 }
-            } else if apiType == API_TYPE_GRAPHQL {
+            } else if apiType == API_TYPE_GRAPHQL || apiType == API_TYPE_GRPC {
                 apiDefinition = definitionFileContent;
             }
             if apkConf is () {
diff --git a/runtime/config-deployer-service/ballerina/ConfigGenreatorClient.bal b/runtime/config-deployer-service/ballerina/ConfigGenreatorClient.bal
index e410cdb51d..5ca4070f1c 100644
--- a/runtime/config-deployer-service/ballerina/ConfigGenreatorClient.bal
+++ b/runtime/config-deployer-service/ballerina/ConfigGenreatorClient.bal
@@ -93,7 +93,7 @@ public class ConfigGeneratorClient {
     private isolated function validateAndRetrieveDefinition(string 'type, string? url, byte[]? content, string? fileName) returns runtimeapi:APIDefinitionValidationResponse|runtimeapi:APIManagementException|error|commons:APKError {
         runtimeapi:APIDefinitionValidationResponse|runtimeapi:APIManagementException|error validationResponse;
         boolean typeAvailable = 'type.length() > 0;
-        string[] ALLOWED_API_DEFINITION_TYPES = [API_TYPE_REST, API_TYPE_GRAPHQL, "ASYNC"];
+        string[] ALLOWED_API_DEFINITION_TYPES = [API_TYPE_REST, API_TYPE_GRAPHQL, "ASYNC",API_TYPE_GRPC];
         if !typeAvailable {
             return e909005("type");
         }
@@ -187,6 +187,14 @@ public class ConfigGeneratorClient {
             string yamlString = check self.convertJsonToYaml(gqlRoute.toJsonString());
             _ = check self.storeFile(yamlString, gqlRoute.metadata.name, zipDir);
         }
+        foreach model:GRPCRoute grpcRoute in apiArtifact.productionGrpcRoutes {
+            string yamlString = check self.convertJsonToYaml(grpcRoute.toJsonString());
+            _ = check self.storeFile(yamlString, grpcRoute.metadata.name, zipDir);
+        }
+        foreach model:GRPCRoute grpcRoute in apiArtifact.sandboxGrpcRoutes {
+            string yamlString = check self.convertJsonToYaml(grpcRoute.toJsonString());
+            _ = check self.storeFile(yamlString, grpcRoute.metadata.name, zipDir);
+        }
         foreach model:Backend backend in apiArtifact.backendServices {
             string yamlString = check self.convertJsonToYaml(backend.toJsonString());
             _ = check self.storeFile(yamlString, backend.metadata.name, zipDir);
diff --git a/runtime/config-deployer-service/ballerina/DeployerClient.bal b/runtime/config-deployer-service/ballerina/DeployerClient.bal
index e5beb5d2df..3bcfb20e6f 100644
--- a/runtime/config-deployer-service/ballerina/DeployerClient.bal
+++ b/runtime/config-deployer-service/ballerina/DeployerClient.bal
@@ -95,6 +95,7 @@ public class DeployerClient {
             apiArtifact.namespace = apiPartition.namespace;
             if existingAPI is model:API {
                 check self.deleteHttpRoutes(existingAPI, <string>apiArtifact?.organization);
+                check self.deleteGrpcRoutes(existingAPI, <string>apiArtifact?.organization);
                 check self.deleteAuthenticationCRs(existingAPI, <string>apiArtifact?.organization);
                 _ = check self.deleteScopeCrsForAPI(existingAPI, <string>apiArtifact?.organization);
                 check self.deleteBackends(existingAPI, <string>apiArtifact?.organization);
@@ -122,8 +123,8 @@ public class DeployerClient {
                     check self.deployBackendJWTConfigs(apiArtifact, ownerReference);
                     check self.deployAPIPolicyCRs(apiArtifact, ownerReference);
 
-                    check self.deployRoutes(apiArtifact.productionHttpRoutes, apiArtifact.productionGqlRoutes, <string>apiArtifact?.namespace, ownerReference);
-                    check self.deployRoutes(apiArtifact.sandboxHttpRoutes, apiArtifact.sandboxGqlRoutes, <string>apiArtifact?.namespace, ownerReference);
+                    check self.deployRoutes(apiArtifact.productionHttpRoutes, apiArtifact.productionGqlRoutes,apiArtifact.productionGrpcRoutes, <string>apiArtifact?.namespace, ownerReference);
+                    check self.deployRoutes(apiArtifact.sandboxHttpRoutes, apiArtifact.sandboxGqlRoutes,apiArtifact.sandboxGrpcRoutes, <string>apiArtifact?.namespace, ownerReference);
 
                     return deployK8sAPICrResult;
                 } on fail var e {
@@ -173,6 +174,30 @@ public class DeployerClient {
         }
     }
 
+    private isolated function deleteGrpcRoutes(model:API api, string organization) returns commons:APKError? {
+        do {
+            model:GRPCRouteList|http:ClientError grpcRouteListResponse = check getGrpcRoutesForAPIs(api.spec.apiName, api.spec.apiVersion, <string>api.metadata?.namespace, organization);
+            if grpcRouteListResponse is model:GRPCRouteList {
+                foreach model:GRPCRoute item in grpcRouteListResponse.items {
+                    http:Response|http:ClientError grpcRouteDeletionResponse = deleteGrpcRoute(item.metadata.name, <string>api.metadata?.namespace);
+                    if grpcRouteDeletionResponse is http:Response {
+                        if grpcRouteDeletionResponse.statusCode != http:STATUS_OK {
+                            json responsePayLoad = check grpcRouteDeletionResponse.getJsonPayload();
+                            model:Status statusResponse = check responsePayLoad.cloneWithType(model:Status);
+                            check self.handleK8sTimeout(statusResponse);
+                        }
+                    } else {
+                        log:printError("Error occured while deleting GrpcRoute", grpcRouteDeletionResponse);
+                    }
+                }
+                return;
+            }
+        } on fail var e {
+            log:printError("Error occured deleting grpcRoutes", e);
+            return e909022("Error occured deleting grpcRoutes", e);
+        }
+    }
+
     private isolated function deleteHttpRoutes(model:API api, string organization) returns commons:APKError? {
         do {
             model:HTTPRouteList|http:ClientError httpRouteListResponse = check getHttproutesForAPIS(api.spec.apiName, api.spec.apiVersion, <string>api.metadata?.namespace, organization);
@@ -312,8 +337,10 @@ public class DeployerClient {
                         model:StatusCause[] 'causes = details.'causes;
                         foreach model:StatusCause 'cause in 'causes {
                             if 'cause.'field == "spec.basePath" {
+                                log:printError("Error occured while updating K8sAPI due to basePath ", e909015(k8sAPI.spec.basePath));
                                 return e909015(k8sAPI.spec.basePath);
                             } else if 'cause.'field == "spec.apiName" {
+                                log:printError("Error occured while updating K8sAPI due to apiName ", e909016(k8sAPI.spec.apiName));
                                 return e909016(k8sAPI.spec.apiName);
                             }
                         }
@@ -349,7 +376,7 @@ public class DeployerClient {
             return e909022("Internal error occured", e = error("Internal error occured"));
         }
     }
-    private isolated function deployRoutes(model:HTTPRoute[]? httproutes, model:GQLRoute[]? gqlroutes, string namespace, model:OwnerReference ownerReference) returns error? {
+    private isolated function deployRoutes(model:HTTPRoute[]? httproutes, model:GQLRoute[]? gqlroutes,model:GRPCRoute[]? grpcroutes, string namespace, model:OwnerReference ownerReference) returns error? {
         if httproutes is model:HTTPRoute[] && httproutes.length() > 0 {
             model:HTTPRoute[] deployReadyHttproutes = httproutes;
             model:HTTPRoute[]|commons:APKError orderedHttproutes = self.createHttpRoutesOrder(httproutes);
@@ -408,6 +435,35 @@ public class DeployerClient {
                     }
                 }
             }
+        } else if grpcroutes is model:GRPCRoute[] && grpcroutes.length() > 0 {
+            model:GRPCRoute[] deployReadyGrpcRoutes = grpcroutes;
+            model:GRPCRoute[]|commons:APKError orderedGrpcRoutes = self.createGrpcRoutesOrder(grpcroutes);
+            if orderedGrpcRoutes is model:GRPCRoute[] {
+                deployReadyGrpcRoutes = orderedGrpcRoutes;
+            }
+            foreach model:GRPCRoute grpcRoute in deployReadyGrpcRoutes {
+                grpcRoute.metadata.ownerReferences = [ownerReference];
+                if grpcRoute.spec.rules.length() > 0 {
+                    http:Response deployGrpcRouteResult = check deployGrpcRoute(grpcRoute, namespace);
+                    if deployGrpcRouteResult.statusCode == http:STATUS_CREATED {
+                        log:printDebug("Deployed GrpcRoute Successfully" + grpcRoute.toString());
+                    } else if deployGrpcRouteResult.statusCode == http:STATUS_CONFLICT {
+                        log:printDebug("GrpcRoute already exists" + grpcRoute.toString());
+                        model:GRPCRoute grpcRouteFromK8s = check getGrpcRoute(grpcRoute.metadata.name, namespace);
+                        grpcRoute.metadata.resourceVersion = grpcRouteFromK8s.metadata.resourceVersion;
+                        http:Response grpcRouteCR = check updateGrpcRoute(grpcRoute, namespace);
+                        if grpcRouteCR.statusCode != http:STATUS_OK {
+                            json responsePayLoad = check grpcRouteCR.getJsonPayload();
+                            model:Status statusResponse = check responsePayLoad.cloneWithType(model:Status);
+                            check self.handleK8sTimeout(statusResponse);
+                        }
+                    } else {
+                        json responsePayLoad = check deployGrpcRouteResult.getJsonPayload();
+                        model:Status statusResponse = check responsePayLoad.cloneWithType(model:Status);
+                        check self.handleK8sTimeout(statusResponse);
+                    }
+                }
+            }
         }
     }
 
@@ -442,6 +498,21 @@ public class DeployerClient {
             return e909022("Error occured while sorting gqlRoutes", e);
         }
     }
+    public isolated function createGrpcRoutesOrder(model:GRPCRoute[] grpcRoutes) returns model:GRPCRoute[]|commons:APKError {
+        do {
+            foreach model:GRPCRoute route in grpcRoutes {
+                model:GRPCRouteRule[] routeRules = route.spec.rules;
+                model:GRPCRouteRule[] sortedRouteRules = from var routeRule in routeRules
+                    order by <string>(routeRule.matches[0].method.'service) descending
+                    select routeRule;
+                route.spec.rules = sortedRouteRules;
+            }
+            return grpcRoutes;
+        } on fail var e {
+            log:printError("Error occured while sorting grpcRoutes", e);
+            return e909022("Error occured while sorting grpcRoutes", e);
+        }
+    }
 
     private isolated function deployAuthenticationCRs(model:APIArtifact apiArtifact, model:OwnerReference ownerReference) returns error? {
         string[] keys = apiArtifact.authenticationMap.keys();
diff --git a/runtime/config-deployer-service/ballerina/K8sClient.bal b/runtime/config-deployer-service/ballerina/K8sClient.bal
index 5e7757206f..45723229a9 100644
--- a/runtime/config-deployer-service/ballerina/K8sClient.bal
+++ b/runtime/config-deployer-service/ballerina/K8sClient.bal
@@ -100,6 +100,16 @@ isolated function deleteGqlRoute(string name, string namespace) returns http:Res
     return k8sApiServerEp->delete(endpoint, targetType = http:Response);
 }
 
+isolated function getGrpcRoute(string name, string namespace) returns model:GRPCRoute|http:ClientError {
+    string endpoint = "/apis/gateway.networking.k8s.io/v1alpha2/namespaces/" + namespace + "/grpcroutes/" + name;
+    return k8sApiServerEp->get(endpoint, targetType = model:GRPCRoute);
+}
+
+isolated function deleteGrpcRoute(string name, string namespace) returns http:Response|http:ClientError {
+    string endpoint = "/apis/gateway.networking.k8s.io/v1alpha2/namespaces/" + namespace + "/grpcroutes/" + name;
+    return k8sApiServerEp->delete(endpoint, targetType = http:Response);
+}
+
 isolated function getConfigMap(string name, string namespace) returns model:ConfigMap|http:ClientError {
     string endpoint = "/api/v1/namespaces/" + namespace + "/configmaps/" + name;
     return k8sApiServerEp->get(endpoint, targetType = model:ConfigMap);
@@ -150,6 +160,16 @@ isolated function updateGqlRoute(model:GQLRoute gqlroute, string namespace) retu
     return k8sApiServerEp->put(endpoint, gqlroute, targetType = http:Response);
 }
 
+isolated function deployGrpcRoute(model:GRPCRoute grpcRoute, string namespace) returns http:Response|http:ClientError {
+    string endpoint = "/apis/gateway.networking.k8s.io/v1alpha2/namespaces/" + namespace + "/grpcroutes";
+    return k8sApiServerEp->post(endpoint, grpcRoute, targetType = http:Response);
+}
+
+isolated function updateGrpcRoute(model:GRPCRoute grpcRoute, string namespace) returns http:Response|http:ClientError {
+    string endpoint = "/apis/gateway.networking.k8s.io/v1alpha2/namespaces/" + namespace + "/grpcroutes/" + grpcRoute.metadata.name;
+    return k8sApiServerEp->put(endpoint, grpcRoute, targetType = http:Response);
+}
+
 public isolated function getK8sAPIByNameAndNamespace(string name, string namespace) returns model:API?|commons:APKError {
     string endpoint = "/apis/dp.wso2.com/v1alpha2/namespaces/" + namespace + "/apis/" + name;
     do {
@@ -244,7 +264,10 @@ public isolated function getGqlRoutesForAPIs(string apiName, string apiVersion,
     string endpoint = "/apis/dp.wso2.com/v1alpha2/namespaces/" + namespace + "/gqlroutes/?labelSelector=" + check generateUrlEncodedLabelSelector(apiName, apiVersion, organization);
     return k8sApiServerEp->get(endpoint, targetType = model:GQLRouteList);
 }
-
+public isolated function getGrpcRoutesForAPIs(string apiName, string apiVersion, string namespace, string organization) returns model:GRPCRouteList|http:ClientError|error {
+    string endpoint = "/apis/gateway.networking.k8s.io/v1alpha2/namespaces/" + namespace + "/grpcroutes/?labelSelector=" + check generateUrlEncodedLabelSelector(apiName, apiVersion, organization);
+    return k8sApiServerEp->get(endpoint, targetType = model:GRPCRouteList);
+}
 isolated function deployRateLimitPolicyCR(model:RateLimitPolicy rateLimitPolicy, string namespace) returns http:Response|http:ClientError {
     string endpoint = "/apis/dp.wso2.com/v1alpha1/namespaces/" + namespace + "/ratelimitpolicies";
     return k8sApiServerEp->post(endpoint, rateLimitPolicy, targetType = http:Response);
diff --git a/runtime/config-deployer-service/ballerina/constants.bal b/runtime/config-deployer-service/ballerina/constants.bal
index 66f523456b..ed2ad0f6fc 100644
--- a/runtime/config-deployer-service/ballerina/constants.bal
+++ b/runtime/config-deployer-service/ballerina/constants.bal
@@ -11,6 +11,7 @@ public final string[] WS_SUPPORTED_METHODS = ["subscribe", "publish"];
 
 const string API_TYPE_REST = "REST";
 const string API_TYPE_GRAPHQL = "GRAPHQL";
+const string API_TYPE_GRPC = "GRPC";
 const string API_TYPE_SOAP = "SOAP";
 const string API_TYPE_SSE = "SSE";
 const string API_TYPE_WS = "WS";
@@ -52,7 +53,7 @@ const string ENDPOINT_SECURITY_PASSWORD = "password";
 const string ZIP_FILE_EXTENSTION = ".zip";
 const string PROTOCOL_HTTP = "http";
 const string PROTOCOL_HTTPS = "https";
-final string[] & readonly ALLOWED_API_TYPES = [API_TYPE_REST, API_TYPE_GRAPHQL];
+final string[] & readonly ALLOWED_API_TYPES = [API_TYPE_REST, API_TYPE_GRAPHQL, API_TYPE_GRPC];
 
 const string MEDIATION_POLICY_TYPE_REQUEST_HEADER_MODIFIER = "RequestHeaderModifier";
 const string MEDIATION_POLICY_TYPE_RESPONSE_HEADER_MODIFIER = "ResponseHeaderModifier";
diff --git a/runtime/config-deployer-service/ballerina/modules/model/APIArtifact.bal b/runtime/config-deployer-service/ballerina/modules/model/APIArtifact.bal
index 7f272176aa..b40f954487 100644
--- a/runtime/config-deployer-service/ballerina/modules/model/APIArtifact.bal
+++ b/runtime/config-deployer-service/ballerina/modules/model/APIArtifact.bal
@@ -6,6 +6,8 @@ public type APIArtifact record {|
     HTTPRoute[] sandboxHttpRoutes = [];
     GQLRoute[] productionGqlRoutes = [];
     GQLRoute[] sandboxGqlRoutes = [];
+    GRPCRoute[] productionGrpcRoutes = [];
+    GRPCRoute[] sandboxGrpcRoutes = [];
     ConfigMap definition?;
     map<ConfigMap> endpointCertificates = {};
     map<string> certificateMap = {};
diff --git a/runtime/config-deployer-service/ballerina/modules/model/GRPCRoute.bal b/runtime/config-deployer-service/ballerina/modules/model/GRPCRoute.bal
new file mode 100644
index 0000000000..4087ea4856
--- /dev/null
+++ b/runtime/config-deployer-service/ballerina/modules/model/GRPCRoute.bal
@@ -0,0 +1,75 @@
+//
+// Copyright (c) 2024, WSO2 LLC. (http://www.wso2.com).
+//
+// WSO2 LLC. licenses this file to you under the Apache License,
+// Version 2.0 (the "License"); you may not use this file except
+// in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+
+public type GRPCRouteSpec record {
+    *CommonRouteSpec;
+    string[] hostnames?;
+    GRPCRouteRule[] rules = [];
+};
+
+public type GRPCRouteRule record {
+    GRPCRouteMatch[] matches;
+    GRPCRouteFilter[] filters?;
+    GRPCBackendRef[] backendRefs?;
+};
+public type GRPCRouteMatch record {
+    GRPCMethodMatch method;
+    GRPCHeaderMatch[] headers?;
+};
+
+public type GRPCHeaderMatch record {
+    string 'type;
+    string name;
+    string value;
+};
+
+public type GRPCMethodMatch record {
+    string 'type;
+    string 'service;
+    string method;
+};
+
+public type GRPCRouteFilter record {
+    string 'type;
+    HTTPHeaderFilter requestHeaderModifier?;
+    HTTPHeaderFilter responseHeaderModifier?;
+    HTTPRequestMirrorFilter requestMirror?;
+    LocalObjectReference extensionRef?;
+};
+
+public type GRPCBackendRef record {
+    *BackendRef;
+    GRPCRouteFilter[] filters?;
+};
+
+public type GRPCRoute record {|
+    string apiVersion = "gateway.networking.k8s.io/v1alpha2";
+    string kind = "GRPCRoute";
+    Metadata metadata;
+    GRPCRouteSpec spec;
+|};
+
+
+public type GRPCRouteList record {|
+    string apiVersion = "gateway.networking.k8s.io/v1alpha2";
+    string kind = "GRPCRouteList";
+    ListMeta metadata;
+    GRPCRoute[] items;
+|};
+
+
diff --git a/runtime/config-deployer-service/ballerina/modules/org.wso2.apk.config.model/API.bal b/runtime/config-deployer-service/ballerina/modules/org.wso2.apk.config.model/API.bal
index 8638e05bef..42470efc51 100644
--- a/runtime/config-deployer-service/ballerina/modules/org.wso2.apk.config.model/API.bal
+++ b/runtime/config-deployer-service/ballerina/modules/org.wso2.apk.config.model/API.bal
@@ -183,6 +183,13 @@ public distinct class API {
         org_wso2_apk_config_model_API_setGraphQLSchema(self.jObj, java:fromString(arg0));
     }
 
+    # The function that maps to the `setProtoDefinition` method of `org.wso2.apk.config.model.API`.
+    #
+    // # + arg0 - The `string` value required to map with the Java method parameter.
+    public isolated function setProtoDefinition(string arg0) {
+        org_wso2_apk_config_model_API_setProtoDefinition(self.jObj, java:fromString(arg0));
+    }
+
     # The function that maps to the `setName` method of `org.wso2.apk.config.model.API`.
     #
     # + arg0 - The `string` value required to map with the Java method parameter.
@@ -328,6 +335,13 @@ isolated function org_wso2_apk_config_model_API_getGraphQLSchema(handle receiver
     paramTypes: []
 } external;
 
+
+isolated function org_wso2_apk_config_model_API_getProtoDefinition(handle receiver) returns handle = @java:Method {
+    name: "getProtoDefinition",
+    'class: "org.wso2.apk.config.model.API",
+    paramTypes: []
+} external;
+
 isolated function org_wso2_apk_config_model_API_getName(handle receiver) returns handle = @java:Method {
     name: "getName",
     'class: "org.wso2.apk.config.model.API",
@@ -412,6 +426,12 @@ isolated function org_wso2_apk_config_model_API_setGraphQLSchema(handle receiver
     paramTypes: ["java.lang.String"]
 } external;
 
+isolated function org_wso2_apk_config_model_API_setProtoDefinition(handle receiver, handle arg0) = @java:Method {
+    name: "setProtoDefinition",
+    'class: "org.wso2.apk.config.model.API",
+    paramTypes: ["java.lang.String"]
+} external;
+
 isolated function org_wso2_apk_config_model_API_setName(handle receiver, handle arg0) = @java:Method {
     name: "setName",
     'class: "org.wso2.apk.config.model.API",
diff --git a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/APIConstants.java b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/APIConstants.java
index ed4a91e2a5..1fcaaadb0b 100644
--- a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/APIConstants.java
+++ b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/APIConstants.java
@@ -49,6 +49,7 @@ public final class APIConstants {
     public static final String OBJECT = "object";
 
     public static final String GRAPHQL_API = "GRAPHQL";
+    public static final String GRPC_API = "GRPC";
     public static final String APPLICATION_JSON_MEDIA_TYPE = "application/json";
 
     // registry location for OpenAPI files
@@ -90,7 +91,7 @@ public final class APIConstants {
     public static final String GRAPHQL_QUERY = "QUERY";
 
     public enum ParserType {
-        REST, ASYNC, GRAPHQL
+        REST, ASYNC, GRAPHQL, GRPC
     }
 
     public static class OperationParameter {
diff --git a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/DefinitionParserFactory.java b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/DefinitionParserFactory.java
index 8cfb710849..585e1010eb 100644
--- a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/DefinitionParserFactory.java
+++ b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/DefinitionParserFactory.java
@@ -21,7 +21,8 @@ private DefinitionParserFactory() {
 
     public static APIDefinition getParser(API api) {
         if (APIConstants.ParserType.REST.name().equals(api.getType())
-                || APIConstants.ParserType.GRAPHQL.name().equals(api.getType())) {
+                || APIConstants.ParserType.GRAPHQL.name().equals(api.getType())
+                || APIConstants.ParserType.GRPC.name().equals(api.getType())) {
             return new OAS3Parser();
         } else if (APIConstants.ParserType.ASYNC.name().equals(api.getType())) {
             return new AsyncApiParser();
diff --git a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/RuntimeAPICommonUtil.java b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/RuntimeAPICommonUtil.java
index 03f0433593..c93073e6dc 100644
--- a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/RuntimeAPICommonUtil.java
+++ b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/RuntimeAPICommonUtil.java
@@ -6,6 +6,7 @@
 import org.wso2.apk.config.api.ExceptionCodes;
 import org.wso2.apk.config.definitions.GraphQLSchemaDefinition;
 import org.wso2.apk.config.definitions.OASParserUtil;
+import org.wso2.apk.config.definitions.ProtoParser;
 import org.wso2.apk.config.model.API;
 import org.wso2.apk.config.model.URITemplate;
 
@@ -66,7 +67,18 @@ public static APIDefinitionValidationResponse validateOpenAPIDefinition(String t
                 OASParserUtil.addErrorToValidationResponse(validationResponse,
                         "Invalid definition file type provided.");
             }
+        } else if (APIConstants.ParserType.GRPC.name().equals(type.toUpperCase())) {
+            if (fileName.endsWith(".proto")) {
+                validationResponse = OASParserUtil.validateProtoDefinition(
+                        new String(inputByteArray, StandardCharsets.UTF_8),
+                        returnContent);
+            } else {
+                OASParserUtil.addErrorToValidationResponse(validationResponse,
+                        "Invalid definition file type provided.");
+            }
         }
+
+
         return validationResponse;
     }
 
@@ -99,6 +111,8 @@ public static API getAPIFromDefinition(String definition, String apiType) throws
 
         if (apiType.toUpperCase().equals(APIConstants.GRAPHQL_API)) {
             return getGQLAPIFromDefinition(definition);
+        } else if (apiType.toUpperCase().equals(APIConstants.GRPC_API)) {
+            return getGRPCAPIFromProtoDefinition(definition);
         } else {
             APIDefinition parser = DefinitionParserFactory.getParser(apiType);
             if (parser != null) {
@@ -128,6 +142,35 @@ private static API getGQLAPIFromDefinition(String definition) {
         return api;
     }
 
+    private static API getGRPCAPIFromProtoDefinition(String definition) {
+        ProtoParser protoParser = new ProtoParser(definition);
+        List<URITemplate> uriTemplates = new ArrayList<>();
+        API api = new API();
+        api.setBasePath("/"+protoParser.protoFile.basePath);
+        api.setVersion(protoParser.protoFile.version);
+        StringBuilder apiName = new StringBuilder();
+        List<String> sortedServices = new ArrayList<>();
+
+        for (ProtoParser.Service service : protoParser.getServices()) {
+            sortedServices.add(service.name);
+            for (String method : service.methods) {
+                URITemplate uriTemplate = new URITemplate();
+                uriTemplate.setUriTemplate(protoParser.protoFile.packageName + "." + service.name);
+                uriTemplate.setVerb(method);
+                uriTemplates.add(uriTemplate);
+            }
+        }
+        sortedServices.sort(String::compareTo);
+        for (String service : sortedServices) {
+            apiName.append(service).append("-");
+        }
+        apiName.deleteCharAt(apiName.length() - 1);
+        api.setName(apiName.toString());
+        api.setUriTemplates(uriTemplates.toArray(new URITemplate[uriTemplates.size()]));
+
+        return api;
+    }
+
     private RuntimeAPICommonUtil() {
 
     }
diff --git a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/api/ExceptionCodes.java b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/api/ExceptionCodes.java
index f24a3a2fe4..6324d87003 100644
--- a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/api/ExceptionCodes.java
+++ b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/api/ExceptionCodes.java
@@ -361,6 +361,10 @@ public enum ExceptionCodes implements ErrorHandler {
     UNSUPPORTED_GRAPHQL_FILE_EXTENSION(900802, "Unsupported GraphQL Schema File Extension", 400,
             "Unsupported extension. Only supported extensions are .graphql, .txt and .sdl"),
 
+    //GRPC API related codes
+    GRPC_PROTO_DEFINTION_CANNOT_BE_NULL(900803, "gRPC Proto Definition cannot be empty or null", 400,
+            "gRPC Proto Definition cannot be empty or null"),
+
     // Oauth related codes
     AUTH_GENERAL_ERROR(900900, "Authorization Error", 403, " Error in authorization"),
     INVALID_CREDENTIALS(900901, "Invalid Credentials", 401, " Invalid username or password"),
diff --git a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/definitions/OASParserUtil.java b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/definitions/OASParserUtil.java
index 66eae511c8..4ec23b7df6 100644
--- a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/definitions/OASParserUtil.java
+++ b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/definitions/OASParserUtil.java
@@ -668,6 +668,34 @@ public static APIDefinitionValidationResponse validateGraphQLSchema(String apiDe
         return validationResponse;
     }
 
+    /**
+     * Validate gRPC proto definition
+     *
+     * @return Validation response
+     */
+    public static APIDefinitionValidationResponse validateProtoDefinition(String apiDefinition,
+                                                                          boolean returnContent) {
+        APIDefinitionValidationResponse validationResponse = new APIDefinitionValidationResponse();
+        ArrayList<ErrorHandler> errors = new ArrayList<>();
+        try {
+            if (apiDefinition.isBlank()) {
+                validationResponse.setValid(false);
+                errors.add(ExceptionCodes.GRPC_PROTO_DEFINTION_CANNOT_BE_NULL);
+                validationResponse.setErrorItems(errors);
+            } else {
+                validationResponse.setValid(true);
+                validationResponse.setContent(apiDefinition);
+            }
+        } catch (Exception e) {
+            OASParserUtil.addErrorToValidationResponse(validationResponse, e.getMessage());
+            validationResponse.setValid(false);
+            errors.add(new ErrorItem("API Definition Validation Error", "API Definition is invalid", 400, 400));
+            validationResponse.setErrorItems(errors);
+        }
+        return validationResponse;
+
+    }
+
     /**
      * This method removes the unsupported json blocks from the given json string.
      *
diff --git a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/definitions/ProtoParser.java b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/definitions/ProtoParser.java
new file mode 100644
index 0000000000..2f371f420c
--- /dev/null
+++ b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/definitions/ProtoParser.java
@@ -0,0 +1,165 @@
+package org.wso2.apk.config.definitions;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ProtoParser {
+
+    public ProtoFile protoFile;
+    public ProtoParser(String content) {
+        protoFile = parseProtoContent(content);
+    }
+
+    public String getPackageString(String content) {
+        Pattern packagePattern = Pattern.compile("package\\s+([\\w\\.]+);");
+        Matcher packageMatcher = packagePattern.matcher(content);
+        if (packageMatcher.find()) {
+            return packageMatcher.group(1);
+        }
+        return null;
+    }
+    public String getVersion(String packageString) {
+        Pattern versionPattern = Pattern.compile("v\\d+(\\.\\d+)*");
+        Matcher versionMatcher = versionPattern.matcher(packageString);
+        if (versionMatcher.find()) {
+            return versionMatcher.group(0);
+        }
+        System.out.println("No version found");
+        return null;
+    }
+    public String getPackageName(String packageString){
+        Pattern namePattern = Pattern.compile("v\\d+(\\.\\d+)*\\.(\\w+)");
+        Matcher nameMatcher = namePattern.matcher(packageString);
+        if (nameMatcher.find()) {
+            return nameMatcher.group(2);
+        }
+        System.out.println("No name found");
+        return null;
+    }
+
+    public String getBasePath(String packageString){
+        Pattern basePathPattern = Pattern.compile("^(.*?)v\\d");
+
+        Matcher basePathMatcher = basePathPattern.matcher(packageString);
+        if (basePathMatcher.find()) {
+            String basePath =  basePathMatcher.group(1);
+            if(basePath.charAt(basePath.length()-1) == '.'){
+                basePath = basePath.substring(0, basePath.length()-1);
+            }
+            return basePath;
+        }
+        System.out.println("No base path found");
+        return null;
+    }
+
+    // Method to extract service blocks from a given text
+    public List<String> extractServiceBlocks(String text) {
+        // Regular expression pattern to match the service blocks
+        String patternString = "service\\s+\\w+\\s*\\{[^{}]*(?:\\{[^{}]*\\}[^{}]*)*\\}";
+
+        // Compile the regular expression
+        Pattern pattern = Pattern.compile(patternString, Pattern.DOTALL);
+        Matcher matcher = pattern.matcher(text);
+
+        // Find all matches and append them to the result
+        List<String> result = new ArrayList<>();
+        while (matcher.find()) {
+            result.add(matcher.group());
+        }
+        return result;
+    }
+
+    public List<String> extractMethodNames(String serviceBlock) {
+        // Regular expression pattern to match the method names
+        String patternString = "(?<=rpc\\s)\\w+";
+
+        // Compile the regular expression
+        Pattern pattern = Pattern.compile(patternString);
+        Matcher matcher = pattern.matcher(serviceBlock);
+
+        // Find all matches and append them to the result
+        List<String> result = new ArrayList<>();
+        while (matcher.find()) {
+            result.add(matcher.group());
+        }
+        return result;
+    }
+
+    public String getServiceName(String serviceBlock) {
+        // Regular expression pattern to match the service name
+        String patternString = "(?<=service\\s)\\w+";
+
+        // Compile the regular expression
+        Pattern pattern = Pattern.compile(patternString);
+        Matcher matcher = pattern.matcher(serviceBlock);
+
+        // Find the first match and return it
+        if (matcher.find()) {
+            return matcher.group();
+        }
+        return null;
+    }
+
+    public ProtoFile parseProtoContent(String content) {
+        ProtoFile protoFile = new ProtoFile();
+        protoFile.services = new ArrayList<>();
+
+        List<String> serviceBlocks = extractServiceBlocks(content);
+        for (String serviceBlock : serviceBlocks) {
+            Service service = new Service();
+            service.name = getServiceName(serviceBlock);
+            service.methods = new ArrayList<>();
+            service.methods.addAll(extractMethodNames(serviceBlock));
+            protoFile.services.add(service);
+        }
+
+        // Extract package name
+        String packageName = getPackageString(content);
+        protoFile.packageName = getPackageName(packageName);
+        protoFile.version = getVersion(packageName);
+        protoFile.basePath = getBasePath(packageName);
+
+//        System.out.println(protoFile);
+
+        return protoFile;
+    }
+
+    public List<String> getMethods(Service Service){
+        return Service.methods;
+    }
+    public List<Service> getServices(){
+        return this.protoFile.services;
+    }
+    public class ProtoFile {
+        public String packageName;
+        public String basePath;
+        public String version;
+        public List<Service> services;
+
+        @Override
+        public String toString() {
+            return "ProtoFile{" +
+                    "packageName='" + packageName + '\'' +
+                    ", basePath='" + basePath + '\'' +
+                    ", version='" + version + '\'' +
+                    ", services=" + services +
+                    '}';
+        }
+
+    }
+
+    public class Service {
+        public String name;
+        public List<String> methods;
+
+        @Override
+        public String toString() {
+            return " Service{" +
+                    "name='" + name + '\'' +
+                    ", methods=" + methods +
+                    '}';
+        }
+    }
+}
\ No newline at end of file
diff --git a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/model/API.java b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/model/API.java
index d2715d77b2..a88c2508fa 100644
--- a/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/model/API.java
+++ b/runtime/config-deployer-service/java/src/main/java/org/wso2/apk/config/model/API.java
@@ -11,6 +11,7 @@ public class API {
     private String apiSecurity;
     private String[] scopes;
     private String graphQLSchema;
+    private String protoDefinition;
     private String swaggerDefinition;
     private String environment;
 
@@ -79,6 +80,13 @@ public void setGraphQLSchema(String graphQLSchema) {
         this.graphQLSchema = graphQLSchema;
     }
 
+    public void setProtoDefinition(String protoDefinition) {
+        this.protoDefinition = protoDefinition;
+    }
+
+    public String getProtoDefinition() {
+        return protoDefinition;
+    }
     public String getSwaggerDefinition() {
         return swaggerDefinition;
     }
diff --git a/test/cucumber-tests/CRs/artifacts.yaml b/test/cucumber-tests/CRs/artifacts.yaml
index cf592dad81..0ee441c99d 100644
--- a/test/cucumber-tests/CRs/artifacts.yaml
+++ b/test/cucumber-tests/CRs/artifacts.yaml
@@ -1154,3 +1154,51 @@ spec:
       protocol: TCP
   selector:
     app: graphql-faker
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: grpc-backend
+  namespace: apk-integration-test
+spec:
+  selector:
+    app: grpc-backend
+  ports:
+    - protocol: TCP
+      port: 6565
+      targetPort: 6565
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: grpc-backend
+  namespace: apk-integration-test
+  labels:
+    app: grpc-backend
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: grpc-backend
+  template:
+    metadata:
+      labels:
+        app: grpc-backend
+    spec:
+      containers:
+        - name: grpc-backend
+          image: ddh13/dineth-grpc-demo-server:1.0.0
+          imagePullPolicy: Always
+          env:
+            - name: POD_NAME
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.name
+            - name: NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+          resources:
+            requests:
+              cpu: 10m
+---
\ No newline at end of file
diff --git a/test/cucumber-tests/build.gradle b/test/cucumber-tests/build.gradle
index 1e348b543e..decdfb1caa 100644
--- a/test/cucumber-tests/build.gradle
+++ b/test/cucumber-tests/build.gradle
@@ -35,6 +35,11 @@ dependencies {
     testImplementation 'io.cucumber:cucumber-testng:7.13.0'
     testImplementation 'commons-io:commons-io:2.13.0'
     testImplementation 'com.nimbusds:nimbus-jose-jwt:9.31'
+    implementation 'javax.annotation:javax.annotation-api:1.3.2'
+    implementation 'io.grpc:grpc-netty:1.48.0'
+    implementation 'io.grpc:grpc-protobuf:1.48.0'
+    implementation 'io.grpc:grpc-stub:1.48.0'
+    implementation 'io.grpc:grpc-auth:1.48.0'
 }
 
 test {
diff --git a/test/cucumber-tests/scripts/setup-hosts.sh b/test/cucumber-tests/scripts/setup-hosts.sh
index 5fb4512483..2f541a7b50 100644
--- a/test/cucumber-tests/scripts/setup-hosts.sh
+++ b/test/cucumber-tests/scripts/setup-hosts.sh
@@ -6,6 +6,7 @@ kubectl wait deployment/backend-retry-deployment -n apk-integration-test --for=c
 kubectl wait deployment/dynamic-backend -n apk-integration-test --for=condition=available --timeout=600s
 kubectl wait deployment/interceptor-service-deployment -n apk-integration-test --for=condition=available --timeout=600s
 kubectl wait deployment/graphql-faker -n apk-integration-test --for=condition=available --timeout=600s
+kubectl wait deployment/grpc-backend -n apk-integration-test --for=condition=available --timeout=600s
 kubectl wait --timeout=5m -n apk-integration-test deployment/apk-test-setup-wso2-apk-adapter-deployment --for=condition=Available
 kubectl wait --timeout=15m -n apk-integration-test deployment/apk-test-setup-wso2-apk-gateway-runtime-deployment --for=condition=Available
 IP=$(kubectl get svc apk-test-setup-wso2-apk-gateway-service -n apk-integration-test --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/BaseSteps.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/BaseSteps.java
index bdc423ec6f..faf39122f5 100644
--- a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/BaseSteps.java
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/BaseSteps.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, WSO2 LLC (http://www.wso2.com).
+ * Copyright (c) 2024, WSO2 LLC (http://www.wso2.com).
  *
  * WSO2 LLC licenses this file to you under the Apache License,
  * Version 2.0 (the "License"); you may not use this file except
@@ -39,6 +39,8 @@
 import io.cucumber.java.Before;
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -49,7 +51,9 @@
 import org.testng.Assert;
 import org.wso2.apk.integration.utils.Constants;
 import org.wso2.apk.integration.utils.Utils;
+import org.wso2.apk.integration.utils.clients.SimpleGRPCStudentClient;
 import org.wso2.apk.integration.utils.clients.SimpleHTTPClient;
+import org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentResponse;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -92,10 +96,27 @@ public void systemIsReady() {
 
     }
 
+    @Then("the student response body should contain name: {string} age: {int}")
+    public void theStudentResponseBodyShouldContainNameAndAge(String arg0, int arg1) {
+        StudentResponse studentResponse = sharedContext.getStudentResponse();
+        if (studentResponse == null) {
+            Assert.fail("Student response is null.");
+        }
+        int age = studentResponse.getAge();
+        String name = studentResponse.getName();
+        Assert.assertEquals(name, arg0);
+        Assert.assertEquals(age, arg1);
+    }
+
     @Then("the response body should contain {string}")
     public void theResponseBodyShouldContain(String expectedText) throws IOException {
         Assert.assertTrue(sharedContext.getResponseBody().contains(expectedText), "Actual response body: " + sharedContext.getResponseBody());
     }
+    @Then("the response body should contain endpoint definition for student.proto")
+    public void theResponseBodyShouldContainEndpointDefinition() throws IOException {
+        String expectedText = "{\"apiDefinition\":\"syntax = \\\"proto3\\\";\\n\\noption java_multiple_files = true;\\noption java_package = \\\"org.example\\\";\\npackage dineth.grpc.api.v1.student;\\n\\nservice StudentService {\\n  rpc GetStudent(StudentRequest) returns (StudentResponse) {};\\n  rpc GetStudentStream(StudentRequest) returns (stream StudentResponse) {};\\n  rpc SendStudentStream(stream StudentRequest) returns (StudentResponse) {};\\n  rpc SendAndGetStudentStream(stream StudentRequest) returns (stream StudentResponse) {}\\n}\\n\\nmessage StudentRequest {\\n  int32 id = 3;\\n}\\n\\nmessage StudentResponse {\\n  string name = 1;\\n  int32 age = 2;\\n}\\n\"}";
+        Assert.assertTrue(sharedContext.getResponseBody().contains(expectedText), "Actual response body: " + sharedContext.getResponseBody());
+    }
     @Then("the response body should not contain {string}")
     public void theResponseBodyShouldNotContain(String expectedText) throws IOException {
         Assert.assertFalse(sharedContext.getResponseBody().contains(expectedText), "Actual response body: " + sharedContext.getResponseBody());
@@ -116,6 +137,12 @@ public void theResponseStatusCodeShouldBe(int expectedStatusCode) throws IOExcep
         Assert.assertEquals(actualStatusCode, expectedStatusCode);
     }
 
+    @Then("the gRPC response status code should be {int}")
+    public void theGrpcResponseStatusCodeShouldBe(int expectedStatusCode) throws IOException {
+        int actualStatusCode = sharedContext.getGrpcStatusCode();
+        Assert.assertEquals(actualStatusCode, expectedStatusCode);
+    }
+
     @Then("I send {string} request to {string} with body {string}")
     public void sendHttpRequest(String httpMethod, String url, String body) throws IOException {
         body = Utils.resolveVariables(body, sharedContext.getValueStore());
@@ -139,6 +166,30 @@ public void sendHttpRequest(String httpMethod, String url, String body) throws I
         }
     }
 
+    @Then("I make grpc request GetStudent to {string} with port {int}")
+    public void GetStudent(String arg0, int arg1) throws StatusRuntimeException {
+        try {
+            SimpleGRPCStudentClient grpcStudentClient = new SimpleGRPCStudentClient(arg0, arg1);
+            sharedContext.setStudentResponse(grpcStudentClient.GetStudent(sharedContext.getHeaders()));
+            sharedContext.setGrpcStatusCode(0);
+        } catch (StatusRuntimeException e) {
+                sharedContext.setGrpcStatusCode(e.getStatus().getCode().value());
+                logger.error(e.getMessage() + " Status code: " + e.getStatus().getCode().value()) ;
+        }
+    }
+
+    @Then("I make grpc request GetStudent default version to {string} with port {int}")
+    public void GetStudentDefaultVersion(String arg0, int arg1) throws StatusRuntimeException {
+        try {
+            SimpleGRPCStudentClient grpcStudentClient = new SimpleGRPCStudentClient(arg0, arg1);
+            sharedContext.setStudentResponse(grpcStudentClient.GetStudentDefaultVersion(sharedContext.getHeaders()));
+            sharedContext.setGrpcStatusCode(0);
+        } catch (StatusRuntimeException e) {
+            sharedContext.setGrpcStatusCode(e.getStatus().getCode().value());
+            logger.error(e.getMessage() + " Status code: " + e.getStatus().getCode().value()) ;
+        }
+    }
+
     // It will send request using a new thread and forget about the response
     @Then("I send {string} async request to {string} with body {string}")
     public void sendAsyncHttpRequest(String httpMethod, String url, String body) throws IOException, NoSuchAlgorithmException, KeyStoreException, KeyManagementException {
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/SharedContext.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/SharedContext.java
index 782e061738..66bc9bfbc5 100644
--- a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/SharedContext.java
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/api/SharedContext.java
@@ -19,11 +19,11 @@
 
 import org.apache.http.HttpResponse;
 import org.wso2.apk.integration.utils.clients.SimpleHTTPClient;
+import org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentResponse;
 
 import java.security.KeyManagementException;
 import java.security.KeyStoreException;
 import java.security.NoSuchAlgorithmException;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
@@ -31,9 +31,11 @@
 public class SharedContext {
 
     private SimpleHTTPClient httpClient;
+    private StudentResponse studentResponse;
     private String accessToken;
     private HttpResponse response;
     private String responseBody;
+    private int grpcStatusCode;
     private HashMap<String, Object> valueStore = new HashMap<>();
     private HashMap<String, String> headers = new HashMap<>();
 
@@ -53,12 +55,28 @@ public void setAccessToken(String accessToken) {
 
         this.accessToken = accessToken;
     }
+    public int getGrpcStatusCode() {
+        return grpcStatusCode;
+    }
+    public void setGrpcStatusCode(int grpcStatusCode) {
+        this.grpcStatusCode = grpcStatusCode;
+    }
 
     public HttpResponse getResponse() {
 
         return response;
     }
 
+    public StudentResponse getStudentResponse() {
+
+        return studentResponse;
+    }
+
+    public void setStudentResponse(StudentResponse studentResponse) {
+
+        this.studentResponse = studentResponse;
+    }
+
     public void setResponse(HttpResponse response) {
 
         this.response = response;
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/GenericClientInterceptor.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/GenericClientInterceptor.java
new file mode 100644
index 0000000000..17ab5702e3
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/GenericClientInterceptor.java
@@ -0,0 +1,39 @@
+package org.wso2.apk.integration.utils;
+import io.grpc.ClientInterceptor;
+import io.grpc.ForwardingClientCall;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.Channel;
+import java.util.Map;
+
+
+import java.util.Map;
+
+public class GenericClientInterceptor implements ClientInterceptor {
+
+    private Map<String, String> headers;
+
+    public GenericClientInterceptor(Map<String, String> headers) {
+        this.headers = headers;
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
+                next.newCall(method, callOptions)) {
+
+            @Override
+            public void start(Listener<RespT> responseListener, Metadata headersMetadata) {
+                // Set each header in the map to the Metadata headers
+                headers.forEach((key, value) -> headersMetadata.put(
+                        Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value));
+
+                super.start(responseListener, headersMetadata);
+            }
+        };
+    }
+}
+
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/SimpleGRPCStudentClient.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/SimpleGRPCStudentClient.java
new file mode 100644
index 0000000000..0f7ba0b988
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/SimpleGRPCStudentClient.java
@@ -0,0 +1,115 @@
+package org.wso2.apk.integration.utils.clients;
+
+import io.grpc.StatusRuntimeException;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.NettyChannelBuilder;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import io.grpc.ManagedChannel;
+import org.wso2.apk.integration.utils.GenericClientInterceptor;
+import org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentRequest;
+import org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentResponse;
+import org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentServiceDefaultVersionGrpc;
+import org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentServiceGrpc;
+
+import javax.net.ssl.SSLException;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+
+public class SimpleGRPCStudentClient {
+    protected Log log = LogFactory.getLog(SimpleGRPCStudentClient.class);
+    private static final int EVENTUAL_SUCCESS_RESPONSE_TIMEOUT_IN_SECONDS = 10;
+    private final String host;
+    private final int port;
+
+    public SimpleGRPCStudentClient(String host, int port) {
+        this.host = host;
+        this.port = port;
+    }
+
+    public StudentResponse GetStudent(Map<String, String> headers) throws StatusRuntimeException{
+        ManagedChannel managedChannel = null;
+        try {
+            SslContext sslContext = GrpcSslContexts.forClient()
+                    .trustManager(InsecureTrustManagerFactory.INSTANCE)
+                    .build();
+
+            GenericClientInterceptor interceptor = new GenericClientInterceptor(headers);
+            managedChannel = NettyChannelBuilder.forAddress(host, port)
+                    .sslContext(sslContext)
+                    .intercept(interceptor)
+                    .build();
+            StudentServiceGrpc.StudentServiceBlockingStub blockingStub = StudentServiceGrpc.newBlockingStub(managedChannel);
+            if (blockingStub == null) {
+                log.error("Failed to create blocking stub");
+                throw new RuntimeException("Failed to create blocking stub");
+            }
+            StudentResponse response = blockingStub.getStudent(StudentRequest.newBuilder().setId(1).build());
+            if (response == null) {
+                log.error("Failed to get student");
+                throw new RuntimeException("Failed to get student");
+            }
+            return response;
+        }catch (SSLException e) {
+            throw new RuntimeException("Failed to create SSL context", e);
+        } finally {
+            // Shut down the channel to release resources
+            if (managedChannel != null) {
+                managedChannel.shutdown(); // Initiates a graceful shutdown
+                try {
+                    // Wait at most 5 seconds for the channel to terminate
+                    if (!managedChannel.awaitTermination(5, TimeUnit.SECONDS)) {
+                        managedChannel.shutdownNow(); // Force shutdown if it does not complete within the timeout
+                    }
+                } catch (InterruptedException ie) {
+                    managedChannel.shutdownNow(); // Force shutdown if the thread is interrupted
+                }
+            }
+        }
+    }
+    public StudentResponse GetStudentDefaultVersion(Map<String, String> headers) throws StatusRuntimeException{
+        ManagedChannel managedChannel = null;
+        try {
+            SslContext sslContext = GrpcSslContexts.forClient()
+                    .trustManager(InsecureTrustManagerFactory.INSTANCE)
+                    .build();
+
+            GenericClientInterceptor interceptor = new GenericClientInterceptor(headers);
+            managedChannel = NettyChannelBuilder.forAddress(host, port)
+                    .sslContext(sslContext)
+                    .intercept(interceptor)
+                    .build();
+            StudentServiceDefaultVersionGrpc.StudentServiceBlockingStub blockingStub = StudentServiceDefaultVersionGrpc.newBlockingStub(managedChannel);
+            if (blockingStub == null) {
+                log.error("Failed to create blocking stub");
+                throw new RuntimeException("Failed to create blocking stub");
+            }
+            StudentResponse response = blockingStub.getStudent(StudentRequest.newBuilder().setId(1).build());
+            if (response == null) {
+                log.error("Failed to get student");
+                throw new RuntimeException("Failed to get student");
+            }
+            return response;
+        }catch (SSLException e) {
+            throw new RuntimeException("Failed to create SSL context", e);
+        } finally {
+            // Shut down the channel to release resources
+            if (managedChannel != null) {
+                managedChannel.shutdown(); // Initiates a graceful shutdown
+                try {
+                    // Wait at most 5 seconds for the channel to terminate
+                    if (!managedChannel.awaitTermination(5, TimeUnit.SECONDS)) {
+                        managedChannel.shutdownNow(); // Force shutdown if it does not complete within the timeout
+                    }
+                } catch (InterruptedException ie) {
+                    managedChannel.shutdownNow(); // Force shutdown if the thread is interrupted
+                }
+            }
+        }
+    }
+
+}
+
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/Student.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/Student.java
new file mode 100644
index 0000000000..8ec85fec12
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/Student.java
@@ -0,0 +1,72 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: student.proto
+
+package org.wso2.apk.integration.utils.clients.studentGrpcClient;
+
+public final class Student {
+  private Student() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistryLite registry) {
+  }
+
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+    registerAllExtensions(
+        (com.google.protobuf.ExtensionRegistryLite) registry);
+  }
+  static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_dineth_grpc_v1_student_StudentRequest_descriptor;
+  static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_dineth_grpc_v1_student_StudentRequest_fieldAccessorTable;
+  static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_dineth_grpc_v1_student_StudentResponse_descriptor;
+  static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_dineth_grpc_v1_student_StudentResponse_fieldAccessorTable;
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static  com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    String[] descriptorData = {
+      "\n\rstudent.proto\022\026dineth.grpc.v1.student\"" +
+      "\034\n\016StudentRequest\022\n\n\002id\030\003 \001(\005\",\n\017Student" +
+      "Response\022\014\n\004name\030\001 \001(\t\022\013\n\003age\030\002 \001(\0052\266\003\n\016" +
+      "StudentService\022_\n\nGetStudent\022&.dineth.gr" +
+      "pc.v1.student.StudentRequest\032\'.dineth.gr" +
+      "pc.v1.student.StudentResponse\"\000\022g\n\020GetSt" +
+      "udentStream\022&.dineth.grpc.v1.student.Stu" +
+      "dentRequest\032\'.dineth.grpc.v1.student.Stu" +
+      "dentResponse\"\0000\001\022h\n\021SendStudentStream\022&." +
+      "dineth.grpc.v1.student.StudentRequest\032\'." +
+      "dineth.grpc.v1.student.StudentResponse\"\000" +
+      "(\001\022p\n\027SendAndGetStudentStream\022&.dineth.g" +
+      "rpc.v1.student.StudentRequest\032\'.dineth.g" +
+      "rpc.v1.student.StudentResponse\"\000(\0010\001B<\n8" +
+      "org.wso2.apk.integration.utils.clients.s" +
+      "tudentGrpcClientP\001b\006proto3"
+    };
+    descriptor = com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+        });
+    internal_static_dineth_grpc_v1_student_StudentRequest_descriptor =
+      getDescriptor().getMessageTypes().get(0);
+    internal_static_dineth_grpc_v1_student_StudentRequest_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_dineth_grpc_v1_student_StudentRequest_descriptor,
+        new String[] { "Id", });
+    internal_static_dineth_grpc_v1_student_StudentResponse_descriptor =
+      getDescriptor().getMessageTypes().get(1);
+    internal_static_dineth_grpc_v1_student_StudentResponse_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_dineth_grpc_v1_student_StudentResponse_descriptor,
+        new String[] { "Name", "Age", });
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentRequest.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentRequest.java
new file mode 100644
index 0000000000..c487c65674
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentRequest.java
@@ -0,0 +1,483 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: student.proto
+
+package org.wso2.apk.integration.utils.clients.studentGrpcClient;
+
+/**
+ * Protobuf type {@code dineth.grpc.v1.student.StudentRequest}
+ */
+public final class StudentRequest extends
+    com.google.protobuf.GeneratedMessageV3 implements
+    // @@protoc_insertion_point(message_implements:dineth.grpc.v1.student.StudentRequest)
+    StudentRequestOrBuilder {
+private static final long serialVersionUID = 0L;
+  // Use StudentRequest.newBuilder() to construct.
+  private StudentRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
+    super(builder);
+  }
+  private StudentRequest() {
+  }
+
+  @Override
+  @SuppressWarnings({"unused"})
+  protected Object newInstance(
+      UnusedPrivateParameter unused) {
+    return new StudentRequest();
+  }
+
+  @Override
+  public final com.google.protobuf.UnknownFieldSet
+  getUnknownFields() {
+    return this.unknownFields;
+  }
+  private StudentRequest(
+      com.google.protobuf.CodedInputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    this();
+    if (extensionRegistry == null) {
+      throw new NullPointerException();
+    }
+    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+        com.google.protobuf.UnknownFieldSet.newBuilder();
+    try {
+      boolean done = false;
+      while (!done) {
+        int tag = input.readTag();
+        switch (tag) {
+          case 0:
+            done = true;
+            break;
+          case 24: {
+
+            id_ = input.readInt32();
+            break;
+          }
+          default: {
+            if (!parseUnknownField(
+                input, unknownFields, extensionRegistry, tag)) {
+              done = true;
+            }
+            break;
+          }
+        }
+      }
+    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+      throw e.setUnfinishedMessage(this);
+    } catch (java.io.IOException e) {
+      throw new com.google.protobuf.InvalidProtocolBufferException(
+          e).setUnfinishedMessage(this);
+    } finally {
+      this.unknownFields = unknownFields.build();
+      makeExtensionsImmutable();
+    }
+  }
+  public static final com.google.protobuf.Descriptors.Descriptor
+      getDescriptor() {
+    return Student.internal_static_dineth_grpc_v1_student_StudentRequest_descriptor;
+  }
+
+  @Override
+  protected FieldAccessorTable
+      internalGetFieldAccessorTable() {
+    return Student.internal_static_dineth_grpc_v1_student_StudentRequest_fieldAccessorTable
+        .ensureFieldAccessorsInitialized(
+            StudentRequest.class, Builder.class);
+  }
+
+  public static final int ID_FIELD_NUMBER = 3;
+  private int id_;
+  /**
+   * <code>int32 id = 3;</code>
+   * @return The id.
+   */
+  @Override
+  public int getId() {
+    return id_;
+  }
+
+  private byte memoizedIsInitialized = -1;
+  @Override
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    memoizedIsInitialized = 1;
+    return true;
+  }
+
+  @Override
+  public void writeTo(com.google.protobuf.CodedOutputStream output)
+                      throws java.io.IOException {
+    if (id_ != 0) {
+      output.writeInt32(3, id_);
+    }
+    unknownFields.writeTo(output);
+  }
+
+  @Override
+  public int getSerializedSize() {
+    int size = memoizedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    if (id_ != 0) {
+      size += com.google.protobuf.CodedOutputStream
+        .computeInt32Size(3, id_);
+    }
+    size += unknownFields.getSerializedSize();
+    memoizedSize = size;
+    return size;
+  }
+
+  @Override
+  public boolean equals(final Object obj) {
+    if (obj == this) {
+     return true;
+    }
+    if (!(obj instanceof StudentRequest)) {
+      return super.equals(obj);
+    }
+    StudentRequest other = (StudentRequest) obj;
+
+    if (getId()
+        != other.getId()) return false;
+    if (!unknownFields.equals(other.unknownFields)) return false;
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    if (memoizedHashCode != 0) {
+      return memoizedHashCode;
+    }
+    int hash = 41;
+    hash = (19 * hash) + getDescriptor().hashCode();
+    hash = (37 * hash) + ID_FIELD_NUMBER;
+    hash = (53 * hash) + getId();
+    hash = (29 * hash) + unknownFields.hashCode();
+    memoizedHashCode = hash;
+    return hash;
+  }
+
+  public static StudentRequest parseFrom(
+      java.nio.ByteBuffer data)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static StudentRequest parseFrom(
+      java.nio.ByteBuffer data,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+  public static StudentRequest parseFrom(
+      com.google.protobuf.ByteString data)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static StudentRequest parseFrom(
+      com.google.protobuf.ByteString data,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+  public static StudentRequest parseFrom(byte[] data)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static StudentRequest parseFrom(
+      byte[] data,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+  public static StudentRequest parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input);
+  }
+  public static StudentRequest parseFrom(
+      java.io.InputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input, extensionRegistry);
+  }
+  public static StudentRequest parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseDelimitedWithIOException(PARSER, input);
+  }
+  public static StudentRequest parseDelimitedFrom(
+      java.io.InputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+  }
+  public static StudentRequest parseFrom(
+      com.google.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input);
+  }
+  public static StudentRequest parseFrom(
+      com.google.protobuf.CodedInputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input, extensionRegistry);
+  }
+
+  @Override
+  public Builder newBuilderForType() { return newBuilder(); }
+  public static Builder newBuilder() {
+    return DEFAULT_INSTANCE.toBuilder();
+  }
+  public static Builder newBuilder(StudentRequest prototype) {
+    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+  }
+  @Override
+  public Builder toBuilder() {
+    return this == DEFAULT_INSTANCE
+        ? new Builder() : new Builder().mergeFrom(this);
+  }
+
+  @Override
+  protected Builder newBuilderForType(
+      BuilderParent parent) {
+    Builder builder = new Builder(parent);
+    return builder;
+  }
+  /**
+   * Protobuf type {@code dineth.grpc.v1.student.StudentRequest}
+   */
+  public static final class Builder extends
+      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
+      // @@protoc_insertion_point(builder_implements:dineth.grpc.v1.student.StudentRequest)
+      StudentRequestOrBuilder {
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return Student.internal_static_dineth_grpc_v1_student_StudentRequest_descriptor;
+    }
+
+    @Override
+    protected FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return Student.internal_static_dineth_grpc_v1_student_StudentRequest_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              StudentRequest.class, Builder.class);
+    }
+
+    // Construct using org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentRequest.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private Builder(
+        BuilderParent parent) {
+      super(parent);
+      maybeForceBuilderInitialization();
+    }
+    private void maybeForceBuilderInitialization() {
+      if (com.google.protobuf.GeneratedMessageV3
+              .alwaysUseFieldBuilders) {
+      }
+    }
+    @Override
+    public Builder clear() {
+      super.clear();
+      id_ = 0;
+
+      return this;
+    }
+
+    @Override
+    public com.google.protobuf.Descriptors.Descriptor
+        getDescriptorForType() {
+      return Student.internal_static_dineth_grpc_v1_student_StudentRequest_descriptor;
+    }
+
+    @Override
+    public StudentRequest getDefaultInstanceForType() {
+      return StudentRequest.getDefaultInstance();
+    }
+
+    @Override
+    public StudentRequest build() {
+      StudentRequest result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    @Override
+    public StudentRequest buildPartial() {
+      StudentRequest result = new StudentRequest(this);
+      result.id_ = id_;
+      onBuilt();
+      return result;
+    }
+
+    @Override
+    public Builder clone() {
+      return super.clone();
+    }
+    @Override
+    public Builder setField(
+        com.google.protobuf.Descriptors.FieldDescriptor field,
+        Object value) {
+      return super.setField(field, value);
+    }
+    @Override
+    public Builder clearField(
+        com.google.protobuf.Descriptors.FieldDescriptor field) {
+      return super.clearField(field);
+    }
+    @Override
+    public Builder clearOneof(
+        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+      return super.clearOneof(oneof);
+    }
+    @Override
+    public Builder setRepeatedField(
+        com.google.protobuf.Descriptors.FieldDescriptor field,
+        int index, Object value) {
+      return super.setRepeatedField(field, index, value);
+    }
+    @Override
+    public Builder addRepeatedField(
+        com.google.protobuf.Descriptors.FieldDescriptor field,
+        Object value) {
+      return super.addRepeatedField(field, value);
+    }
+    @Override
+    public Builder mergeFrom(com.google.protobuf.Message other) {
+      if (other instanceof StudentRequest) {
+        return mergeFrom((StudentRequest)other);
+      } else {
+        super.mergeFrom(other);
+        return this;
+      }
+    }
+
+    public Builder mergeFrom(StudentRequest other) {
+      if (other == StudentRequest.getDefaultInstance()) return this;
+      if (other.getId() != 0) {
+        setId(other.getId());
+      }
+      this.mergeUnknownFields(other.unknownFields);
+      onChanged();
+      return this;
+    }
+
+    @Override
+    public final boolean isInitialized() {
+      return true;
+    }
+
+    @Override
+    public Builder mergeFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      StudentRequest parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (StudentRequest) e.getUnfinishedMessage();
+        throw e.unwrapIOException();
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+
+    private int id_ ;
+    /**
+     * <code>int32 id = 3;</code>
+     * @return The id.
+     */
+    @Override
+    public int getId() {
+      return id_;
+    }
+    /**
+     * <code>int32 id = 3;</code>
+     * @param value The id to set.
+     * @return This builder for chaining.
+     */
+    public Builder setId(int value) {
+      
+      id_ = value;
+      onChanged();
+      return this;
+    }
+    /**
+     * <code>int32 id = 3;</code>
+     * @return This builder for chaining.
+     */
+    public Builder clearId() {
+      
+      id_ = 0;
+      onChanged();
+      return this;
+    }
+    @Override
+    public final Builder setUnknownFields(
+        final com.google.protobuf.UnknownFieldSet unknownFields) {
+      return super.setUnknownFields(unknownFields);
+    }
+
+    @Override
+    public final Builder mergeUnknownFields(
+        final com.google.protobuf.UnknownFieldSet unknownFields) {
+      return super.mergeUnknownFields(unknownFields);
+    }
+
+
+    // @@protoc_insertion_point(builder_scope:dineth.grpc.v1.student.StudentRequest)
+  }
+
+  // @@protoc_insertion_point(class_scope:dineth.grpc.v1.student.StudentRequest)
+  private static final StudentRequest DEFAULT_INSTANCE;
+  static {
+    DEFAULT_INSTANCE = new StudentRequest();
+  }
+
+  public static StudentRequest getDefaultInstance() {
+    return DEFAULT_INSTANCE;
+  }
+
+  private static final com.google.protobuf.Parser<StudentRequest>
+      PARSER = new com.google.protobuf.AbstractParser<StudentRequest>() {
+    @Override
+    public StudentRequest parsePartialFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return new StudentRequest(input, extensionRegistry);
+    }
+  };
+
+  public static com.google.protobuf.Parser<StudentRequest> parser() {
+    return PARSER;
+  }
+
+  @Override
+  public com.google.protobuf.Parser<StudentRequest> getParserForType() {
+    return PARSER;
+  }
+
+  @Override
+  public StudentRequest getDefaultInstanceForType() {
+    return DEFAULT_INSTANCE;
+  }
+
+}
+
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentRequestOrBuilder.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentRequestOrBuilder.java
new file mode 100644
index 0000000000..62c36bc771
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentRequestOrBuilder.java
@@ -0,0 +1,15 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: student.proto
+
+package org.wso2.apk.integration.utils.clients.studentGrpcClient;
+
+public interface StudentRequestOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:dineth.grpc.v1.student.StudentRequest)
+    com.google.protobuf.MessageOrBuilder {
+
+  /**
+   * <code>int32 id = 3;</code>
+   * @return The id.
+   */
+  int getId();
+}
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentResponse.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentResponse.java
new file mode 100644
index 0000000000..33e343eba4
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentResponse.java
@@ -0,0 +1,621 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: student.proto
+
+package org.wso2.apk.integration.utils.clients.studentGrpcClient;
+
+/**
+ * Protobuf type {@code dineth.grpc.v1.student.StudentResponse}
+ */
+public final class StudentResponse extends
+    com.google.protobuf.GeneratedMessageV3 implements
+    // @@protoc_insertion_point(message_implements:dineth.grpc.v1.student.StudentResponse)
+    StudentResponseOrBuilder {
+private static final long serialVersionUID = 0L;
+  // Use StudentResponse.newBuilder() to construct.
+  private StudentResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
+    super(builder);
+  }
+  private StudentResponse() {
+    name_ = "";
+  }
+
+  @Override
+  @SuppressWarnings({"unused"})
+  protected Object newInstance(
+      UnusedPrivateParameter unused) {
+    return new StudentResponse();
+  }
+
+  @Override
+  public final com.google.protobuf.UnknownFieldSet
+  getUnknownFields() {
+    return this.unknownFields;
+  }
+  private StudentResponse(
+      com.google.protobuf.CodedInputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    this();
+    if (extensionRegistry == null) {
+      throw new NullPointerException();
+    }
+    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+        com.google.protobuf.UnknownFieldSet.newBuilder();
+    try {
+      boolean done = false;
+      while (!done) {
+        int tag = input.readTag();
+        switch (tag) {
+          case 0:
+            done = true;
+            break;
+          case 10: {
+            String s = input.readStringRequireUtf8();
+
+            name_ = s;
+            break;
+          }
+          case 16: {
+
+            age_ = input.readInt32();
+            break;
+          }
+          default: {
+            if (!parseUnknownField(
+                input, unknownFields, extensionRegistry, tag)) {
+              done = true;
+            }
+            break;
+          }
+        }
+      }
+    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+      throw e.setUnfinishedMessage(this);
+    } catch (java.io.IOException e) {
+      throw new com.google.protobuf.InvalidProtocolBufferException(
+          e).setUnfinishedMessage(this);
+    } finally {
+      this.unknownFields = unknownFields.build();
+      makeExtensionsImmutable();
+    }
+  }
+  public static final com.google.protobuf.Descriptors.Descriptor
+      getDescriptor() {
+    return Student.internal_static_dineth_grpc_v1_student_StudentResponse_descriptor;
+  }
+
+  @Override
+  protected FieldAccessorTable
+      internalGetFieldAccessorTable() {
+    return Student.internal_static_dineth_grpc_v1_student_StudentResponse_fieldAccessorTable
+        .ensureFieldAccessorsInitialized(
+            StudentResponse.class, Builder.class);
+  }
+
+  public static final int NAME_FIELD_NUMBER = 1;
+  private volatile Object name_;
+  /**
+   * <code>string name = 1;</code>
+   * @return The name.
+   */
+  @Override
+  public String getName() {
+    Object ref = name_;
+    if (ref instanceof String) {
+      return (String) ref;
+    } else {
+      com.google.protobuf.ByteString bs = 
+          (com.google.protobuf.ByteString) ref;
+      String s = bs.toStringUtf8();
+      name_ = s;
+      return s;
+    }
+  }
+  /**
+   * <code>string name = 1;</code>
+   * @return The bytes for name.
+   */
+  @Override
+  public com.google.protobuf.ByteString
+      getNameBytes() {
+    Object ref = name_;
+    if (ref instanceof String) {
+      com.google.protobuf.ByteString b = 
+          com.google.protobuf.ByteString.copyFromUtf8(
+              (String) ref);
+      name_ = b;
+      return b;
+    } else {
+      return (com.google.protobuf.ByteString) ref;
+    }
+  }
+
+  public static final int AGE_FIELD_NUMBER = 2;
+  private int age_;
+  /**
+   * <code>int32 age = 2;</code>
+   * @return The age.
+   */
+  @Override
+  public int getAge() {
+    return age_;
+  }
+
+  private byte memoizedIsInitialized = -1;
+  @Override
+  public final boolean isInitialized() {
+    byte isInitialized = memoizedIsInitialized;
+    if (isInitialized == 1) return true;
+    if (isInitialized == 0) return false;
+
+    memoizedIsInitialized = 1;
+    return true;
+  }
+
+  @Override
+  public void writeTo(com.google.protobuf.CodedOutputStream output)
+                      throws java.io.IOException {
+    if (!getNameBytes().isEmpty()) {
+      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_);
+    }
+    if (age_ != 0) {
+      output.writeInt32(2, age_);
+    }
+    unknownFields.writeTo(output);
+  }
+
+  @Override
+  public int getSerializedSize() {
+    int size = memoizedSize;
+    if (size != -1) return size;
+
+    size = 0;
+    if (!getNameBytes().isEmpty()) {
+      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_);
+    }
+    if (age_ != 0) {
+      size += com.google.protobuf.CodedOutputStream
+        .computeInt32Size(2, age_);
+    }
+    size += unknownFields.getSerializedSize();
+    memoizedSize = size;
+    return size;
+  }
+
+  @Override
+  public boolean equals(final Object obj) {
+    if (obj == this) {
+     return true;
+    }
+    if (!(obj instanceof StudentResponse)) {
+      return super.equals(obj);
+    }
+    StudentResponse other = (StudentResponse) obj;
+
+    if (!getName()
+        .equals(other.getName())) return false;
+    if (getAge()
+        != other.getAge()) return false;
+    if (!unknownFields.equals(other.unknownFields)) return false;
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    if (memoizedHashCode != 0) {
+      return memoizedHashCode;
+    }
+    int hash = 41;
+    hash = (19 * hash) + getDescriptor().hashCode();
+    hash = (37 * hash) + NAME_FIELD_NUMBER;
+    hash = (53 * hash) + getName().hashCode();
+    hash = (37 * hash) + AGE_FIELD_NUMBER;
+    hash = (53 * hash) + getAge();
+    hash = (29 * hash) + unknownFields.hashCode();
+    memoizedHashCode = hash;
+    return hash;
+  }
+
+  public static StudentResponse parseFrom(
+      java.nio.ByteBuffer data)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static StudentResponse parseFrom(
+      java.nio.ByteBuffer data,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+  public static StudentResponse parseFrom(
+      com.google.protobuf.ByteString data)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static StudentResponse parseFrom(
+      com.google.protobuf.ByteString data,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+  public static StudentResponse parseFrom(byte[] data)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data);
+  }
+  public static StudentResponse parseFrom(
+      byte[] data,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws com.google.protobuf.InvalidProtocolBufferException {
+    return PARSER.parseFrom(data, extensionRegistry);
+  }
+  public static StudentResponse parseFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input);
+  }
+  public static StudentResponse parseFrom(
+      java.io.InputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input, extensionRegistry);
+  }
+  public static StudentResponse parseDelimitedFrom(java.io.InputStream input)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseDelimitedWithIOException(PARSER, input);
+  }
+  public static StudentResponse parseDelimitedFrom(
+      java.io.InputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+  }
+  public static StudentResponse parseFrom(
+      com.google.protobuf.CodedInputStream input)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input);
+  }
+  public static StudentResponse parseFrom(
+      com.google.protobuf.CodedInputStream input,
+      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+      throws java.io.IOException {
+    return com.google.protobuf.GeneratedMessageV3
+        .parseWithIOException(PARSER, input, extensionRegistry);
+  }
+
+  @Override
+  public Builder newBuilderForType() { return newBuilder(); }
+  public static Builder newBuilder() {
+    return DEFAULT_INSTANCE.toBuilder();
+  }
+  public static Builder newBuilder(StudentResponse prototype) {
+    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+  }
+  @Override
+  public Builder toBuilder() {
+    return this == DEFAULT_INSTANCE
+        ? new Builder() : new Builder().mergeFrom(this);
+  }
+
+  @Override
+  protected Builder newBuilderForType(
+      BuilderParent parent) {
+    Builder builder = new Builder(parent);
+    return builder;
+  }
+  /**
+   * Protobuf type {@code dineth.grpc.v1.student.StudentResponse}
+   */
+  public static final class Builder extends
+      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
+      // @@protoc_insertion_point(builder_implements:dineth.grpc.v1.student.StudentResponse)
+      StudentResponseOrBuilder {
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return Student.internal_static_dineth_grpc_v1_student_StudentResponse_descriptor;
+    }
+
+    @Override
+    protected FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return Student.internal_static_dineth_grpc_v1_student_StudentResponse_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              StudentResponse.class, Builder.class);
+    }
+
+    // Construct using org.wso2.apk.integration.utils.clients.studentGrpcClient.StudentResponse.newBuilder()
+    private Builder() {
+      maybeForceBuilderInitialization();
+    }
+
+    private Builder(
+        BuilderParent parent) {
+      super(parent);
+      maybeForceBuilderInitialization();
+    }
+    private void maybeForceBuilderInitialization() {
+      if (com.google.protobuf.GeneratedMessageV3
+              .alwaysUseFieldBuilders) {
+      }
+    }
+    @Override
+    public Builder clear() {
+      super.clear();
+      name_ = "";
+
+      age_ = 0;
+
+      return this;
+    }
+
+    @Override
+    public com.google.protobuf.Descriptors.Descriptor
+        getDescriptorForType() {
+      return Student.internal_static_dineth_grpc_v1_student_StudentResponse_descriptor;
+    }
+
+    @Override
+    public StudentResponse getDefaultInstanceForType() {
+      return StudentResponse.getDefaultInstance();
+    }
+
+    @Override
+    public StudentResponse build() {
+      StudentResponse result = buildPartial();
+      if (!result.isInitialized()) {
+        throw newUninitializedMessageException(result);
+      }
+      return result;
+    }
+
+    @Override
+    public StudentResponse buildPartial() {
+      StudentResponse result = new StudentResponse(this);
+      result.name_ = name_;
+      result.age_ = age_;
+      onBuilt();
+      return result;
+    }
+
+    @Override
+    public Builder clone() {
+      return super.clone();
+    }
+    @Override
+    public Builder setField(
+        com.google.protobuf.Descriptors.FieldDescriptor field,
+        Object value) {
+      return super.setField(field, value);
+    }
+    @Override
+    public Builder clearField(
+        com.google.protobuf.Descriptors.FieldDescriptor field) {
+      return super.clearField(field);
+    }
+    @Override
+    public Builder clearOneof(
+        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+      return super.clearOneof(oneof);
+    }
+    @Override
+    public Builder setRepeatedField(
+        com.google.protobuf.Descriptors.FieldDescriptor field,
+        int index, Object value) {
+      return super.setRepeatedField(field, index, value);
+    }
+    @Override
+    public Builder addRepeatedField(
+        com.google.protobuf.Descriptors.FieldDescriptor field,
+        Object value) {
+      return super.addRepeatedField(field, value);
+    }
+    @Override
+    public Builder mergeFrom(com.google.protobuf.Message other) {
+      if (other instanceof StudentResponse) {
+        return mergeFrom((StudentResponse)other);
+      } else {
+        super.mergeFrom(other);
+        return this;
+      }
+    }
+
+    public Builder mergeFrom(StudentResponse other) {
+      if (other == StudentResponse.getDefaultInstance()) return this;
+      if (!other.getName().isEmpty()) {
+        name_ = other.name_;
+        onChanged();
+      }
+      if (other.getAge() != 0) {
+        setAge(other.getAge());
+      }
+      this.mergeUnknownFields(other.unknownFields);
+      onChanged();
+      return this;
+    }
+
+    @Override
+    public final boolean isInitialized() {
+      return true;
+    }
+
+    @Override
+    public Builder mergeFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      StudentResponse parsedMessage = null;
+      try {
+        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        parsedMessage = (StudentResponse) e.getUnfinishedMessage();
+        throw e.unwrapIOException();
+      } finally {
+        if (parsedMessage != null) {
+          mergeFrom(parsedMessage);
+        }
+      }
+      return this;
+    }
+
+    private Object name_ = "";
+    /**
+     * <code>string name = 1;</code>
+     * @return The name.
+     */
+    public String getName() {
+      Object ref = name_;
+      if (!(ref instanceof String)) {
+        com.google.protobuf.ByteString bs =
+            (com.google.protobuf.ByteString) ref;
+        String s = bs.toStringUtf8();
+        name_ = s;
+        return s;
+      } else {
+        return (String) ref;
+      }
+    }
+    /**
+     * <code>string name = 1;</code>
+     * @return The bytes for name.
+     */
+    public com.google.protobuf.ByteString
+        getNameBytes() {
+      Object ref = name_;
+      if (ref instanceof String) {
+        com.google.protobuf.ByteString b = 
+            com.google.protobuf.ByteString.copyFromUtf8(
+                (String) ref);
+        name_ = b;
+        return b;
+      } else {
+        return (com.google.protobuf.ByteString) ref;
+      }
+    }
+    /**
+     * <code>string name = 1;</code>
+     * @param value The name to set.
+     * @return This builder for chaining.
+     */
+    public Builder setName(
+        String value) {
+      if (value == null) {
+    throw new NullPointerException();
+  }
+  
+      name_ = value;
+      onChanged();
+      return this;
+    }
+    /**
+     * <code>string name = 1;</code>
+     * @return This builder for chaining.
+     */
+    public Builder clearName() {
+      
+      name_ = getDefaultInstance().getName();
+      onChanged();
+      return this;
+    }
+    /**
+     * <code>string name = 1;</code>
+     * @param value The bytes for name to set.
+     * @return This builder for chaining.
+     */
+    public Builder setNameBytes(
+        com.google.protobuf.ByteString value) {
+      if (value == null) {
+    throw new NullPointerException();
+  }
+  checkByteStringIsUtf8(value);
+      
+      name_ = value;
+      onChanged();
+      return this;
+    }
+
+    private int age_ ;
+    /**
+     * <code>int32 age = 2;</code>
+     * @return The age.
+     */
+    @Override
+    public int getAge() {
+      return age_;
+    }
+    /**
+     * <code>int32 age = 2;</code>
+     * @param value The age to set.
+     * @return This builder for chaining.
+     */
+    public Builder setAge(int value) {
+      
+      age_ = value;
+      onChanged();
+      return this;
+    }
+    /**
+     * <code>int32 age = 2;</code>
+     * @return This builder for chaining.
+     */
+    public Builder clearAge() {
+      
+      age_ = 0;
+      onChanged();
+      return this;
+    }
+    @Override
+    public final Builder setUnknownFields(
+        final com.google.protobuf.UnknownFieldSet unknownFields) {
+      return super.setUnknownFields(unknownFields);
+    }
+
+    @Override
+    public final Builder mergeUnknownFields(
+        final com.google.protobuf.UnknownFieldSet unknownFields) {
+      return super.mergeUnknownFields(unknownFields);
+    }
+
+
+    // @@protoc_insertion_point(builder_scope:dineth.grpc.v1.student.StudentResponse)
+  }
+
+  // @@protoc_insertion_point(class_scope:dineth.grpc.v1.student.StudentResponse)
+  private static final StudentResponse DEFAULT_INSTANCE;
+  static {
+    DEFAULT_INSTANCE = new StudentResponse();
+  }
+
+  public static StudentResponse getDefaultInstance() {
+    return DEFAULT_INSTANCE;
+  }
+
+  private static final com.google.protobuf.Parser<StudentResponse>
+      PARSER = new com.google.protobuf.AbstractParser<StudentResponse>() {
+    @Override
+    public StudentResponse parsePartialFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return new StudentResponse(input, extensionRegistry);
+    }
+  };
+
+  public static com.google.protobuf.Parser<StudentResponse> parser() {
+    return PARSER;
+  }
+
+  @Override
+  public com.google.protobuf.Parser<StudentResponse> getParserForType() {
+    return PARSER;
+  }
+
+  @Override
+  public StudentResponse getDefaultInstanceForType() {
+    return DEFAULT_INSTANCE;
+  }
+
+}
+
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentResponseOrBuilder.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentResponseOrBuilder.java
new file mode 100644
index 0000000000..08946635cd
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentResponseOrBuilder.java
@@ -0,0 +1,27 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: student.proto
+
+package org.wso2.apk.integration.utils.clients.studentGrpcClient;
+
+public interface StudentResponseOrBuilder extends
+    // @@protoc_insertion_point(interface_extends:dineth.grpc.v1.student.StudentResponse)
+    com.google.protobuf.MessageOrBuilder {
+
+  /**
+   * <code>string name = 1;</code>
+   * @return The name.
+   */
+  String getName();
+  /**
+   * <code>string name = 1;</code>
+   * @return The bytes for name.
+   */
+  com.google.protobuf.ByteString
+      getNameBytes();
+
+  /**
+   * <code>int32 age = 2;</code>
+   * @return The age.
+   */
+  int getAge();
+}
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentServiceDefaultVersionGrpc.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentServiceDefaultVersionGrpc.java
new file mode 100644
index 0000000000..9a2878343f
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentServiceDefaultVersionGrpc.java
@@ -0,0 +1,458 @@
+package org.wso2.apk.integration.utils.clients.studentGrpcClient;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@javax.annotation.Generated(
+    value = "by gRPC proto compiler (version 1.39.0)",
+    comments = "Source: student.proto")
+public final class StudentServiceDefaultVersionGrpc {
+
+  private StudentServiceDefaultVersionGrpc() {}
+
+  public static final String SERVICE_NAME = "dineth.grpc.api.student.StudentService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetStudent",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getGetStudentMethod;
+    if ((getGetStudentMethod = StudentServiceDefaultVersionGrpc.getGetStudentMethod) == null) {
+      synchronized (StudentServiceDefaultVersionGrpc.class) {
+        if ((getGetStudentMethod = StudentServiceDefaultVersionGrpc.getGetStudentMethod) == null) {
+          StudentServiceDefaultVersionGrpc.getGetStudentMethod = getGetStudentMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStudent"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("GetStudent"))
+              .build();
+        }
+      }
+    }
+    return getGetStudentMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentStreamMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetStudentStream",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentStreamMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getGetStudentStreamMethod;
+    if ((getGetStudentStreamMethod = StudentServiceDefaultVersionGrpc.getGetStudentStreamMethod) == null) {
+      synchronized (StudentServiceDefaultVersionGrpc.class) {
+        if ((getGetStudentStreamMethod = StudentServiceDefaultVersionGrpc.getGetStudentStreamMethod) == null) {
+          StudentServiceDefaultVersionGrpc.getGetStudentStreamMethod = getGetStudentStreamMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStudentStream"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("GetStudentStream"))
+              .build();
+        }
+      }
+    }
+    return getGetStudentStreamMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendStudentStreamMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SendStudentStream",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendStudentStreamMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getSendStudentStreamMethod;
+    if ((getSendStudentStreamMethod = StudentServiceDefaultVersionGrpc.getSendStudentStreamMethod) == null) {
+      synchronized (StudentServiceDefaultVersionGrpc.class) {
+        if ((getSendStudentStreamMethod = StudentServiceDefaultVersionGrpc.getSendStudentStreamMethod) == null) {
+          StudentServiceDefaultVersionGrpc.getSendStudentStreamMethod = getSendStudentStreamMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SendStudentStream"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("SendStudentStream"))
+              .build();
+        }
+      }
+    }
+    return getSendStudentStreamMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendAndGetStudentStreamMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SendAndGetStudentStream",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendAndGetStudentStreamMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getSendAndGetStudentStreamMethod;
+    if ((getSendAndGetStudentStreamMethod = StudentServiceDefaultVersionGrpc.getSendAndGetStudentStreamMethod) == null) {
+      synchronized (StudentServiceDefaultVersionGrpc.class) {
+        if ((getSendAndGetStudentStreamMethod = StudentServiceDefaultVersionGrpc.getSendAndGetStudentStreamMethod) == null) {
+          StudentServiceDefaultVersionGrpc.getSendAndGetStudentStreamMethod = getSendAndGetStudentStreamMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SendAndGetStudentStream"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("SendAndGetStudentStream"))
+              .build();
+        }
+      }
+    }
+    return getSendAndGetStudentStreamMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static StudentServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<StudentServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<StudentServiceStub>() {
+        @Override
+        public StudentServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new StudentServiceStub(channel, callOptions);
+        }
+      };
+    return StudentServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static StudentServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<StudentServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<StudentServiceBlockingStub>() {
+        @Override
+        public StudentServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new StudentServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return StudentServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static StudentServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<StudentServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<StudentServiceFutureStub>() {
+        @Override
+        public StudentServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new StudentServiceFutureStub(channel, callOptions);
+        }
+      };
+    return StudentServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public static abstract class StudentServiceImplBase implements io.grpc.BindableService {
+
+    /**
+     */
+    public void getStudent(StudentRequest request,
+                           io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStudentMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public void getStudentStream(StudentRequest request,
+                                 io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStudentStreamMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getSendStudentStreamMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendAndGetStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getSendAndGetStudentStreamMethod(), responseObserver);
+    }
+
+    @Override public final io.grpc.ServerServiceDefinition bindService() {
+      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+          .addMethod(
+            getGetStudentMethod(),
+            io.grpc.stub.ServerCalls.asyncUnaryCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_GET_STUDENT)))
+          .addMethod(
+            getGetStudentStreamMethod(),
+            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_GET_STUDENT_STREAM)))
+          .addMethod(
+            getSendStudentStreamMethod(),
+            io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_SEND_STUDENT_STREAM)))
+          .addMethod(
+            getSendAndGetStudentStreamMethod(),
+            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_SEND_AND_GET_STUDENT_STREAM)))
+          .build();
+    }
+  }
+
+  /**
+   */
+  public static final class StudentServiceStub extends io.grpc.stub.AbstractAsyncStub<StudentServiceStub> {
+    private StudentServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @Override
+    protected StudentServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new StudentServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void getStudent(StudentRequest request,
+                           io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetStudentMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void getStudentStream(StudentRequest request,
+                                 io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getGetStudentStreamMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getSendStudentStreamMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendAndGetStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getSendAndGetStudentStreamMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   */
+  public static final class StudentServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<StudentServiceBlockingStub> {
+    private StudentServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @Override
+    protected StudentServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new StudentServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public StudentResponse getStudent(StudentRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetStudentMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public java.util.Iterator<StudentResponse> getStudentStream(
+        StudentRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getGetStudentStreamMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   */
+  public static final class StudentServiceFutureStub extends io.grpc.stub.AbstractFutureStub<StudentServiceFutureStub> {
+    private StudentServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @Override
+    protected StudentServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new StudentServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<StudentResponse> getStudent(
+        StudentRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetStudentMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_STUDENT = 0;
+  private static final int METHODID_GET_STUDENT_STREAM = 1;
+  private static final int METHODID_SEND_STUDENT_STREAM = 2;
+  private static final int METHODID_SEND_AND_GET_STUDENT_STREAM = 3;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final StudentServiceImplBase serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(StudentServiceImplBase serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_STUDENT:
+          serviceImpl.getStudent((StudentRequest) request,
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+          break;
+        case METHODID_GET_STUDENT_STREAM:
+          serviceImpl.getStudentStream((StudentRequest) request,
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_SEND_STUDENT_STREAM:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.sendStudentStream(
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+        case METHODID_SEND_AND_GET_STUDENT_STREAM:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.sendAndGetStudentStream(
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  private static abstract class StudentServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    StudentServiceBaseDescriptorSupplier() {}
+
+    @Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return Student.getDescriptor();
+    }
+
+    @Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("StudentService");
+    }
+  }
+
+  private static final class StudentServiceFileDescriptorSupplier
+      extends StudentServiceBaseDescriptorSupplier {
+    StudentServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class StudentServiceMethodDescriptorSupplier
+      extends StudentServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final String methodName;
+
+    StudentServiceMethodDescriptorSupplier(String methodName) {
+      this.methodName = methodName;
+    }
+
+    @Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (StudentServiceDefaultVersionGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new StudentServiceFileDescriptorSupplier())
+              .addMethod(getGetStudentMethod())
+              .addMethod(getGetStudentStreamMethod())
+              .addMethod(getSendStudentStreamMethod())
+              .addMethod(getSendAndGetStudentStreamMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentServiceGrpc.java b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentServiceGrpc.java
new file mode 100644
index 0000000000..b9b158c0f1
--- /dev/null
+++ b/test/cucumber-tests/src/test/java/org/wso2/apk/integration/utils/clients/studentGrpcClient/StudentServiceGrpc.java
@@ -0,0 +1,458 @@
+package org.wso2.apk.integration.utils.clients.studentGrpcClient;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@javax.annotation.Generated(
+    value = "by gRPC proto compiler (version 1.39.0)",
+    comments = "Source: student.proto")
+public final class StudentServiceGrpc {
+
+  private StudentServiceGrpc() {}
+
+  public static final String SERVICE_NAME = "dineth.grpc.api.v1.student.StudentService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetStudent",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getGetStudentMethod;
+    if ((getGetStudentMethod = StudentServiceGrpc.getGetStudentMethod) == null) {
+      synchronized (StudentServiceGrpc.class) {
+        if ((getGetStudentMethod = StudentServiceGrpc.getGetStudentMethod) == null) {
+          StudentServiceGrpc.getGetStudentMethod = getGetStudentMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStudent"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("GetStudent"))
+              .build();
+        }
+      }
+    }
+    return getGetStudentMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentStreamMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetStudentStream",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getGetStudentStreamMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getGetStudentStreamMethod;
+    if ((getGetStudentStreamMethod = StudentServiceGrpc.getGetStudentStreamMethod) == null) {
+      synchronized (StudentServiceGrpc.class) {
+        if ((getGetStudentStreamMethod = StudentServiceGrpc.getGetStudentStreamMethod) == null) {
+          StudentServiceGrpc.getGetStudentStreamMethod = getGetStudentStreamMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetStudentStream"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("GetStudentStream"))
+              .build();
+        }
+      }
+    }
+    return getGetStudentStreamMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendStudentStreamMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SendStudentStream",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendStudentStreamMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getSendStudentStreamMethod;
+    if ((getSendStudentStreamMethod = StudentServiceGrpc.getSendStudentStreamMethod) == null) {
+      synchronized (StudentServiceGrpc.class) {
+        if ((getSendStudentStreamMethod = StudentServiceGrpc.getSendStudentStreamMethod) == null) {
+          StudentServiceGrpc.getSendStudentStreamMethod = getSendStudentStreamMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SendStudentStream"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("SendStudentStream"))
+              .build();
+        }
+      }
+    }
+    return getSendStudentStreamMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendAndGetStudentStreamMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SendAndGetStudentStream",
+      requestType = StudentRequest.class,
+      responseType = StudentResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<StudentRequest,
+      StudentResponse> getSendAndGetStudentStreamMethod() {
+    io.grpc.MethodDescriptor<StudentRequest, StudentResponse> getSendAndGetStudentStreamMethod;
+    if ((getSendAndGetStudentStreamMethod = StudentServiceGrpc.getSendAndGetStudentStreamMethod) == null) {
+      synchronized (StudentServiceGrpc.class) {
+        if ((getSendAndGetStudentStreamMethod = StudentServiceGrpc.getSendAndGetStudentStreamMethod) == null) {
+          StudentServiceGrpc.getSendAndGetStudentStreamMethod = getSendAndGetStudentStreamMethod =
+              io.grpc.MethodDescriptor.<StudentRequest, StudentResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SendAndGetStudentStream"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  StudentResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new StudentServiceMethodDescriptorSupplier("SendAndGetStudentStream"))
+              .build();
+        }
+      }
+    }
+    return getSendAndGetStudentStreamMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static StudentServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<StudentServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<StudentServiceStub>() {
+        @Override
+        public StudentServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new StudentServiceStub(channel, callOptions);
+        }
+      };
+    return StudentServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static StudentServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<StudentServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<StudentServiceBlockingStub>() {
+        @Override
+        public StudentServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new StudentServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return StudentServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static StudentServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<StudentServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<StudentServiceFutureStub>() {
+        @Override
+        public StudentServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new StudentServiceFutureStub(channel, callOptions);
+        }
+      };
+    return StudentServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public static abstract class StudentServiceImplBase implements io.grpc.BindableService {
+
+    /**
+     */
+    public void getStudent(StudentRequest request,
+                           io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStudentMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public void getStudentStream(StudentRequest request,
+                                 io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetStudentStreamMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getSendStudentStreamMethod(), responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendAndGetStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getSendAndGetStudentStreamMethod(), responseObserver);
+    }
+
+    @Override public final io.grpc.ServerServiceDefinition bindService() {
+      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+          .addMethod(
+            getGetStudentMethod(),
+            io.grpc.stub.ServerCalls.asyncUnaryCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_GET_STUDENT)))
+          .addMethod(
+            getGetStudentStreamMethod(),
+            io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_GET_STUDENT_STREAM)))
+          .addMethod(
+            getSendStudentStreamMethod(),
+            io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_SEND_STUDENT_STREAM)))
+          .addMethod(
+            getSendAndGetStudentStreamMethod(),
+            io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+              new MethodHandlers<
+                StudentRequest,
+                StudentResponse>(
+                  this, METHODID_SEND_AND_GET_STUDENT_STREAM)))
+          .build();
+    }
+  }
+
+  /**
+   */
+  public static final class StudentServiceStub extends io.grpc.stub.AbstractAsyncStub<StudentServiceStub> {
+    private StudentServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @Override
+    protected StudentServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new StudentServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void getStudent(StudentRequest request,
+                           io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetStudentMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void getStudentStream(StudentRequest request,
+                                 io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getGetStudentStreamMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getSendStudentStreamMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<StudentRequest> sendAndGetStudentStream(
+        io.grpc.stub.StreamObserver<StudentResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getSendAndGetStudentStreamMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   */
+  public static final class StudentServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub<StudentServiceBlockingStub> {
+    private StudentServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @Override
+    protected StudentServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new StudentServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public StudentResponse getStudent(StudentRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetStudentMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public java.util.Iterator<StudentResponse> getStudentStream(
+        StudentRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getGetStudentStreamMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   */
+  public static final class StudentServiceFutureStub extends io.grpc.stub.AbstractFutureStub<StudentServiceFutureStub> {
+    private StudentServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @Override
+    protected StudentServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new StudentServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<StudentResponse> getStudent(
+        StudentRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetStudentMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_STUDENT = 0;
+  private static final int METHODID_GET_STUDENT_STREAM = 1;
+  private static final int METHODID_SEND_STUDENT_STREAM = 2;
+  private static final int METHODID_SEND_AND_GET_STUDENT_STREAM = 3;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final StudentServiceImplBase serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(StudentServiceImplBase serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_STUDENT:
+          serviceImpl.getStudent((StudentRequest) request,
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+          break;
+        case METHODID_GET_STUDENT_STREAM:
+          serviceImpl.getStudentStream((StudentRequest) request,
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_SEND_STUDENT_STREAM:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.sendStudentStream(
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+        case METHODID_SEND_AND_GET_STUDENT_STREAM:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.sendAndGetStudentStream(
+              (io.grpc.stub.StreamObserver<StudentResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  private static abstract class StudentServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    StudentServiceBaseDescriptorSupplier() {}
+
+    @Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return Student.getDescriptor();
+    }
+
+    @Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("StudentService");
+    }
+  }
+
+  private static final class StudentServiceFileDescriptorSupplier
+      extends StudentServiceBaseDescriptorSupplier {
+    StudentServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class StudentServiceMethodDescriptorSupplier
+      extends StudentServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final String methodName;
+
+    StudentServiceMethodDescriptorSupplier(String methodName) {
+      this.methodName = methodName;
+    }
+
+    @Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (StudentServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new StudentServiceFileDescriptorSupplier())
+              .addMethod(getGetStudentMethod())
+              .addMethod(getGetStudentStreamMethod())
+              .addMethod(getSendStudentStreamMethod())
+              .addMethod(getSendAndGetStudentStreamMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc.apk-conf b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc.apk-conf
new file mode 100644
index 0000000000..4d291742b7
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc.apk-conf
@@ -0,0 +1,28 @@
+---
+name: "demo-grpc-api"
+basePath: "/dineth.grpc.api"
+version: "v1"
+type: "GRPC"
+id: "grpc-basic-api"
+endpointConfigurations:
+  production:
+    endpoint: "http://grpc-backend:6565"
+defaultVersion: false
+subscriptionValidation: false
+operations:
+- target: "student.StudentService"
+  verb: "GetStudent"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "GetStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendAndGetStudentStream"
+  secured: true
+  scopes: []
\ No newline at end of file
diff --git a/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_scopes.apk-conf b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_scopes.apk-conf
new file mode 100644
index 0000000000..c4edb6983f
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_scopes.apk-conf
@@ -0,0 +1,28 @@
+---
+name: "demo-grpc-api"
+basePath: "/dineth.grpc.api"
+version: "v1"
+type: "GRPC"
+id: "grpc-scopes"
+endpointConfigurations:
+  production:
+    endpoint: "http://grpc-backend:6565"
+defaultVersion: false
+subscriptionValidation: false
+operations:
+- target: "student.StudentService"
+  verb: "GetStudent"
+  secured: true
+  scopes: ["wso2"]
+- target: "student.StudentService"
+  verb: "GetStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendAndGetStudentStream"
+  secured: true
+  scopes: []
\ No newline at end of file
diff --git a/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_default_version.apk-conf b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_default_version.apk-conf
new file mode 100644
index 0000000000..2c2f88441c
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_default_version.apk-conf
@@ -0,0 +1,28 @@
+---
+name: "demo-grpc-api"
+basePath: "/dineth.grpc.api"
+version: "v1"
+type: "GRPC"
+id: "grpc-default-version-api"
+endpointConfigurations:
+  production:
+    endpoint: "http://grpc-backend:6565"
+defaultVersion: true
+subscriptionValidation: false
+operations:
+- target: "student.StudentService"
+  verb: "GetStudent"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "GetStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendAndGetStudentStream"
+  secured: true
+  scopes: []
\ No newline at end of file
diff --git a/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_disabled_auth.apk-conf b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_disabled_auth.apk-conf
new file mode 100644
index 0000000000..50bdc465ba
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_disabled_auth.apk-conf
@@ -0,0 +1,32 @@
+---
+name: "demo-grpc-api"
+basePath: "/dineth.grpc.api"
+version: "v1"
+type: "GRPC"
+id: "grpc-auth-disabled-api"
+endpointConfigurations:
+  production:
+    endpoint: "http://grpc-backend:6565"
+defaultVersion: false
+subscriptionValidation: false
+operations:
+- target: "student.StudentService"
+  verb: "GetStudent"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "GetStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendAndGetStudentStream"
+  secured: true
+  scopes: []
+authentication:
+  - authType: OAuth2
+    required: mandatory
+    enabled: false
diff --git a/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_mtls_mandatory_oauth2_disabled.apk-conf b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_mtls_mandatory_oauth2_disabled.apk-conf
new file mode 100644
index 0000000000..8341e90952
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_mtls_mandatory_oauth2_disabled.apk-conf
@@ -0,0 +1,36 @@
+---
+name: "demo-grpc-api"
+basePath: "/dineth.grpc.api"
+version: "v1"
+type: "GRPC"
+id: "grpc-mtls-mandatory-oauth2-disabled"
+endpointConfigurations:
+  production:
+    endpoint: "http://grpc-backend:6565"
+defaultVersion: false
+subscriptionValidation: false
+operations:
+- target: "student.StudentService"
+  verb: "GetStudent"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "GetStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendAndGetStudentStream"
+  secured: true
+  scopes: []
+authentication:
+  - authType: OAuth2
+    enabled: false
+  - authType: mTLS
+    required: mandatory
+    certificates:
+      - name: mtls-test-configmap
+        key: tls.crt
diff --git a/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_mtls_optional_oauth2_optional.apk-conf b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_mtls_optional_oauth2_optional.apk-conf
new file mode 100644
index 0000000000..57a849c5ab
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/artifacts/apk-confs/grpc/grpc_with_mtls_optional_oauth2_optional.apk-conf
@@ -0,0 +1,36 @@
+---
+name: "demo-grpc-api"
+basePath: "/dineth.grpc.api"
+version: "v1"
+type: "GRPC"
+id: "grpc-mtls-optional-oauth2-optional"
+endpointConfigurations:
+  production:
+    endpoint: "http://grpc-backend:6565"
+defaultVersion: false
+subscriptionValidation: false
+operations:
+- target: "student.StudentService"
+  verb: "GetStudent"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "GetStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendStudentStream"
+  secured: true
+  scopes: []
+- target: "student.StudentService"
+  verb: "SendAndGetStudentStream"
+  secured: true
+  scopes: []
+authentication:
+  - authType: OAuth2
+    required: optional
+  - authType: mTLS
+    required: optional
+    certificates:
+      - name: mtls-test-configmap
+        key: tls.crt
diff --git a/test/cucumber-tests/src/test/resources/artifacts/definitions/student.proto b/test/cucumber-tests/src/test/resources/artifacts/definitions/student.proto
new file mode 100644
index 0000000000..885c45cfbb
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/artifacts/definitions/student.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "org.example";
+package dineth.grpc.api.v1.student;
+
+service StudentService {
+  rpc GetStudent(StudentRequest) returns (StudentResponse) {};
+  rpc GetStudentStream(StudentRequest) returns (stream StudentResponse) {};
+  rpc SendStudentStream(stream StudentRequest) returns (StudentResponse) {};
+  rpc SendAndGetStudentStream(stream StudentRequest) returns (stream StudentResponse) {}
+}
+
+message StudentRequest {
+  int32 id = 3;
+}
+
+message StudentResponse {
+  string name = 1;
+  int32 age = 2;
+}
diff --git a/test/cucumber-tests/src/test/resources/tests/api/GRPC.feature b/test/cucumber-tests/src/test/resources/tests/api/GRPC.feature
new file mode 100644
index 0000000000..873ad7c48e
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/tests/api/GRPC.feature
@@ -0,0 +1,115 @@
+Feature: Generating APK conf for gRPC API
+    Scenario: Generating APK conf using a valid GRPC API definition
+        Given The system is ready
+        When I use the definition file "artifacts/definitions/student.proto" in resources
+        And generate the APK conf file for a "gRPC" API
+        Then the response status code should be 200
+
+    Scenario: Deploying APK conf using a valid gRPC API definition
+        Given The system is ready
+        And I have a valid subscription
+        When I use the APK Conf file "artifacts/apk-confs/grpc/grpc.apk-conf"
+        And the definition file "artifacts/definitions/student.proto"
+        And make the API deployment request
+        Then the response status code should be 200
+        Then I set headers
+            | Authorization | bearer ${accessToken} |
+        And I make grpc request GetStudent to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 0
+        And the student response body should contain name: "Dineth" age: 10
+
+    Scenario: Undeploy API
+        Given The system is ready
+        And I have a valid subscription
+        When I undeploy the API whose ID is "grpc-basic-api"
+        Then the response status code should be 202
+
+    Scenario: Checking api-definition endpoint to get proto file
+        Given The system is ready
+        And I have a valid subscription
+        When I use the APK Conf file "artifacts/apk-confs/grpc/grpc.apk-conf"
+        And the definition file "artifacts/definitions/student.proto"
+        And make the API deployment request
+        Then the response status code should be 200
+        Then I set headers
+            | Authorization | bearer ${accessToken} |
+            | Host          | default.gw.wso2.com   |
+        And I send "GET" request to "https://default.gw.wso2.com:9095/dineth.grpc.api.v1/api-definition/" with body ""
+        And I eventually receive 200 response code, not accepting
+            | 429 |
+            | 500 |
+        And the response body should contain endpoint definition for student.proto
+
+
+    Scenario: Undeploy API
+        Given The system is ready
+        And I have a valid subscription
+        When I undeploy the API whose ID is "grpc-basic-api"
+        Then the response status code should be 202
+
+    Scenario: Deploying gRPC API with OAuth2 disabled
+        Given The system is ready
+        And I have a valid subscription
+        When I use the APK Conf file "artifacts/apk-confs/grpc/grpc_with_disabled_auth.apk-conf"
+        And the definition file "artifacts/definitions/student.proto"
+        And make the API deployment request
+        Then the response status code should be 200
+        And I make grpc request GetStudent to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 0
+        And the student response body should contain name: "Dineth" age: 10
+
+    Scenario: Undeploy API
+        Given The system is ready
+        And I have a valid subscription
+        When I undeploy the API whose ID is "grpc-auth-disabled-api"
+        Then the response status code should be 202
+
+    Scenario: Deploying gRPC API with scopes
+        Given The system is ready
+        And I have a valid subscription
+        When I use the APK Conf file "artifacts/apk-confs/grpc/grpc_scopes.apk-conf"
+        And the definition file "artifacts/definitions/student.proto"
+        And make the API deployment request
+        Then the response status code should be 200
+        Then I set headers
+            | Authorization | bearer ${accessToken} |
+        And I make grpc request GetStudent to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 7
+        Given I have a valid subscription with scopes
+            | wso2 |
+        Then I set headers
+            | Authorization | bearer ${accessToken} |
+        And I make grpc request GetStudent to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 0
+        And the student response body should contain name: "Dineth" age: 10
+
+    Scenario: Undeploy API
+        Given The system is ready
+        And I have a valid subscription
+        When I undeploy the API whose ID is "grpc-scopes"
+        Then the response status code should be 202
+
+    Scenario: Deploying gRPC API with default version enabled
+        Given The system is ready
+        And I have a valid subscription
+        When I use the APK Conf file "artifacts/apk-confs/grpc/grpc_with_default_version.apk-conf"
+        And the definition file "artifacts/definitions/student.proto"
+        And make the API deployment request
+        Then the response status code should be 200
+        Then I set headers
+            | Authorization | bearer ${accessToken} |
+        And I make grpc request GetStudent to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 0
+        And the student response body should contain name: "Dineth" age: 10
+        Given I have a valid subscription
+        Then I set headers
+            | Authorization | bearer ${accessToken} |
+        And I make grpc request GetStudent default version to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 0
+        And the student response body should contain name: "Dineth" age: 10
+
+    Scenario: Undeploy API
+        Given The system is ready
+        And I have a valid subscription
+        When I undeploy the API whose ID is "grpc-default-version-api"
+        Then the response status code should be 202
\ No newline at end of file
diff --git a/test/cucumber-tests/src/test/resources/tests/api/GRPCMTLS.feature b/test/cucumber-tests/src/test/resources/tests/api/GRPCMTLS.feature
new file mode 100644
index 0000000000..87fa0fac0f
--- /dev/null
+++ b/test/cucumber-tests/src/test/resources/tests/api/GRPCMTLS.feature
@@ -0,0 +1,38 @@
+Feature: Test mTLS between client and gateway with client certificate sent in header
+    Scenario: Test API with mandatory mTLS and OAuth2 disabled
+        Given The system is ready
+        And I have a valid token with a client certificate "invalid-cert.txt"
+        When I use the APK Conf file "artifacts/apk-confs/grpc/grpc_with_mtls_mandatory_oauth2_disabled.apk-conf"
+        And the definition file "artifacts/definitions/student.proto"
+        And make the API deployment request
+        Then the response status code should be 200
+        Then I set headers
+            | X-WSO2-CLIENT-CERTIFICATE | ${clientCertificate} |
+        And I make grpc request GetStudent to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 0
+        And the student response body should contain name: "Dineth" age: 10
+
+    Scenario: Undeploy API
+        Given The system is ready
+        And I have a valid subscription
+        When I undeploy the API whose ID is "grpc-mtls-mandatory-oauth2-disabled"
+        Then the response status code should be 202
+
+    Scenario: Test optional mTLS and optional OAuth2 with an invalid client certificate and invalid token in header
+        Given The system is ready
+        And I have a valid token with a client certificate "invalid-cert.txt"
+        When I use the APK Conf file "artifacts/apk-confs/grpc/grpc_with_mtls_optional_oauth2_optional.apk-conf"
+        And the definition file "artifacts/definitions/student.proto"
+        And make the API deployment request
+        Then the response status code should be 200
+        Then I set headers
+            | X-WSO2-CLIENT-CERTIFICATE | ${clientCertificate} |
+            | Authorization             | bearer {accessToken} |
+        And I make grpc request GetStudent to "default.gw.wso2.com" with port 9095
+        And the gRPC response status code should be 16
+
+    Scenario: Undeploy API
+        Given The system is ready
+        And I have a valid subscription
+        When I undeploy the API whose ID is "grpc-mtls-optional-oauth2-optional"
+        Then the response status code should be 202
diff --git a/test/integration/integration/tests/grpc-api.go b/test/integration/integration/tests/grpc-api.go
new file mode 100644
index 0000000000..43632c1f9b
--- /dev/null
+++ b/test/integration/integration/tests/grpc-api.go
@@ -0,0 +1,76 @@
+/*
+ *  Copyright (c) 2024, WSO2 LLC. (http://www.wso2.org) All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package tests
+
+import (
+	"github.com/wso2/apk/test/integration/integration/utils/grpc-code/student"
+	"github.com/wso2/apk/test/integration/integration/utils/grpc-code/student_default_version"
+	"github.com/wso2/apk/test/integration/integration/utils/grpcutils"
+	"github.com/wso2/apk/test/integration/integration/utils/suite"
+	"testing"
+)
+
+func init() {
+	IntegrationTests = append(IntegrationTests, GRPCAPI)
+}
+
+// GRPCAPI tests gRPC API
+var GRPCAPI = suite.IntegrationTest{
+	ShortName:   "GRPCAPI",
+	Description: "Tests gRPC API",
+	Manifests:   []string{"tests/grpc-api.yaml"},
+	Test: func(t *testing.T, suite *suite.IntegrationTestSuite) {
+		gwAddr := "grpc.test.gw.wso2.com:9095"
+
+		testCases := []grpcutils.GRPCTestCase{
+			{
+				ExpectedResponse: grpcutils.ExpectedResponse{
+					Out: &student.StudentResponse{
+						Name: "Dineth",
+						Age:  10,
+					},
+					Err: nil,
+				},
+				ActualResponse: &student.StudentResponse{},
+				Name:           "Get Student Details",
+				Method:         student.GetStudent,
+				Satisfier:      student.StudentResponseSatisfier{},
+			},
+			{
+				ExpectedResponse: grpcutils.ExpectedResponse{
+					Out: &student_default_version.StudentResponse{
+						Name: "Dineth",
+						Age:  10,
+					},
+					Err: nil,
+				},
+				ActualResponse: &student_default_version.StudentResponse{},
+				Name:           "Get Student Details (Default API Version)",
+				Method:         student_default_version.GetStudent,
+				Satisfier:      student_default_version.StudentResponseSatisfier{},
+			},
+		}
+		for i := range testCases {
+			tc := testCases[i]
+			t.Run("Invoke gRPC API", func(t *testing.T) {
+				t.Parallel()
+				grpcutils.InvokeGRPCClientUntilSatisfied(gwAddr, t, tc, tc.Satisfier, tc.Method)
+			})
+		}
+	},
+}
diff --git a/test/integration/integration/tests/resources/base/manifests.yaml b/test/integration/integration/tests/resources/base/manifests.yaml
index 5d4ef24606..58883fa983 100644
--- a/test/integration/integration/tests/resources/base/manifests.yaml
+++ b/test/integration/integration/tests/resources/base/manifests.yaml
@@ -113,6 +113,53 @@ spec:
 ---
 apiVersion: v1
 kind: Service
+metadata:
+  name: grpc-backend-v1
+  namespace: gateway-integration-test-infra
+spec:
+  selector:
+    app: grpc-backend-v1
+  ports:
+    - protocol: TCP
+      port: 6565
+      targetPort: 6565
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: grpc-backend-v1
+  namespace: gateway-integration-test-infra
+  labels:
+    app: grpc-backend-v1
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: grpc-backend-v1
+  template:
+    metadata:
+      labels:
+        app: grpc-backend-v1
+    spec:
+      containers:
+        - name: grpc-backend-v1
+          image: ddh13/dineth-grpc-demo-server:1.0.0
+          imagePullPolicy: Always
+          env:
+            - name: POD_NAME
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.name
+            - name: NAMESPACE
+              valueFrom:
+                fieldRef:
+                  fieldPath: metadata.namespace
+          resources:
+            requests:
+              cpu: 10m
+---
+apiVersion: v1
+kind: Service
 metadata:
   name: infra-backend-v2
   namespace: gateway-integration-test-infra
diff --git a/test/integration/integration/tests/resources/tests/grpc-api.yaml b/test/integration/integration/tests/resources/tests/grpc-api.yaml
new file mode 100644
index 0000000000..6329c87770
--- /dev/null
+++ b/test/integration/integration/tests/resources/tests/grpc-api.yaml
@@ -0,0 +1,109 @@
+# Copyright (c) 2024, WSO2 LLC. (https://www.wso2.com) All Rights Reserved.
+#
+# WSO2 LLC. licenses this file to you under the Apache License,
+# Version 2.0 (the "License"); you may not use this file except
+# in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+apiVersion: dp.wso2.com/v1alpha2
+kind: API
+metadata:
+  name: grpc-api
+  namespace: gateway-integration-test-infra
+spec:
+  apiName: GRPC API
+  apiType: GRPC
+  apiVersion: v1
+  basePath: /dineth.grpc.api.v1
+  isDefaultVersion: true
+  production:
+    - routeRefs:
+        - grpc-api-grpcroute
+  organization: wso2-org
+
+---
+
+apiVersion: gateway.networking.k8s.io/v1alpha2
+kind: GRPCRoute
+metadata:
+  name: grpc-api-grpcroute
+  namespace: gateway-integration-test-infra
+spec:
+  parentRefs:
+    - group: gateway.networking.k8s.io
+      kind: Gateway
+      name: wso2-apk-default
+      namespace: apk-integration-test
+      sectionName: httpslistener
+  hostnames:
+    - grpc.test.gw.wso2.com
+  rules:
+    - matches:
+        - method:
+            service: student.StudentService
+            method: GetStudent
+      backendRefs:
+        - name: grpc-backend-v1
+          kind: Backend
+          port: 6565
+    - matches:
+        - method:
+            service: student.StudentService
+            method: SendStudentStream
+      backendRefs:
+        - name: grpc-backend-v1
+          kind: Backend
+          port: 6565
+    - matches:
+        - method:
+            service: student.StudentService
+            method: GetStudentStream
+      backendRefs:
+        - name: grpc-backend-v1
+          kind: Backend
+          port: 6565
+    - matches:
+        - method:
+            service: student.StudentService
+            method: SendAndGetStudentStream
+      backendRefs:
+        - name: grpc-backend-v1
+          kind: Backend
+          port: 6565
+
+---
+
+apiVersion: dp.wso2.com/v1alpha1
+kind: Authentication
+metadata:
+  name: disable-grpc-api-security
+  namespace: gateway-integration-test-infra
+spec:
+  override:
+    disabled: true
+  targetRef:
+    group: gateway.networking.k8s.io
+    kind: API
+    namespace: gateway-integration-test-infra
+    name: grpc-api
+---
+apiVersion: dp.wso2.com/v1alpha1
+kind: Backend
+metadata:
+  name: grpc-backend-v1
+  namespace: gateway-integration-test-infra
+spec:
+  services:
+    - host: grpc-backend-v1.gateway-integration-test-infra
+      port: 6565
+  basePath: ""
+  protocol: http
diff --git a/test/integration/integration/utils/grpc-code/student/student.go b/test/integration/integration/utils/grpc-code/student/student.go
new file mode 100644
index 0000000000..36143eb56c
--- /dev/null
+++ b/test/integration/integration/utils/grpc-code/student/student.go
@@ -0,0 +1,46 @@
+package student
+
+import (
+	"context"
+	"github.com/wso2/apk/test/integration/integration/utils/grpcutils"
+	"google.golang.org/grpc"
+	"log"
+	"time"
+)
+
+type StudentResponseSatisfier struct{}
+
+// IsSatisfactory checks if the given response is satisfactory based on the expected response.
+func (srs StudentResponseSatisfier) IsSatisfactory(response any, expectedResponse grpcutils.ExpectedResponse) bool {
+	// Type assert the response to *student.StudentResponse
+	resp, respOk := response.(*StudentResponse)
+	if !respOk {
+		log.Println("Failed to assert response as *student.StudentResponse")
+		return false
+	}
+	// Type assert the expected output to *student.StudentResponse
+	expectedResp, expOk := expectedResponse.Out.(*StudentResponse)
+	if !expOk {
+		log.Println("Failed to assert expectedResponse.Out as *student.StudentResponse")
+		return false
+	}
+
+	// Compare the actual response with the expected response
+	if resp.Name == expectedResp.Name && resp.Age == expectedResp.Age {
+		return true
+	} else {
+		log.Println("Response does not match the expected output")
+		return false
+	}
+}
+func GetStudent(conn *grpc.ClientConn) (any, error) {
+	c := NewStudentServiceClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	r := &StudentRequest{Id: 1234}
+	response, err := c.GetStudent(ctx, r)
+	if err != nil {
+		return nil, err
+	}
+	return response, nil
+}
diff --git a/test/integration/integration/utils/grpc-code/student/student.pb.go b/test/integration/integration/utils/grpc-code/student/student.pb.go
new file mode 100644
index 0000000000..c8efeffa3a
--- /dev/null
+++ b/test/integration/integration/utils/grpc-code/student/student.pb.go
@@ -0,0 +1,254 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.33.0
+// 	protoc        v3.12.4
+// source: student.proto
+
+package student
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type StudentRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id int32 `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (x *StudentRequest) Reset() {
+	*x = StudentRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_student_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StudentRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StudentRequest) ProtoMessage() {}
+
+func (x *StudentRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_student_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StudentRequest.ProtoReflect.Descriptor instead.
+func (*StudentRequest) Descriptor() ([]byte, []int) {
+	return file_student_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *StudentRequest) GetId() int32 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+type StudentResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Age  int32  `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
+}
+
+func (x *StudentResponse) Reset() {
+	*x = StudentResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_student_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StudentResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StudentResponse) ProtoMessage() {}
+
+func (x *StudentResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_student_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StudentResponse.ProtoReflect.Descriptor instead.
+func (*StudentResponse) Descriptor() ([]byte, []int) {
+	return file_student_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *StudentResponse) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *StudentResponse) GetAge() int32 {
+	if x != nil {
+		return x.Age
+	}
+	return 0
+}
+
+var File_student_proto protoreflect.FileDescriptor
+
+var file_student_proto_rawDesc = []byte{
+	0x0a, 0x0d, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+	0x1a, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69,
+	0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x22, 0x20, 0x0a, 0x0e, 0x53,
+	0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a,
+	0x02, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x22, 0x37, 0x0a,
+	0x0f, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
+	0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x05, 0x52, 0x03, 0x61, 0x67, 0x65, 0x32, 0xd6, 0x03, 0x0a, 0x0e, 0x53, 0x74, 0x75, 0x64, 0x65,
+	0x6e, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x67, 0x0a, 0x0a, 0x47, 0x65, 0x74,
+	0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x12, 0x2a, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68,
+	0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74, 0x75,
+	0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70,
+	0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74,
+	0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x12, 0x6f, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74,
+	0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x2a, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e,
+	0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74, 0x75, 0x64,
+	0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63,
+	0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e,
+	0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
+	0x00, 0x30, 0x01, 0x12, 0x70, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x75, 0x64, 0x65,
+	0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x2a, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74,
+	0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74,
+	0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72,
+	0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e,
+	0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x00, 0x28, 0x01, 0x12, 0x78, 0x0a, 0x17, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x64,
+	0x47, 0x65, 0x74, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d,
+	0x12, 0x2a, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61,
+	0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74,
+	0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x64,
+	0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x76,
+	0x31, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e,
+	0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x42,
+	0x30, 0x5a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67,
+	0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c,
+	0x65, 0x73, 0x2f, 0x73, 0x63, 0x68, 0x6f, 0x6f, 0x6c, 0x2f, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e,
+	0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_student_proto_rawDescOnce sync.Once
+	file_student_proto_rawDescData = file_student_proto_rawDesc
+)
+
+func file_student_proto_rawDescGZIP() []byte {
+	file_student_proto_rawDescOnce.Do(func() {
+		file_student_proto_rawDescData = protoimpl.X.CompressGZIP(file_student_proto_rawDescData)
+	})
+	return file_student_proto_rawDescData
+}
+
+var file_student_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_student_proto_goTypes = []interface{}{
+	(*StudentRequest)(nil),  // 0: dineth.grpc.api.v1.student.StudentRequest
+	(*StudentResponse)(nil), // 1: dineth.grpc.api.v1.student.StudentResponse
+}
+var file_student_proto_depIdxs = []int32{
+	0, // 0: dineth.grpc.api.v1.student.StudentService.GetStudent:input_type -> dineth.grpc.api.v1.student.StudentRequest
+	0, // 1: dineth.grpc.api.v1.student.StudentService.GetStudentStream:input_type -> dineth.grpc.api.v1.student.StudentRequest
+	0, // 2: dineth.grpc.api.v1.student.StudentService.SendStudentStream:input_type -> dineth.grpc.api.v1.student.StudentRequest
+	0, // 3: dineth.grpc.api.v1.student.StudentService.SendAndGetStudentStream:input_type -> dineth.grpc.api.v1.student.StudentRequest
+	1, // 4: dineth.grpc.api.v1.student.StudentService.GetStudent:output_type -> dineth.grpc.api.v1.student.StudentResponse
+	1, // 5: dineth.grpc.api.v1.student.StudentService.GetStudentStream:output_type -> dineth.grpc.api.v1.student.StudentResponse
+	1, // 6: dineth.grpc.api.v1.student.StudentService.SendStudentStream:output_type -> dineth.grpc.api.v1.student.StudentResponse
+	1, // 7: dineth.grpc.api.v1.student.StudentService.SendAndGetStudentStream:output_type -> dineth.grpc.api.v1.student.StudentResponse
+	4, // [4:8] is the sub-list for method output_type
+	0, // [0:4] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_student_proto_init() }
+func file_student_proto_init() {
+	if File_student_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_student_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*StudentRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_student_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*StudentResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_student_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_student_proto_goTypes,
+		DependencyIndexes: file_student_proto_depIdxs,
+		MessageInfos:      file_student_proto_msgTypes,
+	}.Build()
+	File_student_proto = out.File
+	file_student_proto_rawDesc = nil
+	file_student_proto_goTypes = nil
+	file_student_proto_depIdxs = nil
+}
diff --git a/test/integration/integration/utils/grpc-code/student/student_grpc.pb.go b/test/integration/integration/utils/grpc-code/student/student_grpc.pb.go
new file mode 100644
index 0000000000..be4b29e7dd
--- /dev/null
+++ b/test/integration/integration/utils/grpc-code/student/student_grpc.pb.go
@@ -0,0 +1,314 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc             v3.12.4
+// source: student.proto
+
+package student
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+	StudentService_GetStudent_FullMethodName              = "/dineth.grpc.api.v1.student.StudentService/GetStudent"
+	StudentService_GetStudentStream_FullMethodName        = "/dineth.grpc.api.v1.student.StudentService/GetStudentStream"
+	StudentService_SendStudentStream_FullMethodName       = "/dineth.grpc.api.v1.student.StudentService/SendStudentStream"
+	StudentService_SendAndGetStudentStream_FullMethodName = "/dineth.grpc.api.v1.student.StudentService/SendAndGetStudentStream"
+)
+
+// StudentServiceClient is the client API for StudentService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type StudentServiceClient interface {
+	GetStudent(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (*StudentResponse, error)
+	GetStudentStream(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (StudentService_GetStudentStreamClient, error)
+	SendStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendStudentStreamClient, error)
+	SendAndGetStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendAndGetStudentStreamClient, error)
+}
+
+type studentServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewStudentServiceClient(cc grpc.ClientConnInterface) StudentServiceClient {
+	return &studentServiceClient{cc}
+}
+
+func (c *studentServiceClient) GetStudent(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (*StudentResponse, error) {
+	out := new(StudentResponse)
+	err := c.cc.Invoke(ctx, StudentService_GetStudent_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *studentServiceClient) GetStudentStream(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (StudentService_GetStudentStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, &StudentService_ServiceDesc.Streams[0], StudentService_GetStudentStream_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &studentServiceGetStudentStreamClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type StudentService_GetStudentStreamClient interface {
+	Recv() (*StudentResponse, error)
+	grpc.ClientStream
+}
+
+type studentServiceGetStudentStreamClient struct {
+	grpc.ClientStream
+}
+
+func (x *studentServiceGetStudentStreamClient) Recv() (*StudentResponse, error) {
+	m := new(StudentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *studentServiceClient) SendStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendStudentStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, &StudentService_ServiceDesc.Streams[1], StudentService_SendStudentStream_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &studentServiceSendStudentStreamClient{stream}
+	return x, nil
+}
+
+type StudentService_SendStudentStreamClient interface {
+	Send(*StudentRequest) error
+	CloseAndRecv() (*StudentResponse, error)
+	grpc.ClientStream
+}
+
+type studentServiceSendStudentStreamClient struct {
+	grpc.ClientStream
+}
+
+func (x *studentServiceSendStudentStreamClient) Send(m *StudentRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *studentServiceSendStudentStreamClient) CloseAndRecv() (*StudentResponse, error) {
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	m := new(StudentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *studentServiceClient) SendAndGetStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendAndGetStudentStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, &StudentService_ServiceDesc.Streams[2], StudentService_SendAndGetStudentStream_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &studentServiceSendAndGetStudentStreamClient{stream}
+	return x, nil
+}
+
+type StudentService_SendAndGetStudentStreamClient interface {
+	Send(*StudentRequest) error
+	Recv() (*StudentResponse, error)
+	grpc.ClientStream
+}
+
+type studentServiceSendAndGetStudentStreamClient struct {
+	grpc.ClientStream
+}
+
+func (x *studentServiceSendAndGetStudentStreamClient) Send(m *StudentRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *studentServiceSendAndGetStudentStreamClient) Recv() (*StudentResponse, error) {
+	m := new(StudentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// StudentServiceServer is the server API for StudentService service.
+// All implementations must embed UnimplementedStudentServiceServer
+// for forward compatibility
+type StudentServiceServer interface {
+	GetStudent(context.Context, *StudentRequest) (*StudentResponse, error)
+	GetStudentStream(*StudentRequest, StudentService_GetStudentStreamServer) error
+	SendStudentStream(StudentService_SendStudentStreamServer) error
+	SendAndGetStudentStream(StudentService_SendAndGetStudentStreamServer) error
+	mustEmbedUnimplementedStudentServiceServer()
+}
+
+// UnimplementedStudentServiceServer must be embedded to have forward compatible implementations.
+type UnimplementedStudentServiceServer struct {
+}
+
+func (UnimplementedStudentServiceServer) GetStudent(context.Context, *StudentRequest) (*StudentResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetStudent not implemented")
+}
+func (UnimplementedStudentServiceServer) GetStudentStream(*StudentRequest, StudentService_GetStudentStreamServer) error {
+	return status.Errorf(codes.Unimplemented, "method GetStudentStream not implemented")
+}
+func (UnimplementedStudentServiceServer) SendStudentStream(StudentService_SendStudentStreamServer) error {
+	return status.Errorf(codes.Unimplemented, "method SendStudentStream not implemented")
+}
+func (UnimplementedStudentServiceServer) SendAndGetStudentStream(StudentService_SendAndGetStudentStreamServer) error {
+	return status.Errorf(codes.Unimplemented, "method SendAndGetStudentStream not implemented")
+}
+func (UnimplementedStudentServiceServer) mustEmbedUnimplementedStudentServiceServer() {}
+
+// UnsafeStudentServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to StudentServiceServer will
+// result in compilation errors.
+type UnsafeStudentServiceServer interface {
+	mustEmbedUnimplementedStudentServiceServer()
+}
+
+func RegisterStudentServiceServer(s grpc.ServiceRegistrar, srv StudentServiceServer) {
+	s.RegisterService(&StudentService_ServiceDesc, srv)
+}
+
+func _StudentService_GetStudent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StudentRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StudentServiceServer).GetStudent(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: StudentService_GetStudent_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StudentServiceServer).GetStudent(ctx, req.(*StudentRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _StudentService_GetStudentStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(StudentRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(StudentServiceServer).GetStudentStream(m, &studentServiceGetStudentStreamServer{stream})
+}
+
+type StudentService_GetStudentStreamServer interface {
+	Send(*StudentResponse) error
+	grpc.ServerStream
+}
+
+type studentServiceGetStudentStreamServer struct {
+	grpc.ServerStream
+}
+
+func (x *studentServiceGetStudentStreamServer) Send(m *StudentResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _StudentService_SendStudentStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(StudentServiceServer).SendStudentStream(&studentServiceSendStudentStreamServer{stream})
+}
+
+type StudentService_SendStudentStreamServer interface {
+	SendAndClose(*StudentResponse) error
+	Recv() (*StudentRequest, error)
+	grpc.ServerStream
+}
+
+type studentServiceSendStudentStreamServer struct {
+	grpc.ServerStream
+}
+
+func (x *studentServiceSendStudentStreamServer) SendAndClose(m *StudentResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *studentServiceSendStudentStreamServer) Recv() (*StudentRequest, error) {
+	m := new(StudentRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _StudentService_SendAndGetStudentStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(StudentServiceServer).SendAndGetStudentStream(&studentServiceSendAndGetStudentStreamServer{stream})
+}
+
+type StudentService_SendAndGetStudentStreamServer interface {
+	Send(*StudentResponse) error
+	Recv() (*StudentRequest, error)
+	grpc.ServerStream
+}
+
+type studentServiceSendAndGetStudentStreamServer struct {
+	grpc.ServerStream
+}
+
+func (x *studentServiceSendAndGetStudentStreamServer) Send(m *StudentResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *studentServiceSendAndGetStudentStreamServer) Recv() (*StudentRequest, error) {
+	m := new(StudentRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// StudentService_ServiceDesc is the grpc.ServiceDesc for StudentService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var StudentService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "dineth.grpc.api.v1.student.StudentService",
+	HandlerType: (*StudentServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetStudent",
+			Handler:    _StudentService_GetStudent_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetStudentStream",
+			Handler:       _StudentService_GetStudentStream_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "SendStudentStream",
+			Handler:       _StudentService_SendStudentStream_Handler,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "SendAndGetStudentStream",
+			Handler:       _StudentService_SendAndGetStudentStream_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "student.proto",
+}
diff --git a/test/integration/integration/utils/grpc-code/student_default_version/student2.go b/test/integration/integration/utils/grpc-code/student_default_version/student2.go
new file mode 100644
index 0000000000..939bb3b903
--- /dev/null
+++ b/test/integration/integration/utils/grpc-code/student_default_version/student2.go
@@ -0,0 +1,46 @@
+package student_default_version
+
+import (
+	"context"
+	"github.com/wso2/apk/test/integration/integration/utils/grpcutils"
+	"google.golang.org/grpc"
+	"log"
+	"time"
+)
+
+type StudentResponseSatisfier struct{}
+
+// IsSatisfactory checks if the given response is satisfactory based on the expected response.
+func (srs StudentResponseSatisfier) IsSatisfactory(response any, expectedResponse grpcutils.ExpectedResponse) bool {
+	// Type assert the response to *student.StudentResponse
+	resp, respOk := response.(*StudentResponse)
+	if !respOk {
+		log.Println("Failed to assert response as *student.StudentResponse")
+		return false
+	}
+	// Type assert the expected output to *student.StudentResponse
+	expectedResp, expOk := expectedResponse.Out.(*StudentResponse)
+	if !expOk {
+		log.Println("Failed to assert expectedResponse.Out as *student.StudentResponse")
+		return false
+	}
+
+	// Compare the actual response with the expected response
+	if resp.Name == expectedResp.Name && resp.Age == expectedResp.Age {
+		return true
+	} else {
+		log.Println("Response does not match the expected output")
+		return false
+	}
+}
+func GetStudent(conn *grpc.ClientConn) (any, error) {
+	c := NewStudentServiceClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	r := &StudentRequest{Id: 1234}
+	response, err := c.GetStudent(ctx, r)
+	if err != nil {
+		return nil, err
+	}
+	return response, nil
+}
diff --git a/test/integration/integration/utils/grpc-code/student_default_version/student_default_version.pb.go b/test/integration/integration/utils/grpc-code/student_default_version/student_default_version.pb.go
new file mode 100644
index 0000000000..a006069e84
--- /dev/null
+++ b/test/integration/integration/utils/grpc-code/student_default_version/student_default_version.pb.go
@@ -0,0 +1,251 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.33.0
+// 	protoc        v3.12.4
+// source: student_default_version.proto
+
+package student_default_version
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type StudentRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Id int32 `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (x *StudentRequest) Reset() {
+	*x = StudentRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_student_default_version_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StudentRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StudentRequest) ProtoMessage() {}
+
+func (x *StudentRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_student_default_version_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StudentRequest.ProtoReflect.Descriptor instead.
+func (*StudentRequest) Descriptor() ([]byte, []int) {
+	return file_student_default_version_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *StudentRequest) GetId() int32 {
+	if x != nil {
+		return x.Id
+	}
+	return 0
+}
+
+type StudentResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Age  int32  `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
+}
+
+func (x *StudentResponse) Reset() {
+	*x = StudentResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_student_default_version_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *StudentResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StudentResponse) ProtoMessage() {}
+
+func (x *StudentResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_student_default_version_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StudentResponse.ProtoReflect.Descriptor instead.
+func (*StudentResponse) Descriptor() ([]byte, []int) {
+	return file_student_default_version_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *StudentResponse) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *StudentResponse) GetAge() int32 {
+	if x != nil {
+		return x.Age
+	}
+	return 0
+}
+
+var File_student_default_version_proto protoreflect.FileDescriptor
+
+var file_student_default_version_proto_rawDesc = []byte{
+	0x0a, 0x1d, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+	0x74, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
+	0x17, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69,
+	0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x22, 0x20, 0x0a, 0x0e, 0x53, 0x74, 0x75, 0x64,
+	0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x22, 0x37, 0x0a, 0x0f, 0x53, 0x74,
+	0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
+	0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03,
+	0x61, 0x67, 0x65, 0x32, 0xbe, 0x03, 0x0a, 0x0e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x53,
+	0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x61, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x53, 0x74, 0x75,
+	0x64, 0x65, 0x6e, 0x74, 0x12, 0x27, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72,
+	0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53,
+	0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e,
+	0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e,
+	0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x10, 0x47, 0x65, 0x74,
+	0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x27, 0x2e,
+	0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e,
+	0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e,
+	0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74,
+	0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x30, 0x01, 0x12, 0x6a, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x75, 0x64,
+	0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x27, 0x2e, 0x64, 0x69, 0x6e, 0x65,
+	0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x73, 0x74, 0x75, 0x64,
+	0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x28, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63,
+	0x2e, 0x61, 0x70, 0x69, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75,
+	0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01,
+	0x12, 0x72, 0x0a, 0x17, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x64, 0x47, 0x65, 0x74, 0x53, 0x74,
+	0x75, 0x64, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x27, 0x2e, 0x64, 0x69,
+	0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x73, 0x74,
+	0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x64, 0x69, 0x6e, 0x65, 0x74, 0x68, 0x2e, 0x67, 0x72,
+	0x70, 0x63, 0x2e, 0x61, 0x70, 0x69, 0x2e, 0x73, 0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x2e, 0x53,
+	0x74, 0x75, 0x64, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
+	0x28, 0x01, 0x30, 0x01, 0x42, 0x0f, 0x0a, 0x0b, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x78, 0x61, 0x6d,
+	0x70, 0x6c, 0x65, 0x50, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_student_default_version_proto_rawDescOnce sync.Once
+	file_student_default_version_proto_rawDescData = file_student_default_version_proto_rawDesc
+)
+
+func file_student_default_version_proto_rawDescGZIP() []byte {
+	file_student_default_version_proto_rawDescOnce.Do(func() {
+		file_student_default_version_proto_rawDescData = protoimpl.X.CompressGZIP(file_student_default_version_proto_rawDescData)
+	})
+	return file_student_default_version_proto_rawDescData
+}
+
+var file_student_default_version_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_student_default_version_proto_goTypes = []interface{}{
+	(*StudentRequest)(nil),  // 0: dineth.grpc.api.student.StudentRequest
+	(*StudentResponse)(nil), // 1: dineth.grpc.api.student.StudentResponse
+}
+var file_student_default_version_proto_depIdxs = []int32{
+	0, // 0: dineth.grpc.api.student.StudentService.GetStudent:input_type -> dineth.grpc.api.student.StudentRequest
+	0, // 1: dineth.grpc.api.student.StudentService.GetStudentStream:input_type -> dineth.grpc.api.student.StudentRequest
+	0, // 2: dineth.grpc.api.student.StudentService.SendStudentStream:input_type -> dineth.grpc.api.student.StudentRequest
+	0, // 3: dineth.grpc.api.student.StudentService.SendAndGetStudentStream:input_type -> dineth.grpc.api.student.StudentRequest
+	1, // 4: dineth.grpc.api.student.StudentService.GetStudent:output_type -> dineth.grpc.api.student.StudentResponse
+	1, // 5: dineth.grpc.api.student.StudentService.GetStudentStream:output_type -> dineth.grpc.api.student.StudentResponse
+	1, // 6: dineth.grpc.api.student.StudentService.SendStudentStream:output_type -> dineth.grpc.api.student.StudentResponse
+	1, // 7: dineth.grpc.api.student.StudentService.SendAndGetStudentStream:output_type -> dineth.grpc.api.student.StudentResponse
+	4, // [4:8] is the sub-list for method output_type
+	0, // [0:4] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_student_default_version_proto_init() }
+func file_student_default_version_proto_init() {
+	if File_student_default_version_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_student_default_version_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*StudentRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_student_default_version_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*StudentResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_student_default_version_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_student_default_version_proto_goTypes,
+		DependencyIndexes: file_student_default_version_proto_depIdxs,
+		MessageInfos:      file_student_default_version_proto_msgTypes,
+	}.Build()
+	File_student_default_version_proto = out.File
+	file_student_default_version_proto_rawDesc = nil
+	file_student_default_version_proto_goTypes = nil
+	file_student_default_version_proto_depIdxs = nil
+}
diff --git a/test/integration/integration/utils/grpc-code/student_default_version/student_default_version_grpc.pb.go b/test/integration/integration/utils/grpc-code/student_default_version/student_default_version_grpc.pb.go
new file mode 100644
index 0000000000..b3fe9b74bb
--- /dev/null
+++ b/test/integration/integration/utils/grpc-code/student_default_version/student_default_version_grpc.pb.go
@@ -0,0 +1,314 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc             v3.12.4
+// source: student_default_version.proto
+
+package student_default_version
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+	StudentService_GetStudent_FullMethodName              = "/dineth.grpc.api.student.StudentService/GetStudent"
+	StudentService_GetStudentStream_FullMethodName        = "/dineth.grpc.api.student.StudentService/GetStudentStream"
+	StudentService_SendStudentStream_FullMethodName       = "/dineth.grpc.api.student.StudentService/SendStudentStream"
+	StudentService_SendAndGetStudentStream_FullMethodName = "/dineth.grpc.api.student.StudentService/SendAndGetStudentStream"
+)
+
+// StudentServiceClient is the client API for StudentService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type StudentServiceClient interface {
+	GetStudent(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (*StudentResponse, error)
+	GetStudentStream(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (StudentService_GetStudentStreamClient, error)
+	SendStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendStudentStreamClient, error)
+	SendAndGetStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendAndGetStudentStreamClient, error)
+}
+
+type studentServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewStudentServiceClient(cc grpc.ClientConnInterface) StudentServiceClient {
+	return &studentServiceClient{cc}
+}
+
+func (c *studentServiceClient) GetStudent(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (*StudentResponse, error) {
+	out := new(StudentResponse)
+	err := c.cc.Invoke(ctx, StudentService_GetStudent_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *studentServiceClient) GetStudentStream(ctx context.Context, in *StudentRequest, opts ...grpc.CallOption) (StudentService_GetStudentStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, &StudentService_ServiceDesc.Streams[0], StudentService_GetStudentStream_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &studentServiceGetStudentStreamClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type StudentService_GetStudentStreamClient interface {
+	Recv() (*StudentResponse, error)
+	grpc.ClientStream
+}
+
+type studentServiceGetStudentStreamClient struct {
+	grpc.ClientStream
+}
+
+func (x *studentServiceGetStudentStreamClient) Recv() (*StudentResponse, error) {
+	m := new(StudentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *studentServiceClient) SendStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendStudentStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, &StudentService_ServiceDesc.Streams[1], StudentService_SendStudentStream_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &studentServiceSendStudentStreamClient{stream}
+	return x, nil
+}
+
+type StudentService_SendStudentStreamClient interface {
+	Send(*StudentRequest) error
+	CloseAndRecv() (*StudentResponse, error)
+	grpc.ClientStream
+}
+
+type studentServiceSendStudentStreamClient struct {
+	grpc.ClientStream
+}
+
+func (x *studentServiceSendStudentStreamClient) Send(m *StudentRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *studentServiceSendStudentStreamClient) CloseAndRecv() (*StudentResponse, error) {
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	m := new(StudentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *studentServiceClient) SendAndGetStudentStream(ctx context.Context, opts ...grpc.CallOption) (StudentService_SendAndGetStudentStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, &StudentService_ServiceDesc.Streams[2], StudentService_SendAndGetStudentStream_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &studentServiceSendAndGetStudentStreamClient{stream}
+	return x, nil
+}
+
+type StudentService_SendAndGetStudentStreamClient interface {
+	Send(*StudentRequest) error
+	Recv() (*StudentResponse, error)
+	grpc.ClientStream
+}
+
+type studentServiceSendAndGetStudentStreamClient struct {
+	grpc.ClientStream
+}
+
+func (x *studentServiceSendAndGetStudentStreamClient) Send(m *StudentRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *studentServiceSendAndGetStudentStreamClient) Recv() (*StudentResponse, error) {
+	m := new(StudentResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// StudentServiceServer is the server API for StudentService service.
+// All implementations must embed UnimplementedStudentServiceServer
+// for forward compatibility
+type StudentServiceServer interface {
+	GetStudent(context.Context, *StudentRequest) (*StudentResponse, error)
+	GetStudentStream(*StudentRequest, StudentService_GetStudentStreamServer) error
+	SendStudentStream(StudentService_SendStudentStreamServer) error
+	SendAndGetStudentStream(StudentService_SendAndGetStudentStreamServer) error
+	mustEmbedUnimplementedStudentServiceServer()
+}
+
+// UnimplementedStudentServiceServer must be embedded to have forward compatible implementations.
+type UnimplementedStudentServiceServer struct {
+}
+
+func (UnimplementedStudentServiceServer) GetStudent(context.Context, *StudentRequest) (*StudentResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetStudent not implemented")
+}
+func (UnimplementedStudentServiceServer) GetStudentStream(*StudentRequest, StudentService_GetStudentStreamServer) error {
+	return status.Errorf(codes.Unimplemented, "method GetStudentStream not implemented")
+}
+func (UnimplementedStudentServiceServer) SendStudentStream(StudentService_SendStudentStreamServer) error {
+	return status.Errorf(codes.Unimplemented, "method SendStudentStream not implemented")
+}
+func (UnimplementedStudentServiceServer) SendAndGetStudentStream(StudentService_SendAndGetStudentStreamServer) error {
+	return status.Errorf(codes.Unimplemented, "method SendAndGetStudentStream not implemented")
+}
+func (UnimplementedStudentServiceServer) mustEmbedUnimplementedStudentServiceServer() {}
+
+// UnsafeStudentServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to StudentServiceServer will
+// result in compilation errors.
+type UnsafeStudentServiceServer interface {
+	mustEmbedUnimplementedStudentServiceServer()
+}
+
+func RegisterStudentServiceServer(s grpc.ServiceRegistrar, srv StudentServiceServer) {
+	s.RegisterService(&StudentService_ServiceDesc, srv)
+}
+
+func _StudentService_GetStudent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StudentRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(StudentServiceServer).GetStudent(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: StudentService_GetStudent_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(StudentServiceServer).GetStudent(ctx, req.(*StudentRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _StudentService_GetStudentStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(StudentRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(StudentServiceServer).GetStudentStream(m, &studentServiceGetStudentStreamServer{stream})
+}
+
+type StudentService_GetStudentStreamServer interface {
+	Send(*StudentResponse) error
+	grpc.ServerStream
+}
+
+type studentServiceGetStudentStreamServer struct {
+	grpc.ServerStream
+}
+
+func (x *studentServiceGetStudentStreamServer) Send(m *StudentResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _StudentService_SendStudentStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(StudentServiceServer).SendStudentStream(&studentServiceSendStudentStreamServer{stream})
+}
+
+type StudentService_SendStudentStreamServer interface {
+	SendAndClose(*StudentResponse) error
+	Recv() (*StudentRequest, error)
+	grpc.ServerStream
+}
+
+type studentServiceSendStudentStreamServer struct {
+	grpc.ServerStream
+}
+
+func (x *studentServiceSendStudentStreamServer) SendAndClose(m *StudentResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *studentServiceSendStudentStreamServer) Recv() (*StudentRequest, error) {
+	m := new(StudentRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _StudentService_SendAndGetStudentStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(StudentServiceServer).SendAndGetStudentStream(&studentServiceSendAndGetStudentStreamServer{stream})
+}
+
+type StudentService_SendAndGetStudentStreamServer interface {
+	Send(*StudentResponse) error
+	Recv() (*StudentRequest, error)
+	grpc.ServerStream
+}
+
+type studentServiceSendAndGetStudentStreamServer struct {
+	grpc.ServerStream
+}
+
+func (x *studentServiceSendAndGetStudentStreamServer) Send(m *StudentResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *studentServiceSendAndGetStudentStreamServer) Recv() (*StudentRequest, error) {
+	m := new(StudentRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// StudentService_ServiceDesc is the grpc.ServiceDesc for StudentService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var StudentService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "dineth.grpc.api.student.StudentService",
+	HandlerType: (*StudentServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetStudent",
+			Handler:    _StudentService_GetStudent_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetStudentStream",
+			Handler:       _StudentService_GetStudentStream_Handler,
+			ServerStreams: true,
+		},
+		{
+			StreamName:    "SendStudentStream",
+			Handler:       _StudentService_SendStudentStream_Handler,
+			ClientStreams: true,
+		},
+		{
+			StreamName:    "SendAndGetStudentStream",
+			Handler:       _StudentService_SendAndGetStudentStream_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "student_default_version.proto",
+}
diff --git a/test/integration/integration/utils/grpcutils/helpers.go b/test/integration/integration/utils/grpcutils/helpers.go
new file mode 100644
index 0000000000..66d3392156
--- /dev/null
+++ b/test/integration/integration/utils/grpcutils/helpers.go
@@ -0,0 +1,90 @@
+package grpcutils
+
+import (
+	"crypto/tls"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"testing"
+	"time"
+)
+
+type Request struct {
+	Host    string
+	Headers map[string]string
+}
+type ClientCreator[T any] func(conn *grpc.ClientConn) T
+type ExpectedResponse struct {
+	Out any
+	Err error
+}
+
+type GRPCTestCase struct {
+	Request          Request
+	ExpectedResponse ExpectedResponse
+	ActualResponse   any
+	Name             string
+	Method           func(conn *grpc.ClientConn) (any, error)
+	Satisfier        ResponseSatisfier
+}
+type ResponseSatisfier interface {
+	IsSatisfactory(response interface{}, expectedResponse ExpectedResponse) bool
+}
+
+func DialGRPCServer(gwAddr string, t *testing.T) (*grpc.ClientConn, error) {
+	// Set up a connection to the server.
+	t.Logf("Dialing gRPC server at %s...", gwAddr)
+	creds := credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
+	conn, err := grpc.Dial(gwAddr, grpc.WithTransportCredentials(creds))
+	if err != nil {
+		t.Fatalf("Could not connect to the server: %v", err)
+	}
+	return conn, nil
+}
+func InvokeGRPCClientUntilSatisfied(gwAddr string, t *testing.T, testCase GRPCTestCase, satisfier ResponseSatisfier, fn ExecuteClientCall) {
+	//(delay to allow CRs to be applied)
+	time.Sleep(5 * time.Second)
+
+	var out any
+	var err error
+	attempt := 0
+	maxAttempts := 4
+	expected := testCase.ExpectedResponse
+	timeoutDuration := 50 * time.Second
+	for attempt < maxAttempts {
+		t.Logf("Attempt %d to invoke gRPC client...", attempt+1)
+		out, err = InvokeGRPCClient(gwAddr, t, fn)
+
+		if err != nil {
+			t.Logf("Error on attempt %d: %v", attempt+1, err)
+		} else {
+			if satisfier.IsSatisfactory(out, expected) {
+				return
+			}
+		}
+
+		if attempt < maxAttempts-1 {
+			t.Logf("Waiting %s seconds before next attempt...", timeoutDuration)
+			time.Sleep(timeoutDuration)
+		}
+		attempt++
+	}
+
+	t.Logf("Failed to receive a satisfactory response after %d attempts", maxAttempts)
+	t.Fail()
+}
+
+type ExecuteClientCall func(conn *grpc.ClientConn) (any, error)
+
+func InvokeGRPCClient(gwAddr string, t *testing.T, fn ExecuteClientCall) (any, error) {
+
+	conn, err := DialGRPCServer(gwAddr, t)
+	if err != nil {
+		t.Fatalf("Could not connect to the server: %v", err)
+	}
+
+	response, err := fn(conn)
+	if err != nil {
+		return nil, err
+	}
+	return response, nil
+}
diff --git a/test/integration/scripts/run-tests.sh b/test/integration/scripts/run-tests.sh
index 7a50bd0567..ecdd329aca 100644
--- a/test/integration/scripts/run-tests.sh
+++ b/test/integration/scripts/run-tests.sh
@@ -79,6 +79,7 @@ sudo echo "$IP ratelimit-priority.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP different-endpoint-with-same-route.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP custom-auth-header.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP gql.test.gw.wso2.com" | sudo tee -a /etc/hosts
+sudo echo "$IP grpc.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP api-level-jwt.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP resource-level-jwt.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "255.255.255.255 broadcasthost" | sudo tee -a /etc/hosts
diff --git a/test/integration/scripts/setup-hosts.sh b/test/integration/scripts/setup-hosts.sh
index 7ff4ff8afd..ec36022ebe 100644
--- a/test/integration/scripts/setup-hosts.sh
+++ b/test/integration/scripts/setup-hosts.sh
@@ -38,6 +38,7 @@ sudo echo "$IP ratelimit-priority.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP different-endpoint-with-same-route.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP custom-auth-header.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP gql.test.gw.wso2.com" | sudo tee -a /etc/hosts
+sudo echo "$IP grpc.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP api-level-jwt.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "$IP resource-level-jwt.test.gw.wso2.com" | sudo tee -a /etc/hosts
 sudo echo "255.255.255.255 broadcasthost" | sudo tee -a /etc/hosts