diff --git a/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatch.cs b/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatch.cs
index df2607c..7a0a2dc 100644
--- a/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatch.cs
+++ b/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatch.cs
@@ -14,9 +14,22 @@ internal class GraphQLBatch : IGraphQLBatch
     {
         private readonly GraphQLBatchMerger _batch;
 
-        internal GraphQLBatch(GraphQLOperationType graphQLOperationType, string url, HttpMethod httpMethod, IDictionary<string, string> headers, string authorizationToken, string authorizationMethod, IGraphQLHttpExecutor executor, IGraphQLFieldBuilder fieldBuilder, IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization deserialization)
+        internal GraphQLBatch(GraphQLOperationType graphQLOperationType, string operationName, string url,
+            HttpMethod httpMethod, IDictionary<string, string> headers, string authorizationToken,
+            string authorizationMethod, IGraphQLHttpExecutor executor, IGraphQLFieldBuilder fieldBuilder,
+            IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization deserialization)
+        {
+            _batch = new GraphQLBatchMerger(graphQLOperationType, operationName, url, httpMethod, headers,
+                authorizationToken, authorizationMethod, executor, fieldBuilder, queryGenerator, deserialization);
+        }
+
+        internal GraphQLBatch(GraphQLOperationType graphQLOperationType, string url, HttpMethod httpMethod,
+            IDictionary<string, string> headers, string authorizationToken, string authorizationMethod,
+            IGraphQLHttpExecutor executor, IGraphQLFieldBuilder fieldBuilder,
+            IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization deserialization) : this(
+            graphQLOperationType, null, url, httpMethod, headers, authorizationToken, authorizationMethod, executor,
+            fieldBuilder, queryGenerator, deserialization)
         {
-            _batch = new GraphQLBatchMerger(graphQLOperationType, url, httpMethod, headers, authorizationToken, authorizationMethod, executor, fieldBuilder, queryGenerator, deserialization);
         }
 
         /// <inheritdoc />
diff --git a/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatchMerger.cs b/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatchMerger.cs
index 950ca46..56f6f66 100644
--- a/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatchMerger.cs
+++ b/src/SAHB.GraphQLClient/Batching/Internal/GraphQLBatchMerger.cs
@@ -18,6 +18,7 @@ namespace SAHB.GraphQLClient.Batching.Internal
     internal class GraphQLBatchMerger
     {
         private readonly GraphQLOperationType _graphQLOperationType;
+        private readonly string _operationName;
         private readonly string _url;
         private readonly HttpMethod _httpMethod;
         private readonly IDictionary<string, string> _headers;
@@ -34,9 +35,22 @@ internal class GraphQLBatchMerger
         private GraphQLDataResult<JObject> _result;
         private string _executedQuery;
 
-        public GraphQLBatchMerger(GraphQLOperationType graphQLOperationType, string url, HttpMethod httpMethod, IDictionary<string, string> headers, string authorizationToken, string authorizationMethod, IGraphQLHttpExecutor executor, IGraphQLFieldBuilder fieldBuilder, IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization graphQLDeserialization)
+        public GraphQLBatchMerger(GraphQLOperationType graphQLOperationType, string url,
+            HttpMethod httpMethod, IDictionary<string, string> headers, string authorizationToken,
+            string authorizationMethod, IGraphQLHttpExecutor executor, IGraphQLFieldBuilder fieldBuilder,
+            IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization graphQLDeserialization) : this(
+            graphQLOperationType, null, url, httpMethod, headers, authorizationToken, authorizationMethod, executor,
+            fieldBuilder, queryGenerator, graphQLDeserialization)
+        {
+        }
+
+        public GraphQLBatchMerger(GraphQLOperationType graphQLOperationType, string operationName, string url,
+            HttpMethod httpMethod, IDictionary<string, string> headers, string authorizationToken,
+            string authorizationMethod, IGraphQLHttpExecutor executor, IGraphQLFieldBuilder fieldBuilder,
+            IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization graphQLDeserialization)
         {
             _graphQLOperationType = graphQLOperationType;
+            _operationName = operationName;
             _url = url;
             _httpMethod = httpMethod;
             _headers = headers;
@@ -78,16 +92,13 @@ public Task<T> GetValue<T>(string identifier, CancellationToken cancellationToke
             return GetDeserializedResult<T>(identifier, cancellationToken);
         }
 
-        public async Task<GraphQLDataResult<T>> GetDetailedValue<T>(string identifier, CancellationToken cancellationToken)
+        public async Task<GraphQLDataResult<T>> GetDetailedValue<T>(string identifier,
+            CancellationToken cancellationToken)
             where T : class
         {
             var deserialized = await GetDeserializedResult<T>(identifier, cancellationToken).ConfigureAwait(false);
 
-            return new GraphQLDataResult<T>
-            {
-                Data = deserialized,
-                Headers = _result.Headers
-            };
+            return new GraphQLDataResult<T> {Data = deserialized, Headers = _result.Headers};
         }
 
         public async Task Execute(CancellationToken cancellationToken)
@@ -107,11 +118,13 @@ public async Task Execute(CancellationToken cancellationToken)
             var fields = _fields.SelectMany(e => e.Value).ToList();
 
             // Generate query
-            _executedQuery = _queryGenerator.GenerateQuery(_graphQLOperationType, fields,
+            _executedQuery = _queryGenerator.GenerateQuery(_graphQLOperationType, _operationName, fields,
                 _arguments.SelectMany(e => e.Value).ToArray());
 
             // Execute query
-            var serverResult = await _executor.ExecuteQuery(query: _executedQuery, url: _url, method: _httpMethod, authorizationToken: _authorizationToken, authorizationMethod: _authorizationMethod, headers: _headers, cancellationToken: cancellationToken).ConfigureAwait(false);
+            var serverResult = await _executor.ExecuteQuery(query: _executedQuery, url: _url, method: _httpMethod,
+                authorizationToken: _authorizationToken, authorizationMethod: _authorizationMethod, headers: _headers,
+                cancellationToken: cancellationToken).ConfigureAwait(false);
 
             // Deserilize result
             _result = _graphQLDeserialization.DeserializeResult<JObject>(serverResult.Response, fields);
@@ -178,7 +191,8 @@ private async Task<T> GetDeserializedResult<T>(string identifier, CancellationTo
             }
 
             // Deserialize from
-            return _graphQLDeserialization.DeserializeResult<T>(jsonObject: deserilizeFrom, fields: _fields[identifier]);
+            return _graphQLDeserialization.DeserializeResult<T>(jsonObject: deserilizeFrom,
+                fields: _fields[identifier]);
         }
 
         public bool Executed => _isExecuted;
diff --git a/src/SAHB.GraphQLClient/Extentions/GraphQLQueryGeneratorFromFieldsExtentions.cs b/src/SAHB.GraphQLClient/Extentions/GraphQLQueryGeneratorFromFieldsExtentions.cs
index af97b61..bc127fc 100644
--- a/src/SAHB.GraphQLClient/Extentions/GraphQLQueryGeneratorFromFieldsExtentions.cs
+++ b/src/SAHB.GraphQLClient/Extentions/GraphQLQueryGeneratorFromFieldsExtentions.cs
@@ -1,7 +1,9 @@
 using System;
+using System.Reflection;
 using SAHB.GraphQLClient.FieldBuilder;
 using SAHB.GraphQLClient.FieldBuilder.Attributes;
 using SAHB.GraphQLClient.QueryGenerator;
+using SAHB.GraphQLClient.QueryGenerator.Attributes;
 
 namespace SAHB.GraphQLClient.Extentions
 {
@@ -24,8 +26,12 @@ public static string GetQuery<T>(this IGraphQLQueryGeneratorFromFields queryGene
         {
             if (queryGenerator == null) throw new ArgumentNullException(nameof(queryGenerator));
             if (fieldBuilder == null) throw new ArgumentNullException(nameof(fieldBuilder));
-            var selectionSet = fieldBuilder.GenerateSelectionSet(typeof(T));
-            return queryGenerator.GenerateQuery(GraphQLOperationType.Query, selectionSet, arguments);
+
+            var type = typeof(T);
+            var selectionSet = fieldBuilder.GenerateSelectionSet(type);
+            var operationNameAttribute = type.GetTypeInfo().GetCustomAttribute<GraphQLOperationNameAttribute>();
+            
+            return queryGenerator.GenerateQuery(GraphQLOperationType.Query, operationNameAttribute?.OperationName, selectionSet, arguments);
         }
 
         /// <summary>
@@ -41,8 +47,12 @@ public static string GetMutation<T>(this IGraphQLQueryGeneratorFromFields queryG
         {
             if (queryGenerator == null) throw new ArgumentNullException(nameof(queryGenerator));
             if (fieldBuilder == null) throw new ArgumentNullException(nameof(fieldBuilder));
-            var selectionSet = fieldBuilder.GenerateSelectionSet(typeof(T));
-            return queryGenerator.GenerateQuery(GraphQLOperationType.Mutation, selectionSet, arguments);
+            
+            var type = typeof(T);
+            var selectionSet = fieldBuilder.GenerateSelectionSet(type);
+            var operationNameAttribute = type.GetTypeInfo().GetCustomAttribute<GraphQLOperationNameAttribute>();
+            
+            return queryGenerator.GenerateQuery(GraphQLOperationType.Mutation, operationNameAttribute?.OperationName, selectionSet, arguments);
         }
     }
 }
diff --git a/src/SAHB.GraphQLClient/GraphQLHttpClient.cs b/src/SAHB.GraphQLClient/GraphQLHttpClient.cs
index 2f1ac4c..e5b54e9 100644
--- a/src/SAHB.GraphQLClient/GraphQLHttpClient.cs
+++ b/src/SAHB.GraphQLClient/GraphQLHttpClient.cs
@@ -48,12 +48,15 @@ public class GraphQLHttpClient : IGraphQLHttpClient
         public IQueryGeneratorFilter FilterGenerator { get; }
 
         [Obsolete]
-        public GraphQLHttpClient(IGraphQLHttpExecutor httpExecutor, IGraphQLFieldBuilder fieldBuilder, IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization deserialization)
+        public GraphQLHttpClient(IGraphQLHttpExecutor httpExecutor, IGraphQLFieldBuilder fieldBuilder,
+            IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization deserialization)
             : this(httpExecutor, fieldBuilder, queryGenerator, deserialization, null)
         {
         }
 
-        public GraphQLHttpClient(IGraphQLHttpExecutor httpExecutor, IGraphQLFieldBuilder fieldBuilder, IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization deserialization, IQueryGeneratorFilter filterGenerator)
+        public GraphQLHttpClient(IGraphQLHttpExecutor httpExecutor, IGraphQLFieldBuilder fieldBuilder,
+            IGraphQLQueryGeneratorFromFields queryGenerator, IGraphQLDeserialization deserialization,
+            IQueryGeneratorFilter filterGenerator)
         {
             HttpExecutor = httpExecutor ?? throw new ArgumentNullException(nameof(httpExecutor));
             FieldBuilder = fieldBuilder ?? throw new ArgumentNullException(nameof(fieldBuilder));
@@ -68,7 +71,8 @@ public GraphQLHttpClient(IGraphQLHttpExecutor httpExecutor, IGraphQLFieldBuilder
         /// <returns>Returns a default <see cref="GraphQLHttpClient"/></returns>
         public static GraphQLHttpClient Default()
         {
-            return new GraphQLHttpClient(new GraphQLHttpExecutor(), new GraphQLFieldBuilder(), new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization(), new QueryGeneratorFilter());
+            return new GraphQLHttpClient(new GraphQLHttpExecutor(), new GraphQLFieldBuilder(),
+                new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization(), new QueryGeneratorFilter());
         }
 
         /// <summary>
@@ -78,21 +82,30 @@ public static GraphQLHttpClient Default()
         /// <returns>Returns a default <see cref="GraphQLHttpClient"/> using the specified <see cref="HttpClient"/></returns>
         public static GraphQLHttpClient Default(HttpClient client)
         {
-            return new GraphQLHttpClient(new GraphQLHttpExecutor(client), new GraphQLFieldBuilder(), new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization(), new QueryGeneratorFilter());
+            return new GraphQLHttpClient(new GraphQLHttpExecutor(client), new GraphQLFieldBuilder(),
+                new GraphQLQueryGeneratorFromFields(), new GraphQLDeserilization(), new QueryGeneratorFilter());
         }
 
         /// <inheritdoc />
-        public Task<T> Execute<T>(GraphQLOperationType operationType, string url = null, HttpMethod httpMethod = null, IDictionary<string, string> headers = null, Expression<Func<T, T>> filter = null, string authorizationToken = null, string authorizationMethod = "Bearer", CancellationToken cancellationToken = default, params GraphQLQueryArgument[] arguments) where T : class
+        public Task<T> Execute<T>(GraphQLOperationType operationType, string url = null, HttpMethod httpMethod = null,
+            IDictionary<string, string> headers = null, Expression<Func<T, T>> filter = null,
+            string authorizationToken = null, string authorizationMethod = "Bearer",
+            CancellationToken cancellationToken = default, params GraphQLQueryArgument[] arguments) where T : class
         {
             // Generate selectionSet
             var selectionSet = FieldBuilder.GenerateSelectionSet(typeof(T));
 
             // Execute
-            return Execute<T>(operationType, selectionSet, arguments, url: url, httpMethod: httpMethod, headers: headers, filter: filter, authorizationMethod: authorizationMethod, authorizationToken: authorizationToken, cancellationToken: cancellationToken);
+            return Execute<T>(operationType, selectionSet, arguments, url: url, httpMethod: httpMethod,
+                headers: headers, filter: filter, authorizationMethod: authorizationMethod,
+                authorizationToken: authorizationToken, cancellationToken: cancellationToken);
         }
 
         /// <inheritdoc />
-        public Task<dynamic> Execute(GraphQLOperationType operationType, Action<IGraphQLBuilder> builder, string url = null, HttpMethod httpMethod = null, IDictionary<string, string> headers = null, string authorizationToken = null, string authorizationMethod = "Bearer", CancellationToken cancellationToken = default, params GraphQLQueryArgument[] arguments)
+        public Task<dynamic> Execute(GraphQLOperationType operationType, Action<IGraphQLBuilder> builder,
+            string url = null, HttpMethod httpMethod = null, IDictionary<string, string> headers = null,
+            string authorizationToken = null, string authorizationMethod = "Bearer",
+            CancellationToken cancellationToken = default, params GraphQLQueryArgument[] arguments)
         {
             // Get builder
             var build = new GraphQLBuilder();
@@ -102,83 +115,122 @@ public Task<dynamic> Execute(GraphQLOperationType operationType, Action<IGraphQL
             var selectionSet = build.GetFields();
 
             // Execute
-            return Execute<dynamic>(operationType, selectionSet, arguments, url: url, httpMethod: httpMethod, headers: headers, filter: null, authorizationMethod: authorizationMethod, authorizationToken: authorizationToken, cancellationToken: cancellationToken);
+            return Execute<dynamic>(operationType, selectionSet, arguments, url: url, httpMethod: httpMethod,
+                headers: headers, filter: null, authorizationMethod: authorizationMethod,
+                authorizationToken: authorizationToken, cancellationToken: cancellationToken);
+        }
+
+        public IGraphQLBatch CreateBatch(GraphQLOperationType operationType, string url,
+            HttpMethod httpMethod = null,
+            IDictionary<string, string> headers = null, string authorizationToken = null,
+            string authorizationMethod = "Bearer")
+        {
+            return new GraphQLBatch(operationType, url, httpMethod, headers, authorizationToken: authorizationToken,
+                authorizationMethod: authorizationMethod, HttpExecutor, FieldBuilder, QueryGenerator, Deserialization);
         }
 
         /// <inheritdoc />
-        public IGraphQLBatch CreateBatch(GraphQLOperationType operationType, string url = null, HttpMethod httpMethod = null, IDictionary<string, string> headers = null, string authorizationToken = null, string authorizationMethod = "Bearer")
+        public IGraphQLBatch CreateBatch(GraphQLOperationType operationType, string operationName, string url,
+            HttpMethod httpMethod = null, IDictionary<string, string> headers = null, string authorizationToken = null,
+            string authorizationMethod = "Bearer")
         {
-            return new GraphQLBatch(operationType, url, httpMethod, headers, authorizationToken: authorizationToken, authorizationMethod: authorizationMethod, HttpExecutor, FieldBuilder, QueryGenerator, Deserialization);
+            return new GraphQLBatch(operationType, operationName, url, httpMethod, headers,
+                authorizationToken: authorizationToken, authorizationMethod: authorizationMethod, HttpExecutor,
+                FieldBuilder, QueryGenerator, Deserialization);
         }
 
-        private async Task<T> Execute<T>(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod, IDictionary<string, string> headers, Expression<Func<T, T>> filter, string authorizationMethod, string authorizationToken, CancellationToken cancellationToken) where T : class
+        private async Task<T> Execute<T>(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet,
+            GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod, IDictionary<string, string> headers,
+            Expression<Func<T, T>> filter, string authorizationMethod, string authorizationToken,
+            CancellationToken cancellationToken) where T : class
         {
-            var result = await ExecuteQuery<T>(operationType, selectionSet, arguments, url, httpMethod, headers, filter, authorizationMethod: authorizationMethod, authorizationToken: authorizationToken, cancellationToken: cancellationToken).ConfigureAwait(false);
+            var result = await ExecuteQuery<T>(operationType, selectionSet, arguments, url, httpMethod, headers, filter,
+                authorizationMethod: authorizationMethod, authorizationToken: authorizationToken,
+                cancellationToken: cancellationToken).ConfigureAwait(false);
             return result.Data;
         }
 
-        private Task<GraphQLDataResult<T>> ExecuteQuery<T>(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod, IDictionary<string, string> headers, Expression<Func<T, T>> filter, string authorizationMethod, string authorizationToken, CancellationToken cancellationToken) where T : class
+        private Task<GraphQLDataResult<T>> ExecuteQuery<T>(GraphQLOperationType operationType,
+            IEnumerable<GraphQLField> selectionSet, GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod,
+            IDictionary<string, string> headers, Expression<Func<T, T>> filter, string authorizationMethod,
+            string authorizationToken, CancellationToken cancellationToken) where T : class
         {
-            var query = GetGraphQLQuery<T>(operationType, selectionSet, arguments, url, httpMethod, headers, GetQueryFilter<T>(filter), authorizationToken: authorizationToken, authorizationMethod: authorizationMethod);
+            var query = GetGraphQLQuery<T>(operationType, selectionSet, arguments, url, httpMethod, headers,
+                GetQueryFilter<T>(filter), authorizationToken: authorizationToken,
+                authorizationMethod: authorizationMethod);
             return query.ExecuteDetailed(cancellationToken);
         }
 
         /// <inheritdoc />
         public IGraphQLQuery CreateQuery(Action<IGraphQLBuilder> builder, string url, string authorizationToken = null,
-             string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments)
+            string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments)
         {
             return CreateQuery(builder, url, HttpMethod.Post, authorizationToken, authorizationMethod, arguments);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery<T> CreateQuery<T>(string url, string authorizationToken = null, string authorizationMethod = "Bearer",
+        public IGraphQLQuery<T> CreateQuery<T>(string url, string authorizationToken = null,
+            string authorizationMethod = "Bearer",
             params GraphQLQueryArgument[] arguments) where T : class
         {
             return CreateQuery<T>(url, HttpMethod.Post, authorizationToken, authorizationMethod, arguments);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery<T> CreateQuery<T>(string url, Expression<Func<T, T>> filter, string authorizationToken = null, string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments) where T : class
+        public IGraphQLQuery<T> CreateQuery<T>(string url, Expression<Func<T, T>> filter,
+            string authorizationToken = null, string authorizationMethod = "Bearer",
+            params GraphQLQueryArgument[] arguments) where T : class
         {
             return CreateQuery<T>(url, HttpMethod.Post, filter, authorizationToken, authorizationMethod, arguments);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery<T> CreateMutation<T>(string url, Expression<Func<T, T>> filter, string authorizationToken = null, string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments) where T : class
+        public IGraphQLQuery<T> CreateMutation<T>(string url, Expression<Func<T, T>> filter,
+            string authorizationToken = null, string authorizationMethod = "Bearer",
+            params GraphQLQueryArgument[] arguments) where T : class
         {
             return CreateMutation<T>(url, HttpMethod.Post, filter, authorizationToken, authorizationMethod, arguments);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery<T> CreateMutation<T>(string url, HttpMethod httpMethod, Expression<Func<T, T>> filter, string authorizationToken = null, string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments) where T : class
+        public IGraphQLQuery<T> CreateMutation<T>(string url, HttpMethod httpMethod, Expression<Func<T, T>> filter,
+            string authorizationToken = null, string authorizationMethod = "Bearer",
+            params GraphQLQueryArgument[] arguments) where T : class
         {
             var selectionSet = FieldBuilder.GenerateSelectionSet(typeof(T));
-            return GetGraphQLQuery<T>(GraphQLOperationType.Mutation, selectionSet, arguments, url, httpMethod, null, GetQueryFilter(filter), authorizationToken, authorizationMethod);
+            return GetGraphQLQuery<T>(GraphQLOperationType.Mutation, selectionSet, arguments, url, httpMethod, null,
+                GetQueryFilter(filter), authorizationToken, authorizationMethod);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery<T> CreateQuery<T>(string url, HttpMethod httpMethod, Expression<Func<T, T>> filter, string authorizationToken = null, string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments) where T : class
+        public IGraphQLQuery<T> CreateQuery<T>(string url, HttpMethod httpMethod, Expression<Func<T, T>> filter,
+            string authorizationToken = null, string authorizationMethod = "Bearer",
+            params GraphQLQueryArgument[] arguments) where T : class
         {
             var selectionSet = FieldBuilder.GenerateSelectionSet(typeof(T));
-            return GetGraphQLQuery<T>(GraphQLOperationType.Query, selectionSet, arguments, url, httpMethod, null, GetQueryFilter(filter), authorizationToken, authorizationMethod);
+            return GetGraphQLQuery<T>(GraphQLOperationType.Query, selectionSet, arguments, url, httpMethod, null,
+                GetQueryFilter(filter), authorizationToken, authorizationMethod);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery CreateMutation(Action<IGraphQLBuilder> builder, string url, string authorizationToken = null,
+        public IGraphQLQuery CreateMutation(Action<IGraphQLBuilder> builder, string url,
+            string authorizationToken = null,
             string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments)
         {
             return CreateMutation(builder, url, HttpMethod.Post, authorizationToken, authorizationMethod, arguments);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery<T> CreateMutation<T>(string url, string authorizationToken = null, string authorizationMethod = "Bearer",
+        public IGraphQLQuery<T> CreateMutation<T>(string url, string authorizationToken = null,
+            string authorizationMethod = "Bearer",
             params GraphQLQueryArgument[] arguments) where T : class
         {
             return CreateMutation<T>(url, HttpMethod.Post, authorizationToken, authorizationMethod, arguments);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery CreateMutation(Action<IGraphQLBuilder> builder, string url, HttpMethod httpMethod, string authorizationToken = null,
+        public IGraphQLQuery CreateMutation(Action<IGraphQLBuilder> builder, string url, HttpMethod httpMethod,
+            string authorizationToken = null,
             string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments)
         {
             var build = new GraphQLBuilder();
@@ -188,7 +240,8 @@ public IGraphQLQuery CreateMutation(Action<IGraphQLBuilder> builder, string url,
             var selectionSet = build.GetFields();
 
             // Get query
-            return GetGraphQLQuery(GraphQLOperationType.Mutation, selectionSet, arguments, url, httpMethod, null, null, authorizationToken, authorizationMethod);
+            return GetGraphQLQuery(GraphQLOperationType.Mutation, selectionSet, arguments, url, httpMethod, null, null,
+                authorizationToken, authorizationMethod);
         }
 
         /// <inheritdoc />
@@ -196,11 +249,13 @@ public IGraphQLQuery<T> CreateMutation<T>(string url, HttpMethod httpMethod, str
             string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments) where T : class
         {
             var selectionSet = FieldBuilder.GenerateSelectionSet(typeof(T));
-            return GetGraphQLQuery<T>(GraphQLOperationType.Mutation, selectionSet, arguments, url, httpMethod, null, null, authorizationToken, authorizationMethod);
+            return GetGraphQLQuery<T>(GraphQLOperationType.Mutation, selectionSet, arguments, url, httpMethod, null,
+                null, authorizationToken, authorizationMethod);
         }
 
         /// <inheritdoc />
-        public IGraphQLQuery CreateQuery(Action<IGraphQLBuilder> builder, string url, HttpMethod httpMethod, string authorizationToken = null,
+        public IGraphQLQuery CreateQuery(Action<IGraphQLBuilder> builder, string url, HttpMethod httpMethod,
+            string authorizationToken = null,
             string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments)
         {
             var build = new GraphQLBuilder();
@@ -210,7 +265,8 @@ public IGraphQLQuery CreateQuery(Action<IGraphQLBuilder> builder, string url, Ht
             var selectionSet = build.GetFields();
 
             // Get query
-            return GetGraphQLQuery(GraphQLOperationType.Query, selectionSet, arguments, url, httpMethod, null, null, authorizationToken, authorizationMethod);
+            return GetGraphQLQuery(GraphQLOperationType.Query, selectionSet, arguments, url, httpMethod, null, null,
+                authorizationToken, authorizationMethod);
         }
 
         /// <inheritdoc />
@@ -218,41 +274,64 @@ public IGraphQLQuery<T> CreateQuery<T>(string url, HttpMethod httpMethod, string
             string authorizationMethod = "Bearer", params GraphQLQueryArgument[] arguments) where T : class
         {
             var selectionSet = FieldBuilder.GenerateSelectionSet(typeof(T));
-            return GetGraphQLQuery<T>(GraphQLOperationType.Query, selectionSet, arguments, url, httpMethod, null, null, authorizationToken, authorizationMethod);
+            return GetGraphQLQuery<T>(GraphQLOperationType.Query, selectionSet, arguments, url, httpMethod, null, null,
+                authorizationToken, authorizationMethod);
         }
 
         #region Old methods
+
         /// <inheritdoc />
-        public IGraphQLBatch CreateBatch(string url, string authorizationToken = null, string authorizationMethod = "Bearer")
+        public IGraphQLBatch CreateBatch(string url, string authorizationToken = null,
+            string authorizationMethod = "Bearer")
         {
-            return CreateBatch(url, HttpMethod.Post, authorizationToken, authorizationMethod);
+            return CreateBatch(null, url, HttpMethod.Post, authorizationToken, authorizationMethod);
         }
 
-        /// <inheritdoc />
         public IGraphQLBatch CreateBatch(string url, HttpMethod httpMethod, string authorizationToken = null,
             string authorizationMethod = "Bearer")
         {
-            return new GraphQLBatch(GraphQLOperationType.Query, url, httpMethod, null, authorizationToken, authorizationMethod, HttpExecutor, FieldBuilder, QueryGenerator, Deserialization);
+            return CreateBatch(null, url, httpMethod, authorizationToken, authorizationMethod);
+            ;
+        }
+
+        /// <inheritdoc />
+        public IGraphQLBatch CreateBatch(string operationName, string url, string authorizationToken = null,
+            string authorizationMethod = "Bearer")
+        {
+            return CreateBatch(operationName, url, HttpMethod.Post, authorizationToken, authorizationMethod);
+        }
+
+        /// <inheritdoc />
+        public IGraphQLBatch CreateBatch(string operationName, string url, HttpMethod httpMethod,
+            string authorizationToken = null,
+            string authorizationMethod = "Bearer")
+        {
+            return new GraphQLBatch(GraphQLOperationType.Query, operationName, url, httpMethod, null,
+                authorizationToken, authorizationMethod, HttpExecutor, FieldBuilder, QueryGenerator, Deserialization);
         }
 
         // ReSharper disable once InconsistentNaming
-        private IGraphQLQuery GetGraphQLQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod,
+        private IGraphQLQuery GetGraphQLQuery(GraphQLOperationType operationType,
+            IEnumerable<GraphQLField> selectionSet, GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod,
             IDictionary<string, string> headers,
             Func<GraphQLField, bool> filter,
             string authorizationToken = null,
             string authorizationMethod = "Bearer")
         {
-            return new GraphQLQuery(operationType, selectionSet, arguments, url, httpMethod, filter, authorizationToken, authorizationMethod, headers, QueryGenerator, HttpExecutor, Deserialization);
+            return new GraphQLQuery(operationType, selectionSet, arguments, url, httpMethod, filter, authorizationToken,
+                authorizationMethod, headers, QueryGenerator, HttpExecutor, Deserialization);
         }
 
         // ReSharper disable once InconsistentNaming
-        private IGraphQLQuery<T> GetGraphQLQuery<T>(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod,
+        private IGraphQLQuery<T> GetGraphQLQuery<T>(GraphQLOperationType operationType,
+            IEnumerable<GraphQLField> selectionSet, GraphQLQueryArgument[] arguments, string url, HttpMethod httpMethod,
             IDictionary<string, string> headers,
             Func<GraphQLField, bool> filter,
             string authorizationToken = null,
             string authorizationMethod = "Bearer") where T : class
         {
-            return new GraphQLQuery<T>(operationType, selectionSet, arguments, url, httpMethod, filter, authorizationToken, authorizationMethod, headers, QueryGenerator, HttpExecutor, Deserialization);
+            return new GraphQLQuery<T>(operationType, selectionSet, arguments, url, httpMethod, filter,
+                authorizationToken, authorizationMethod, headers, QueryGenerator, HttpExecutor, Deserialization);
         }
 
         private Func<GraphQLField, bool> GetQueryFilter<T>(Expression<Func<T, T>> filter)
@@ -262,7 +341,8 @@ private Func<GraphQLField, bool> GetQueryFilter<T>(Expression<Func<T, T>> filter
                 return null;
 
             if (FilterGenerator == null)
-                throw new NotSupportedException("IQueryGeneratorFilter needs to be specified in constructer if filter is used");
+                throw new NotSupportedException(
+                    "IQueryGeneratorFilter needs to be specified in constructer if filter is used");
 
             return FilterGenerator.GetFilter(filter);
         }
diff --git a/src/SAHB.GraphQLClient/IGraphQLHttpClient.cs b/src/SAHB.GraphQLClient/IGraphQLHttpClient.cs
index 1123160..34ceb56 100644
--- a/src/SAHB.GraphQLClient/IGraphQLHttpClient.cs
+++ b/src/SAHB.GraphQLClient/IGraphQLHttpClient.cs
@@ -60,8 +60,21 @@ public interface IGraphQLHttpClient
         /// <param name="authorizationToken">The token used to authenticate with the GraphQL server</param>
         /// <param name="authorizationMethod">The method used for authentication</param>
         /// <returns></returns>
-        IGraphQLBatch CreateBatch(GraphQLOperationType operationType, string url = null, HttpMethod httpMethod = null, IDictionary<string, string> headers = null, string authorizationToken = null, string authorizationMethod = "Bearer");
+        IGraphQLBatch CreateBatch(GraphQLOperationType operationType, string url, HttpMethod httpMethod = null, IDictionary<string, string> headers = null, string authorizationToken = null, string authorizationMethod = "Bearer");
 
+        /// <summary>
+        /// Generates a GraphQL batch
+        /// </summary>
+        /// <param name="operationType">The GraphQL Operation to execute</param>
+        /// <param name="operationName">The operation name for this batch, null if no operation name to be set</param>
+        /// <param name="url">The endpoint to request the GraphQL server from</param>
+        /// <param name="httpMethod">The httpMethod to use requesting the GraphQL server</param>
+        /// <param name="headers">Headers to add to the request</param>
+        /// <param name="authorizationToken">The token used to authenticate with the GraphQL server</param>
+        /// <param name="authorizationMethod">The method used for authentication</param>
+        /// <returns></returns>
+        IGraphQLBatch CreateBatch(GraphQLOperationType operationType, string operationName, string url, HttpMethod httpMethod = null, IDictionary<string, string> headers = null, string authorizationToken = null, string authorizationMethod = "Bearer");
+        
         /// <summary>
         /// Generates a query to a GraphQL server using a query generated by the <see cref="IGraphQLBuilder"/>, the specified URL and the HttpMethod Post
         /// </summary>
@@ -235,5 +248,16 @@ public interface IGraphQLHttpClient
         /// <param name="authorizationMethod">The method used for authentication</param>
         /// <returns></returns>
         IGraphQLBatch CreateBatch(string url, HttpMethod httpMethod, string authorizationToken = null, string authorizationMethod = "Bearer");
+        
+        /// <summary>
+        /// Generates a GraphQL batch using the specified server <paramref name="url"/>, the specified <paramref name="authorizationToken"/> and the specified <paramref name="authorizationMethod"/>
+        /// </summary>
+        /// <param name="operationName">The operation name for the batch execution, can be null if no operation name to be set</param>
+        /// <param name="url">The endpoint to request the GraphQL server from</param>
+        /// <param name="httpMethod">The HttpMethod to use to communicate with the server, for example POST</param>
+        /// <param name="authorizationToken">The token used to authenticate with the GraphQL server</param>
+        /// <param name="authorizationMethod">The method used for authentication</param>
+        /// <returns></returns>
+        IGraphQLBatch CreateBatch(string operationName, string url, HttpMethod httpMethod, string authorizationToken = null, string authorizationMethod = "Bearer");
     }
 }
diff --git a/src/SAHB.GraphQLClient/Internal/GraphQLQuery.cs b/src/SAHB.GraphQLClient/Internal/GraphQLQuery.cs
index 053f2ad..8e984c2 100644
--- a/src/SAHB.GraphQLClient/Internal/GraphQLQuery.cs
+++ b/src/SAHB.GraphQLClient/Internal/GraphQLQuery.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Http;
+using System.Reflection;
 using System.Threading.Tasks;
 using SAHB.GraphQLClient.Deserialization;
 using SAHB.GraphQLClient.FieldBuilder;
@@ -10,6 +11,7 @@
 using SAHB.GraphQLClient.QueryGenerator;
 using SAHB.GraphQLClient.Result;
 using System.Threading;
+using SAHB.GraphQLClient.QueryGenerator.Attributes;
 
 namespace SAHB.GraphQLClient.Internal
 {
@@ -59,9 +61,13 @@ public GraphQLQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField
             this._arguments = arguments;
             this._headers = headers;
             this._filter = filter;
+
+            var operationNameAttribute = typeof(T).GetTypeInfo().GetCustomAttribute<GraphQLOperationNameAttribute>();
+            this.OperationName = operationNameAttribute?.OperationName;
         }
 
         private GraphQLOperationType OperationType { get; }
+        private string OperationName { get; }
         private IEnumerable<GraphQLField> SelectionSet { get; }
 
         /// <inheritdoc />
@@ -84,7 +90,7 @@ public async Task<GraphQLDataResult<T>> ExecuteDetailed(CancellationToken cancel
         private async Task<GraphQLDataResult<T>> GetDataResult(CancellationToken cancellationToken)
         {
             // Generate query
-            var query = _queryGenerator.GenerateQuery(OperationType, SelectionSet, _filter, _arguments);
+            var query = _queryGenerator.GenerateQuery(OperationType, OperationName, SelectionSet, _filter, _arguments);
 
             // Get result
             var result = await _executor.ExecuteQuery(
diff --git a/src/SAHB.GraphQLClient/QueryGenerator/Attributes/GraphQLOperationNameAttribute.cs b/src/SAHB.GraphQLClient/QueryGenerator/Attributes/GraphQLOperationNameAttribute.cs
new file mode 100644
index 0000000..a8b898f
--- /dev/null
+++ b/src/SAHB.GraphQLClient/QueryGenerator/Attributes/GraphQLOperationNameAttribute.cs
@@ -0,0 +1,19 @@
+using System;
+
+namespace SAHB.GraphQLClient.QueryGenerator.Attributes
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class GraphQLOperationNameAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes an attribute that describes the corresponding GraphQL operation name for the attributed class
+        /// </summary>
+        /// <param name="operationName">The operation name used in the GraphQL query</param>
+        public GraphQLOperationNameAttribute(string operationName)
+        {
+            OperationName = operationName;
+        }
+        
+        public string OperationName { get; set; }
+    }
+}
diff --git a/src/SAHB.GraphQLClient/QueryGenerator/GraphQLQueryGeneratorFromFields.cs b/src/SAHB.GraphQLClient/QueryGenerator/GraphQLQueryGeneratorFromFields.cs
index 9a7fbff..0419b74 100644
--- a/src/SAHB.GraphQLClient/QueryGenerator/GraphQLQueryGeneratorFromFields.cs
+++ b/src/SAHB.GraphQLClient/QueryGenerator/GraphQLQueryGeneratorFromFields.cs
@@ -17,21 +17,33 @@ namespace SAHB.GraphQLClient.QueryGenerator
     /// <inheritdoc />
     public class GraphQLQueryGeneratorFromFields : IGraphQLQueryGeneratorFromFields
     {
+        public string GenerateQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet,
+            params GraphQLQueryArgument[] arguments)
+        {
+            return GenerateQuery(operationType, null, selectionSet, null, arguments);;
+        }
+
         /// <inheritdoc />
-        public string GenerateQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, params GraphQLQueryArgument[] arguments)
+        public string GenerateQuery(GraphQLOperationType operationType, string operationName, IEnumerable<GraphQLField> selectionSet, params GraphQLQueryArgument[] arguments)
+        {
+            return GenerateQuery(operationType, operationName, selectionSet, null, arguments);
+        }
+
+        public string GenerateQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, Func<GraphQLField, bool> filter,
+            params GraphQLQueryArgument[] arguments)
         {
-            return GenerateQuery(operationType, selectionSet, null, arguments);
+            return GenerateQuery(operationType, null, selectionSet, filter, arguments);
         }
 
         /// <inheritdoc />
-        public string GenerateQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, Func<GraphQLField, bool> filter, params GraphQLQueryArgument[] arguments)
+        public string GenerateQuery(GraphQLOperationType operationType, string operationName, IEnumerable<GraphQLField> selectionSet, Func<GraphQLField, bool> filter, params GraphQLQueryArgument[] arguments)
         {
             switch (operationType)
             {
                 case GraphQLOperationType.Query:
                 case GraphQLOperationType.Mutation:
                 case GraphQLOperationType.Subscription:
-                    return GetQuery(operationType, selectionSet.ToList(), filter, arguments);
+                    return GetQuery(operationType, operationName, selectionSet.ToList(), filter, arguments);
             }
 
             throw new NotImplementedException($"Operation {operationType} not implemented");
@@ -39,13 +51,13 @@ public string GenerateQuery(GraphQLOperationType operationType, IEnumerable<Grap
 
         [Obsolete("Please use GenerateQuery instead")]
         /// <inheritdoc />
-        public string GetQuery(IEnumerable<GraphQLField> fields, params GraphQLQueryArgument[] arguments) => GenerateQuery(GraphQLOperationType.Query, fields, arguments);
+        public string GetQuery(IEnumerable<GraphQLField> fields, params GraphQLQueryArgument[] arguments) => GenerateQuery(GraphQLOperationType.Query, null, fields, arguments);
 
         [Obsolete("Please use GenerateQuery instead")]
         /// <inheritdoc />
-        public string GetMutation(IEnumerable<GraphQLField> fields, params GraphQLQueryArgument[] arguments) => GenerateQuery(GraphQLOperationType.Mutation, fields, arguments);
+        public string GetMutation(IEnumerable<GraphQLField> fields, params GraphQLQueryArgument[] arguments) => GenerateQuery(GraphQLOperationType.Mutation, null, fields, arguments);
 
-        private string GetQuery(GraphQLOperationType operationType, ICollection<GraphQLField> selectionSet, Func<GraphQLField, bool> filter, params GraphQLQueryArgument[] queryArguments)
+        private string GetQuery(GraphQLOperationType operationType, string operationName, ICollection<GraphQLField> selectionSet, Func<GraphQLField, bool> filter, params GraphQLQueryArgument[] queryArguments)
         {
             // Get arguments
             var readonlyArguments = GetArguments(selectionSet, filter, queryArguments);
@@ -79,6 +91,7 @@ private string GetQuery(GraphQLOperationType operationType, ICollection<GraphQLF
 
             var queryBuilder = new StringBuilder();
             AppendRootQueryType(queryBuilder, queryType);
+            AppendRootOperationName(queryBuilder, operationName);
             AppendRootArguments(queryBuilder, readonlyArguments);
             AppendRootSelectionSet(queryBuilder, selectionSet, filter, readonlyArguments);
 
@@ -205,6 +218,15 @@ private void AppendRootQueryType(StringBuilder builder, string queryType)
             // Format: query
             builder.Append(queryType);
         }
+        
+        private void AppendRootOperationName(StringBuilder queryBuilder, string operationName)
+        {
+            if (!string.IsNullOrEmpty(operationName))
+            {
+                queryBuilder.Append(' ');
+                queryBuilder.Append(operationName);
+            }
+        }
 
         private void AppendRootArguments(StringBuilder builder, IReadOnlyDictionary<GraphQLFieldArguments, GraphQLQueryArgument> arguments)
         {
diff --git a/src/SAHB.GraphQLClient/QueryGenerator/IGraphQLQueryGeneratorFromFields.cs b/src/SAHB.GraphQLClient/QueryGenerator/IGraphQLQueryGeneratorFromFields.cs
index a83fc80..7f84b14 100644
--- a/src/SAHB.GraphQLClient/QueryGenerator/IGraphQLQueryGeneratorFromFields.cs
+++ b/src/SAHB.GraphQLClient/QueryGenerator/IGraphQLQueryGeneratorFromFields.cs
@@ -37,6 +37,15 @@ public interface IGraphQLQueryGeneratorFromFields
         /// <returns>The generated query</returns>
         string GenerateQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, params GraphQLQueryArgument[] arguments);
 
+        /// <summary>
+        /// Builds a GraphQL query from the specified <see cref="IGraphQLOperation"/>s and the <see cref="GraphQLQueryArgument"/>s
+        /// </summary>
+        /// <param name="operationType">The GraphQL operation to generate the query from</param>
+        /// <param name="operationName">The operation name of the query, can be null if no operation name needs to be set</param>
+        /// <param name="arguments">The argument values which is inserted using a variable on specified arguments with the <see cref="GraphQLArgumentsAttribute"/></param>
+        /// <returns>The generated query</returns>
+        string GenerateQuery(GraphQLOperationType operationType, string operationName, IEnumerable<GraphQLField> selectionSet, params GraphQLQueryArgument[] arguments);
+        
         /// <summary>
         /// Builds a GraphQL query from the specified <see cref="IGraphQLOperation"/>s and the <see cref="GraphQLQueryArgument"/>s and the specified filter used to select the required fields
         /// </summary>
@@ -45,5 +54,15 @@ public interface IGraphQLQueryGeneratorFromFields
         /// <param name="filter">The filter for the fields. If a field is included which has subfields, but no subfields are included all subfields are included</param>
         /// <returns>The generated query</returns>
         string GenerateQuery(GraphQLOperationType operationType, IEnumerable<GraphQLField> selectionSet, Func<GraphQLField, bool> filter, params GraphQLQueryArgument[] arguments);
+        
+        /// <summary>
+        /// Builds a GraphQL query from the specified <see cref="IGraphQLOperation"/>s and the <see cref="GraphQLQueryArgument"/>s and the specified filter used to select the required fields
+        /// </summary>
+        /// <param name="operationType">The GraphQL operation to generate the query from</param>
+        /// <param name="operationName">The operation name of the query, can be null if no operation name needs to be set</param>
+        /// <param name="arguments">The argument values which is inserted using a variable on specified arguments with the <see cref="GraphQLArgumentsAttribute"/></param>
+        /// <param name="filter">The filter for the fields. If a field is included which has subfields, but no subfields are included all subfields are included</param>
+        /// <returns>The generated query</returns>
+        string GenerateQuery(GraphQLOperationType operationType, string operationName, IEnumerable<GraphQLField> selectionSet, Func<GraphQLField, bool> filter, params GraphQLQueryArgument[] arguments);
     }
 }