diff --git a/src/plugins/intel_gpu/include/intel_gpu/primitives/concatenation.hpp b/src/plugins/intel_gpu/include/intel_gpu/primitives/concatenation.hpp
index 6e3a0065bbb..a0e58b9b767 100644
--- a/src/plugins/intel_gpu/include/intel_gpu/primitives/concatenation.hpp
+++ b/src/plugins/intel_gpu/include/intel_gpu/primitives/concatenation.hpp
@@ -39,16 +39,6 @@ namespace cldnn {
 ///   @li outputIdx : index of destination feature
 struct concatenation : public primitive_base<concatenation> {
     CLDNN_DECLARE_PRIMITIVE(concatenation)
-
-    enum concatenation_axis {
-        along_b,
-        along_f,
-        along_x,
-        along_y,
-        along_z,
-        along_w
-    };
-
     /// @li Constructs concatenation primitive.
     /// @param id This primitive id.
     /// @param input Vector of input primitives ids.
@@ -56,7 +46,7 @@ struct concatenation : public primitive_base<concatenation> {
     concatenation(
         const primitive_id& id,
         const std::vector<primitive_id>& input,
-        const concatenation_axis axis,
+        const int64_t axis,
         const primitive_id& ext_prim_id = "",
         const padding& output_padding = padding())
         : primitive_base(id, {input}, ext_prim_id, output_padding), axis(axis) {}
@@ -69,14 +59,14 @@ struct concatenation : public primitive_base<concatenation> {
     concatenation(
         const primitive_id& id,
         const std::vector<primitive_id>& input,
-        const concatenation_axis axis,
+        const int64_t axis,
         const data_types output_dt,
         const primitive_id& ext_prim_id = "",
         const padding& output_padding = padding())
         : primitive_base(id, {input}, ext_prim_id, output_padding, optional_data_type{output_dt}), axis(axis) {}
 
     /// @brief Dimension along which concatenation should take place
-    concatenation_axis axis;
+    int64_t axis;
 };
 /// @}
 /// @}
diff --git a/src/plugins/intel_gpu/src/graph/concatenation.cpp b/src/plugins/intel_gpu/src/graph/concatenation.cpp
index 766c62285ef..c7368daf50b 100644
--- a/src/plugins/intel_gpu/src/graph/concatenation.cpp
+++ b/src/plugins/intel_gpu/src/graph/concatenation.cpp
@@ -22,7 +22,7 @@ layout concatenation_inst::calc_output_layout(concatenation_node const& node) {
 
     auto input_layout = node.input(0).get_output_layout();
     auto output_format = input_layout.format;
-    auto result_sizes = input_layout.size.sizes();
+    auto result_sizes = input_layout.get_dims();
 
     auto output_dt = desc->output_data_type ? *desc->output_data_type : input_layout.data_type;
 
@@ -31,14 +31,16 @@ layout concatenation_inst::calc_output_layout(concatenation_node const& node) {
     // calculate sum of features from all inputs
     result_sizes[axis_index] = 0;
     for (size_t i = 0; i < desc->input.size(); ++i) {
-        auto input_sizes = node.input(i).get_output_layout().size.sizes();
+        auto input_sizes = node.input(i).get_output_layout().get_dims();
         if (node.input(i).get_output_layout().format == format::b_fs_yx_fsv16)
             output_format = format::b_fs_yx_fsv16;
 
         result_sizes[axis_index] += input_sizes[axis_index];
     }
 
-    return layout {output_dt, output_format, (tensor) result_sizes};
+    auto def_fmt = format::get_default_format(input_layout.get_rank());
+
+    return layout {output_dt, output_format, tensor(def_fmt, result_sizes)};
 }
 
 std::string concatenation_inst::to_string(concatenation_node const& node) {
@@ -58,7 +60,6 @@ std::string concatenation_inst::to_string(concatenation_node const& node) {
     concat_info.add("concat axis", desc->axis);
     concat_info.add("inputs count", node.inputs_count());
     concat_info.add("inputs", ss_inputs.str());
-    concat_info.dump(primitive_description);
 
     node_info->add("concat info", concat_info);
     node_info->dump(primitive_description);
@@ -72,39 +73,39 @@ concatenation_inst::typed_primitive_inst(network& network, concatenation_node co
     auto output_layout = node.get_output_layout();
 
     tensor::value_type concat_count = 0;
-    auto input_size = input_layout.size;
-    auto output_size = output_layout.size;
+    auto input_size = input_layout.get_dims();
+    auto output_size = output_layout.get_dims();
     for (const auto& i : node.get_dependencies()) {
         auto input_i_layout = i->get_output_layout();
-        auto input_mem_size = input_i_layout.size;
-        for (int dim = concatenation::along_b; dim <= concatenation::along_w; ++dim) {
+        auto input_mem_size = input_i_layout.get_dims();
+        for (int64_t dim = 0; dim < output_layout.get_rank(); ++dim) {
             if (dim == node.get_primitive()->axis) {
-                concat_count += input_mem_size.raw[dim];
+                concat_count += input_mem_size[dim];
             } else {
                 CLDNN_ERROR_NOT_EQUAL(node.id(),
                                       "Input size dim: " + std::to_string(dim),
-                                      input_size.raw[dim],
+                                      input_size[dim],
                                       "input memory dim: " + std::to_string(dim),
-                                      input_mem_size.raw[dim],
+                                      input_mem_size[dim],
                                       "Every input must have the same size");
             }
         }
     }
 
-    for (int dim = concatenation::along_b; dim <= concatenation::along_w; ++dim) {
+    for (int64_t dim = 0; dim < output_layout.get_rank(); ++dim) {
         if (dim == node.get_primitive()->axis) {
             CLDNN_ERROR_NOT_EQUAL(node.id(),
                                   "Concat count",
                                   concat_count,
                                   "output size dim:" + std::to_string(dim),
-                                  output_size.raw[dim],
+                                  output_size[dim],
                                   "Output size in concatenated dimension mismatch sum of inputs!");
         } else {
             CLDNN_ERROR_NOT_EQUAL(node.id(),
                                   "Input size dim: " + std::to_string(dim),
-                                  input_size.raw[dim],
+                                  input_size[dim],
                                   "output size dim:" + std::to_string(dim),
-                                  output_size.raw[dim],
+                                  output_size[dim],
                                   "Output size in non-concatenated dimension mistmatch input");
         }
     }
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/add_required_reorders.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/add_required_reorders.cpp
index b88ffc92fe6..215b115a711 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/add_required_reorders.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/add_required_reorders.cpp
@@ -9,7 +9,6 @@
 #include "pass_manager.h"
 #include "program_node.h"
 #include "mutable_data_inst.h"
-#include "concatenation_inst.h"
 #include "tensor_type.h"
 #include <memory>
 #include <vector>
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/concat_input_order.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/concat_input_order.cpp
index c47167e5dbd..832df989537 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/concat_input_order.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/concat_input_order.cpp
@@ -126,7 +126,7 @@ void concat_input_order::run(program& p) {
         auto& concat_node = node->as<concatenation>();
         auto prim = concat_node.get_primitive();
 
-        bool along_f = prim->axis == concatenation::along_f;
+        bool along_f = prim->axis == 1;
         size_t inputs_count = prim->input_size();
         bool no_fusing = !concat_node.has_fused_primitives() && concat_node.get_dependencies().size() == inputs_count;
 
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/graph_initializations.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/graph_initializations.cpp
index 13e50ed512b..5a7b314c9db 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/graph_initializations.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/graph_initializations.cpp
@@ -298,8 +298,7 @@ void graph_initializations::handle_lstm_node(program& p, lstm_node& node) {
             output_ids_offsets.push_back(e.second.first);
         }
         primitive_id concatenation_id = node.id() + ":concat";
-        auto concatenation_primitive =
-            std::make_shared<concatenation>(concatenation_id, output_ids_offsets, concatenation::along_f);
+        auto concatenation_primitive = std::make_shared<concatenation>(concatenation_id, output_ids_offsets, 1);
         auto& concatenation_node = p.get_or_create(concatenation_primitive);
         for (auto& e : output_map) {
             p.add_connection(*e.second.second, concatenation_node);
diff --git a/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_buffer_fusing.cpp b/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_buffer_fusing.cpp
index a2bd0420a39..e13e457af13 100644
--- a/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_buffer_fusing.cpp
+++ b/src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_buffer_fusing.cpp
@@ -125,6 +125,7 @@ bool concat_in_place_optimization::match(concatenation_node& node) {
     auto output_format = node.get_output_layout().format;
     auto output_datatype = node.get_output_layout().data_type;
     auto concat_axis = node.get_primitive()->axis;
+    auto def_fmt = format::get_default_format(node.get_output_layout().get_rank());
 
     size_t idx = 0;
     for (auto& input : node.get_dependencies()) {
@@ -145,22 +146,22 @@ bool concat_in_place_optimization::match(concatenation_node& node) {
         // It however would make normal optimizations possible in others, so this is a trade-off to be investigated.
         if (idx != node.get_dependencies().size() - 1) {
             if ((l.format == format::b_fs_yx_fsv16 || l.format == format::b_fs_zyx_fsv16) &&
-                (l.size.feature[0] % 16 != 0 || node.get_primitive()->axis != concatenation::along_f))
+                (l.size.feature[0] % 16 != 0 || node.get_primitive()->axis != 1))
                 return false;
 
             if ((l.format == format::b_fs_yx_fsv32 || l.format == format::b_fs_zyx_fsv32) &&
-                (l.size.feature[0] % 32 != 0 || node.get_primitive()->axis != concatenation::along_f))
+                (l.size.feature[0] % 32 != 0 || node.get_primitive()->axis != 1))
                 return false;
 
-            if (l.format == format::b_fs_yx_fsv4 && (l.size.feature[0] != 4 || node.get_primitive()->axis != concatenation::along_f))
+            if (l.format == format::b_fs_yx_fsv4 && (l.size.feature[0] != 4 || node.get_primitive()->axis != 1))
                 return false;
         }
         idx++;
     }
 
-    auto lower_padd_in_axis = node.get_output_layout().data_padding.lower_size().raw[concat_axis];
+    auto lower_padd_in_axis = node.get_output_layout().data_padding.lower_size().sizes(def_fmt)[concat_axis];
     lower_padd_in_axis = std::max(lower_padd_in_axis,
-                                  node.get_dependency(0).get_output_layout().data_padding.lower_size().raw[concat_axis]);
+                                  node.get_dependency(0).get_output_layout().data_padding.lower_size().sizes(def_fmt)[concat_axis]);
 
     // check if concatenation in place can be applied for inputs set
     idx = 0;
@@ -208,13 +209,13 @@ bool concat_in_place_optimization::match(concatenation_node& node) {
         // Check that there isn't already some padding between inputs in concat axis.
         // If node has already been optimized we skip this check - this is just cascade adjustment.
         if (!node.can_be_optimized()) {
-            if (idx != node.get_dependencies().size() && input_padd.upper_size().raw[concat_axis] != 0)
+            if (idx != node.get_dependencies().size() && input_padd.upper_size().sizes(def_fmt)[concat_axis] != 0)
                 return false;
-            if (idx != 0 && input_padd.lower_size().raw[concat_axis] != 0)
+            if (idx != 0 && input_padd.lower_size().sizes(def_fmt)[concat_axis] != 0)
                 return false;
         }
 
-        lower_padd_in_axis += input->get_output_layout().size.raw[concat_axis];
+        lower_padd_in_axis += input->get_output_layout().size.sizes(def_fmt)[concat_axis];
         idx += 1;
     }
 
@@ -222,31 +223,43 @@ bool concat_in_place_optimization::match(concatenation_node& node) {
 }
 
 void concat_in_place_optimization::optimize_cascade(concatenation_node& node, std::list<concatenation_node*>& need_reoptimization) {
+    auto out_layout = node.get_output_layout();
+    auto out_rank = out_layout.get_rank();
+    auto def_fmt = format::get_default_format(out_rank);
     auto concat_axis = node.get_primitive()->axis;
+    // We need to transform axis from bf[w][z]yx order to bfxy[z][w] due to tensor.sizes() usages here
+    // should be removed once pad representation is changed
+    auto concat_axis_legacy = concat_axis;
+    if (concat_axis_legacy >= 2) {
+        auto spatial_axis = concat_axis_legacy - 2;
+        // Default and minimum number of dimensions is 4
+        auto spatial_size = std::max<size_t>(out_rank, 4) - 2;
+        concat_axis_legacy = spatial_size - spatial_axis - 1 + 2;
+    }
 
     // Select output padding by propagating all required input paddings.
-    auto padd = node.get_output_layout().data_padding;
+    auto padd = out_layout.data_padding;
     for (auto input : node.get_dependencies()) {
         auto inputPadding = input->get_output_layout().data_padding;
         padd = padding::max(padd, inputPadding);
     }
 
-    auto lower_padd = padd.lower_size();
-    auto upper_padd = padd.upper_size();
+    auto lower_padd = padd.lower_size().sizes();
+    auto upper_padd = padd.upper_size().sizes();
 
     // For cascade adjustment override padding in concat axis to output padding.
     // In other case match(...) already checked that only first/last input have lower/upper padding.
     if (node.can_be_optimized()) {
-        lower_padd.raw[concat_axis] = node.get_output_layout().data_padding.lower_size().raw[concat_axis];
-        upper_padd.raw[concat_axis] = node.get_output_layout().data_padding.upper_size().raw[concat_axis];
+        lower_padd[concat_axis_legacy] = out_layout.data_padding.lower_size().sizes()[concat_axis_legacy];
+        upper_padd[concat_axis_legacy] = out_layout.data_padding.upper_size().sizes()[concat_axis_legacy];
     }
-    node.set_output_padding(padding(lower_padd.sizes(), upper_padd.sizes()));
+    node.set_output_padding(padding(lower_padd, upper_padd));
 
-    upper_padd.raw[concat_axis] += node.get_output_layout().size.raw[concat_axis];
+    upper_padd[concat_axis_legacy] += out_layout.get_dims()[concat_axis];
 
     // apply concatenation in place optimization
     for (auto input : node.get_dependencies()) {
-        auto input_length = input->get_output_layout().size.raw[concat_axis];
+        auto input_length = input->get_output_layout().get_dims()[concat_axis];
 
         if (input->is_type<concatenation>() && input->can_be_optimized())
             need_reoptimization.push_back(&input->as<concatenation>());
@@ -255,16 +268,16 @@ void concat_in_place_optimization::optimize_cascade(concatenation_node& node, st
         //
         //   |--- lower padd ---|                    |---------- upper padd -----------|
         //   |-- output padd ---| ----- input1 ------|----- input2 -----|-- out padd --|
-        upper_padd.raw[concat_axis] -= input_length;
+        upper_padd[concat_axis_legacy] -= input_length;
 
         // set new padding for input
-        input->set_output_padding(padding(lower_padd.sizes(), upper_padd.sizes()));
+        input->set_output_padding(padding(lower_padd, upper_padd));
 
         // move lower padd further
         //
         //   |-------------- lower padd -------------|---------- upper padd -----------|
         //   |-- output padd ---| ----- input1 ------|----- input2 -----|-- out padd --|
-        lower_padd.raw[concat_axis] += input_length;
+        lower_padd[concat_axis_legacy] += input_length;
     }
 
     node.can_be_optimized(true);
diff --git a/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp b/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
index f5f86e1c2f9..e0e22e31762 100644
--- a/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/ocl/concatenation.cpp
@@ -16,24 +16,33 @@ namespace cldnn {
 namespace ocl {
 
 namespace {
-kernel_selector::concat_axis convert_axis(concatenation::concatenation_axis axis) {
-    switch (axis) {
-        case concatenation::along_x:
-            return kernel_selector::concat_axis::X;
-        case concatenation::along_y:
-            return kernel_selector::concat_axis::Y;
-        case concatenation::along_z:
-            return kernel_selector::concat_axis::Z;
-        case concatenation::along_w:
-            return kernel_selector::concat_axis::W;
-        case concatenation::along_f:
-            return kernel_selector::concat_axis::FEATURE;
-        case concatenation::along_b:
-            return kernel_selector::concat_axis::BATCH;
-        default:
-            return kernel_selector::concat_axis::X;
+kernel_selector::concat_axis convert_axis(int64_t axis, size_t rank) {
+    unsigned cldnn_axis = axis >= 0 ? axis : axis + static_cast<int64_t>(rank);
+    if (cldnn_axis >= rank)
+        IE_THROW() << "Concatenation axis exceeds number of dimensions";
+
+    // Difference in dimension ordering between IE and GPU plugin,
+    // reverse spatial dimensions after batch and feature.
+    if (cldnn_axis >= 2) {
+        auto spatial_axis = cldnn_axis - 2;
+        // Default and minimum number of dimensions is 4
+        auto spatial_size = std::max<size_t>(rank, 4) - 2;
+        cldnn_axis = spatial_size - spatial_axis - 1 + 2;
     }
+
+    switch (cldnn_axis) {
+        case 0: return kernel_selector::concat_axis::BATCH;
+        case 1: return kernel_selector::concat_axis::FEATURE;
+        case 2: return kernel_selector::concat_axis::X;
+        case 3: return kernel_selector::concat_axis::Y;
+        case 4: return kernel_selector::concat_axis::Z;
+        case 5: return kernel_selector::concat_axis::W;
+        default: IE_THROW() << "Unsupported concatenation axis: " << axis;
+    }
+
+    return kernel_selector::concat_axis::FEATURE;  // shouldn't get here
 }
+
 }  // namespace
 
 struct concatenation_impl : typed_primitive_impl_ocl<concatenation> {
@@ -76,7 +85,7 @@ public:
             concat_params.inputs[i] = convert_data_tensor(input_layout);
         }
 
-        concat_params.axis = convert_axis(axis);
+        concat_params.axis = convert_axis(axis, arg.get_output_layout().get_rank());
         concat_optional_params.kernelPerInput = true;
 
         auto& kernel_selector = kernel_selector::concatenation_kernel_selector::Instance();
diff --git a/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp b/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp
index 98198fd86e5..c1c4e6b915b 100644
--- a/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp
+++ b/src/plugins/intel_gpu/src/graph/impls/onednn/concatenation_onednn.cpp
@@ -54,18 +54,9 @@ protected:
             input_mds.push_back(onednn::layout_to_memory_desc(input->get_output_layout()));
         }
         auto output_md = onednn::layout_to_memory_desc(arg.get_output_layout());
-        int axis = 0;
-        switch (prim->axis) {
-            case concatenation::concatenation_axis::along_b: axis = 0; break;
-            case concatenation::concatenation_axis::along_f: axis = 1; break;
-            case concatenation::concatenation_axis::along_y: axis = 2; break;
-            case concatenation::concatenation_axis::along_x: axis = 3; break;
-            default: throw std::runtime_error("unsupported concat axis");
-        }
-
         return std::make_shared<dnnl::concat::primitive_desc>(
             output_md,
-            axis,
+            prim->axis,
             input_mds,
             engine.get_onednn_engine());
     }
diff --git a/src/plugins/intel_gpu/src/plugin/ops/concat.cpp b/src/plugins/intel_gpu/src/plugin/ops/concat.cpp
index 2c101f299b8..60220dcc20e 100644
--- a/src/plugins/intel_gpu/src/plugin/ops/concat.cpp
+++ b/src/plugins/intel_gpu/src/plugin/ops/concat.cpp
@@ -13,40 +13,17 @@ namespace ov {
 namespace runtime {
 namespace intel_gpu {
 
-static cldnn::concatenation::concatenation_axis GetConcatAxis(int32_t axis, size_t rank) {
-    unsigned cldnn_axis = axis >= 0 ? axis : axis + static_cast<int32_t>(rank);
-    if (cldnn_axis >= rank)
-        IE_THROW() << "Concatenation axis exceeds number of dimensions";
-
-    // Difference in dimension ordering between IE and GPU plugin,
-    // reverse spatial dimensions after batch and feature.
-    if (cldnn_axis >= 2) {
-        auto spatial_axis = cldnn_axis - 2;
-        // Default and minimum number of dimensions is 4
-        auto spatial_size = std::max<size_t>(rank, 4) - 2;
-        cldnn_axis = spatial_size - spatial_axis - 1 + 2;
-    }
-
-    switch (cldnn_axis) {
-        case 0: return cldnn::concatenation::concatenation_axis::along_b;
-        case 1: return cldnn::concatenation::concatenation_axis::along_f;
-        case 2: return cldnn::concatenation::concatenation_axis::along_x;
-        case 3: return cldnn::concatenation::concatenation_axis::along_y;
-        case 4: return cldnn::concatenation::concatenation_axis::along_z;
-        case 5: return cldnn::concatenation::concatenation_axis::along_w;
-        default: IE_THROW() << "Unsupported concatenation axis: " << axis;
-    }
-
-    return cldnn::concatenation::concatenation_axis::along_f;  // shouldn't get here
-}
-
 static void CreateConcatOp(Program& p, const std::shared_ptr<ngraph::op::v0::Concat>& op) {
     auto inputPrimitives = p.GetInputPrimitiveIDs(op);
     std::string layerName = layer_type_name_ID(op);
+    int64_t axis = op->get_axis();
+    if (axis < 0)
+        axis = axis + static_cast<int64_t>(op->get_input_partial_shape(0).rank().get_length());
+
     auto concatPrim = cldnn::concatenation(
         layerName,
         inputPrimitives,
-        GetConcatAxis(op->get_axis(), op->get_input_shape(0).size()),
+        axis,
         DataTypeFromPrecision(op->get_output_element_type(0)),
         op->get_friendly_name());
 
diff --git a/src/plugins/intel_gpu/src/plugin/ops/convert_color.cpp b/src/plugins/intel_gpu/src/plugin/ops/convert_color.cpp
index 4b743e706bd..30fd9678097 100644
--- a/src/plugins/intel_gpu/src/plugin/ops/convert_color.cpp
+++ b/src/plugins/intel_gpu/src/plugin/ops/convert_color.cpp
@@ -51,7 +51,7 @@ static void CreateCommonConvertColorOp(Program& p, const std::shared_ptr<ngraph:
                                                 out_layout,
                                                 op->get_friendly_name()));
         }
-        p.AddPrimitive(cldnn::concatenation(layerName, convert_color_names, cldnn::concatenation::along_b, op->get_friendly_name()));
+        p.AddPrimitive(cldnn::concatenation(layerName, convert_color_names, 0, op->get_friendly_name()));
     } else {
         p.AddPrimitive(cldnn::convert_color(layerName,
                                             inputPrimitives,
diff --git a/src/plugins/intel_gpu/src/plugin/ops/parameter.cpp b/src/plugins/intel_gpu/src/plugin/ops/parameter.cpp
index 901271f07d4..d5820fea9c0 100644
--- a/src/plugins/intel_gpu/src/plugin/ops/parameter.cpp
+++ b/src/plugins/intel_gpu/src/plugin/ops/parameter.cpp
@@ -293,7 +293,7 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
 
             if (inputDims[0] > 1) {
                 auto concatPrimID = "concat:" + inputName + Program::m_preProcessTag;
-                p.AddPrimitive(cldnn::concatenation(concatPrimID, reorders, cldnn::concatenation::along_b, op->get_friendly_name()));
+                p.AddPrimitive(cldnn::concatenation(concatPrimID, reorders, 0, op->get_friendly_name()));
                 p.primitiveIDs[inputName] = concatPrimID;
             }
         } else {
diff --git a/src/plugins/intel_gpu/src/plugin/ops/rnn.cpp b/src/plugins/intel_gpu/src/plugin/ops/rnn.cpp
index 8dc8ffab82f..a8b877ef0e8 100644
--- a/src/plugins/intel_gpu/src/plugin/ops/rnn.cpp
+++ b/src/plugins/intel_gpu/src/plugin/ops/rnn.cpp
@@ -140,7 +140,7 @@ static void CreateLSTMCellOp(Program& p, const std::shared_ptr<ngraph::op::v4::L
                                   op->get_friendly_name()));
     p.AddPrimitive(cldnn::concatenation(input_concatID,
                                         { permuteID, hiddenInStr },
-                                        cldnn::concatenation::concatenation_axis::along_x,
+                                        3,
                                         op->get_friendly_name()));
 
     p.AddInnerPrimitiveToProfiler(hiddenInResh, op->get_friendly_name(), op);
@@ -159,7 +159,7 @@ static void CreateLSTMCellOp(Program& p, const std::shared_ptr<ngraph::op::v4::L
     std::string crop_id = layerName + "_crop";
 
     cldnn::primitive_id WRconcatID = layerName + "_WRconcat";
-    p.AddPrimitive(cldnn::concatenation(WRconcatID, { weightID, recurrentID }, cldnn::concatenation::concatenation_axis::along_f, op->get_friendly_name()));
+    p.AddPrimitive(cldnn::concatenation(WRconcatID, { weightID, recurrentID }, 1, op->get_friendly_name()));
     p.AddInnerPrimitiveToProfiler(WRconcatID, op->get_friendly_name(), op);
 
     p.AddPrimitive(cldnn::fully_connected(lstm_fc_id, input_concatID, WRconcatID, hasBias ? biasID : "", op->get_friendly_name()));
@@ -273,7 +273,7 @@ static void CreateLSTMSequenceOp(Program& p, const std::shared_ptr<ngraph::op::v
     cldnn::primitive_id inputCropID = layerName + "_inputCrop";
 
     cldnn::primitive_id WRconcatID = layerName + "_WRconcat";
-    p.AddPrimitive(cldnn::concatenation(WRconcatID, { weightID, recurrentID }, cldnn::concatenation::concatenation_axis::along_y, op->get_friendly_name()));
+    p.AddPrimitive(cldnn::concatenation(WRconcatID, { weightID, recurrentID }, 2, op->get_friendly_name()));
     p.AddInnerPrimitiveToProfiler(WRconcatID, op->get_friendly_name(), op);
 
     std::vector<size_t> WRreshapeSize = { 4 * size_t(lstm_hidden_size), size_t(lstm_input_size + lstm_hidden_size) };
@@ -300,7 +300,7 @@ static void CreateLSTMSequenceOp(Program& p, const std::shared_ptr<ngraph::op::v
         p.AddPrimitive(cldnn::crop(inputCrop_id, permuteID, crop_tensor, offset_tensor, op->get_friendly_name()));
         p.AddInnerPrimitiveToProfiler(inputCrop_id, op->get_friendly_name(), op);
 
-        p.AddPrimitive(cldnn::concatenation(concatID, { inputCrop_id, hiddenStr }, cldnn::concatenation::concatenation_axis::along_x, op->get_friendly_name()));
+        p.AddPrimitive(cldnn::concatenation(concatID, { inputCrop_id, hiddenStr }, 3, op->get_friendly_name()));
         p.AddInnerPrimitiveToProfiler(concatID, op->get_friendly_name(), op);
         p.AddPrimitive(cldnn::fully_connected(lstm_fc_id, concatID, WRreshapeID, biasID, op->get_friendly_name()));
         p.AddInnerPrimitiveToProfiler(lstm_fc_id, op->get_friendly_name(), op);
@@ -345,7 +345,7 @@ static void CreateLSTMSequenceOp(Program& p, const std::shared_ptr<ngraph::op::v
     // concatenated hidden state (output 1)
     cldnn::primitive_id outputConcatID = layerName + ".0";
     cldnn::primitive_id concatStr = layerName + ":hiddenConcat";
-    p.AddPrimitive(cldnn::concatenation(concatStr, output_ids_offsets, cldnn::concatenation::along_f, op->get_friendly_name()));
+    p.AddPrimitive(cldnn::concatenation(concatStr, output_ids_offsets, 1, op->get_friendly_name()));
 
     p.primitiveIDs[outputConcatID] = concatStr;
     p.primitiveIDs[layerName] = concatStr;
diff --git a/src/plugins/intel_gpu/tests/fusions/concatenate_fusion_test.cpp b/src/plugins/intel_gpu/tests/fusions/concatenate_fusion_test.cpp
index 053f78df1e2..db082f65562 100644
--- a/src/plugins/intel_gpu/tests/fusions/concatenate_fusion_test.cpp
+++ b/src/plugins/intel_gpu/tests/fusions/concatenate_fusion_test.cpp
@@ -102,7 +102,7 @@ TEST_P(concat_onednn_activation, along_f) {
         input_layout("input1", get_input_layout(p)),
         concatenation("concat",
                       { "input0", "input1" },
-                      concatenation::concatenation_axis::along_f,
+                      1,
                       data_types::f16,
                       "",
                       padding{ { 0, 0, 0, 0 }, 0 }),
@@ -125,7 +125,7 @@ TEST_P(concat_onednn_eltwise, along_f) {
         data("scale_data", get_mem(data_layout, 1.0f / tensor{ 1, 1, 4, 4 }.count())),
         concatenation("concat",
                       { "input0", "input1" },
-                      concatenation::concatenation_axis::along_f,
+                      1,
                       data_types::f16,
                       "",
                       padding{ { 0, 0, 0, 0 }, 0 }),
diff --git a/src/plugins/intel_gpu/tests/fusions/convolution_fusion_test.cpp b/src/plugins/intel_gpu/tests/fusions/convolution_fusion_test.cpp
index 562cfa7c15d..044122a985d 100644
--- a/src/plugins/intel_gpu/tests/fusions/convolution_fusion_test.cpp
+++ b/src/plugins/intel_gpu/tests/fusions/convolution_fusion_test.cpp
@@ -822,7 +822,7 @@ TEST_P(conv_fp32_eltwise_fusing_extend_ops, pattern01_simple_sub) {
         eltwise("eltwise2_sub", "conv_prim", "eltwise_data2", eltwise_mode::sub),
         eltwise("eltwise3_prod", "eltwise1_sum", "eltwise2_sub", eltwise_mode::prod),
         eltwise("eltwise4_sum", "eltwise3_prod", "eltwise_data4", eltwise_mode::sum),
-        concatenation("concat", { "eltwise4_sum", "eltwise4_sum" }, cldnn::concatenation::along_f),
+        concatenation("concat", { "eltwise4_sum", "eltwise4_sum" }, 1),
         reorder("reorder_bfyx", "concat", p.default_format, data_types::f32)
     );
     implementation_desc conv_impl = { format::b_fs_yx_fsv16, "" };
@@ -850,7 +850,7 @@ TEST_P(conv_fp32_eltwise_fusing_extend_ops, pattern02_sub_scale) {
         eltwise("eltwise2_sub", "conv_prim", "eltwise1_sum", eltwise_mode::sub),
         eltwise("eltwise3_prod", "eltwise2_sub", "eltwise_data2", eltwise_mode::prod),
         scale("scale", "eltwise3_prod", "scale_data"),
-        concatenation("concat", { "scale", "scale" }, cldnn::concatenation::along_f),
+        concatenation("concat", { "scale", "scale" }, 1),
         reorder("reorder_bfyx", "concat", p.default_format, data_types::f32)
     );
     implementation_desc conv_impl = { format::b_fs_yx_fsv16, "" };
@@ -879,7 +879,7 @@ TEST_P(conv_fp32_eltwise_fusing_extend_ops, pattern03_sub_div) {
         eltwise("eltwise2_div", "eltwise1_sum", "eltwise_data2", eltwise_mode::div),
         eltwise("eltwise3_prod", "eltwise2_div", "eltwise_data3", eltwise_mode::prod),
         eltwise("eltwise4_sum", "eltwise3_prod", "eltwise_data4", eltwise_mode::sum),
-        concatenation("concat", { "eltwise4_sum", "eltwise4_sum" }, cldnn::concatenation::along_f),
+        concatenation("concat", { "eltwise4_sum", "eltwise4_sum" }, 1),
         reorder("reorder_bfyx", "concat", p.default_format, data_types::f32)
     );
     implementation_desc conv_impl = { format::b_fs_yx_fsv16, "" };
@@ -917,7 +917,7 @@ TEST_P(conv_fp32_eltwise_fusing_2conv, basic) {
         eltwise("eltwise1", "conv_prim0", "conv_prim", eltwise_mode::sum),
         eltwise("eltwise2", "conv_prim0", "conv_prim", eltwise_mode::sum),
         eltwise("eltwise3", "eltwise1", "eltwise2", eltwise_mode::prod),
-        concatenation("concat", { "eltwise3", "eltwise3" }, cldnn::concatenation::along_f),
+        concatenation("concat", { "eltwise3", "eltwise3" }, 1),
         reorder("reorder_bfyx", "concat", p.default_format, data_types::f32)
     );
     implementation_desc conv_impl = { format::b_fs_yx_fsv16, "" };
@@ -1023,7 +1023,7 @@ TEST_P(conv_fp32_multi_eltwise_concat, basic) {
         eltwise("eltwise2", "conv_prim", "eltwise_data2", eltwise_mode::sum),
         concatenation("concat",
             { "eltwise1", "eltwise2" },
-            concatenation::concatenation_axis::along_f,
+            1,
             data_types::i8,
             "",
             padding{ { 0, 0, 0, 0 }, 0 }),
diff --git a/src/plugins/intel_gpu/tests/fusions/resample_fusion_test.cpp b/src/plugins/intel_gpu/tests/fusions/resample_fusion_test.cpp
index 1d1e807612f..27506403429 100644
--- a/src/plugins/intel_gpu/tests/fusions/resample_fusion_test.cpp
+++ b/src/plugins/intel_gpu/tests/fusions/resample_fusion_test.cpp
@@ -208,7 +208,7 @@ TEST_P(resample_quantize_concat, along_f) {
         data("out_lo_2", get_mem(get_single_element_layout(p), -127)),
         data("out_hi_2", get_mem(get_single_element_layout(p), 127)),
         quantize("quant2", "resample2", "in_lo_2", "in_hi_2", "out_lo_2", "out_hi_2", 255, data_types::i8),
-        concatenation("concat", { "quant1", "quant2" }, cldnn::concatenation::along_f),
+        concatenation("concat", { "quant1", "quant2" }, 1),
         reorder("reorder_bfyx", "concat", cldnn::format::bfyx, p.default_type)
     );
 
@@ -263,7 +263,7 @@ TEST_P(resample_scale_concat, along_f) {
         data("scale2_scale", get_mem(get_per_channel_layout(p), -10, 10)),
         data("scale2_shift", get_mem(get_per_channel_layout(p), -10, 10)),
         scale("scale2", "resample2", "scale2_scale", "scale2_shift"),
-        concatenation("concat", { "scale1", "scale2" }, cldnn::concatenation::along_f),
+        concatenation("concat", { "scale1", "scale2" }, 1),
         reorder("reorder_bfyx", "concat", cldnn::format::bfyx, p.default_type)
     );
 
diff --git a/src/plugins/intel_gpu/tests/module_tests/graph_manipulation_gpu_test.cpp b/src/plugins/intel_gpu/tests/module_tests/graph_manipulation_gpu_test.cpp
index fc91a1b7b05..5a4caa5c310 100644
--- a/src/plugins/intel_gpu/tests/module_tests/graph_manipulation_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/module_tests/graph_manipulation_gpu_test.cpp
@@ -46,7 +46,7 @@ TEST(basic, test1) {
     topology.add(reshape("reshape1", "weights1", tensor(spatial(1, 2))));
     topology.add(reorder("reorder2", "input", layout(data_types::f32, format::byxf, tensor(4))));
     topology.add(reorder("reorder1", "reshape1", layout(data_types::f32, format::byxf, tensor(4))));
-    topology.add(concatenation("concat", { "reorder1", "weights2" }, concatenation::along_x));
+    topology.add(concatenation("concat", { "reorder1", "weights2" }, 3));
     topology.add(convolution("conv2", { "reorder2" }, { "concat" }));
 
     program::ptr prog = program::build_program(engine, topology, build_opt, false);
diff --git a/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp
index 2ecd773642e..c78a96dfe41 100644
--- a/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/add_reorders_gpu_test.cpp
@@ -44,7 +44,7 @@ TEST(add_reorders_gpu, two_convolutions_and_concatenation) {
     topology.add(cldnn::reorder("reorder", "input", cldnn::layout(data_types::f32, format::byxf, tensor(4))));
     topology.add(cldnn::convolution("conv2", { "reorder" }, { "weights2" }));
 
-    topology.add(cldnn::concatenation("concat", { "conv1", "conv2" }, cldnn::concatenation::along_f));
+    topology.add(cldnn::concatenation("concat", { "conv1", "conv2" }, 1));
 
     network network(engine, topology, build_opt);
     network.set_input_data("input", input);
diff --git a/src/plugins/intel_gpu/tests/test_cases/barriers_test.cpp b/src/plugins/intel_gpu/tests/test_cases/barriers_test.cpp
index 5a99c201994..1489b2a6757 100644
--- a/src/plugins/intel_gpu/tests/test_cases/barriers_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/barriers_test.cpp
@@ -35,13 +35,13 @@ TEST(DISABLED_oooq_test, simple)
     tpl.add(reorder("r4", "r2", input_mem->get_layout(), std::vector<float>{ 4 }));
     tpl.add(reorder("r5", "r4", input_mem->get_layout(), std::vector<float>{ 5 }));
 
-    tpl.add(concatenation("c6", { "r3", "r5" }, concatenation::along_x));
+    tpl.add(concatenation("c6", { "r3", "r5" }, 3));
     layout concat_lay = input_mem->get_layout();
     concat_lay.size.spatial[0] *= 2;
 
     tpl.add(reorder("r7", "c6", concat_lay, std::vector<float>{ 7 }));
     tpl.add(reorder("r8", "c6", concat_lay, std::vector<float>{ 8 }));
-    tpl.add(concatenation("c9", { "r7", "r8" }, concatenation::along_y));
+    tpl.add(concatenation("c9", { "r7", "r8" }, 2));
     concat_lay.size.spatial[1] *= 2;
 
     build_options options;
diff --git a/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp
index 34b18e1828f..a4793a482a1 100644
--- a/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/concatenation_gpu_test.cpp
@@ -61,7 +61,7 @@ TEST(concat_gpu, mixed_input_types) {
             input_layout("input4", input4->get_layout()),
             concatenation("concat",
                           { "input0", "input1", "input2", "input3", "input4" },
-                          concatenation::concatenation_axis::along_f,
+                          1,
                           data_types::f32,
                           "",
                           padding{ { 0,0,0,0 }, 0 })
@@ -135,7 +135,7 @@ TEST(concat_gpu, mixed_input_types_5d) {
             input_layout("input3", input3->get_layout()),
             concatenation("concat",
                           { "input0", "input1", "input2", "input3" },
-                          concatenation::concatenation_axis::along_f,
+                          1,
                           data_types::f32,
                           "",
                           padding{ { 0,0,0,0 }, 0 })
@@ -210,7 +210,7 @@ TEST(concat_gpu, i8_optimization_with_pool) {
                       pooling("pool1", "input1", pooling_mode::max, {1, 1, 2, 2}, {1, 1, 1, 1}),
                       concatenation("concat",
                                     {"pool0", "pool1"},
-                                    concatenation::concatenation_axis::along_f,
+                                    1,
                                     data_types::i8,
                                     "",
                                     padding{{0, 0, 0, 0}, 0}),
@@ -311,7 +311,7 @@ TEST(concat_gpu, i8_optimization_with_conv) {
                       input_layout("input2", input2->get_layout()),
                       concatenation("concat",
                                     {"input0", "input1", "input2"},
-                                    concatenation::concatenation_axis::along_f,
+                                    1,
                                     data_types::i8,
                                     "",
                                     padding{{0, 0, 0, 0}, 0}),
@@ -413,7 +413,7 @@ TEST(concat_gpu, i8_optimization_with_pool_conv) {
                       pooling("pool1", "input1", pooling_mode::max, {1, 1, 2, 2}, {1, 1, 1, 1}),
                       concatenation("concat",
                                     {"pool0", "pool1"},
-                                    concatenation::concatenation_axis::along_f,
+                                    1,
                                     data_types::i8,
                                     "",
                                     padding{{0, 0, 0, 0}, 0}),
@@ -572,7 +572,7 @@ public:
             input_ids.push_back("input" + std::to_string(i));
         }
 
-        topology.add(concatenation("concat", input_ids, concatenation::concatenation_axis::along_f));
+        topology.add(concatenation("concat", input_ids, 1));
 
         build_options options;
         options.set_option(build_option::optimize_data(true));
@@ -696,7 +696,7 @@ public:
             input_ids.push_back("input" + std::to_string(i));
         }
 
-        topology.add(concatenation("concat", input_ids, concatenation::concatenation_axis::along_f));
+        topology.add(concatenation("concat", input_ids, 1));
         // Add identity convolution
         auto weights_lay = cldnn::layout(data_type, cldnn::format::bfyx, tensor(batch(output_f), feature(output_f)));
         auto weights_mem = engine.allocate_memory(weights_lay);
@@ -836,7 +836,7 @@ public:
             pooling_ids.push_back("pool" + std::to_string(i));
         }
 
-        topology.add(concatenation("concat", pooling_ids, concatenation::concatenation_axis::along_f));
+        topology.add(concatenation("concat", pooling_ids, 1));
         auto weights_lay = cldnn::layout(data_type, cldnn::format::bfyx, tensor(batch(output_f), feature(output_f)));
         auto weights_mem = engine.allocate_memory(weights_lay);
         weights_mem->fill(get_test_stream());
@@ -962,7 +962,7 @@ TEST(concat_gpu_onednn, basic_input_types) {
             input_layout("input4", input4->get_layout()),
             concatenation("concat",
                           { "input0", "input1", "input2", "input3", "input4" },
-                          concatenation::concatenation_axis::along_f,
+                          1,
                           data_types::f32,
                           "",
                           padding{ { 0,0,0,0 }, 0 })
@@ -1055,7 +1055,7 @@ public:
             pooling_ids.push_back("pool" + std::to_string(i));
         }
 
-        topology.add(concatenation("concat", pooling_ids, concatenation::concatenation_axis::along_f));
+        topology.add(concatenation("concat", pooling_ids, 1));
         auto weights_lay = cldnn::layout(data_type, cldnn::format::bfyx, tensor(batch(output_f), feature(output_f)));
         auto weights_mem = engine.allocate_memory(weights_lay);
         weights_mem->fill(get_test_stream());
diff --git a/src/plugins/intel_gpu/tests/test_cases/condition_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/condition_gpu_test.cpp
index f545e294085..e803159eef4 100644
--- a/src/plugins/intel_gpu/tests/test_cases/condition_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/condition_gpu_test.cpp
@@ -118,7 +118,7 @@ TEST(DISABLED_condition_gpu, basic_range_equal_comp) {
         input_layout("compare", compare->get_layout())
     );
     topology.add(
-        concatenation("concat", { "input0", "input1" }, concatenation::along_x)
+        concatenation("concat", { "input0", "input1" }, 3)
     );
     topology.add(
         condition("condi", "concat", branch_true, branch_false, "compare", cond_functions::EQUAL)
diff --git a/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp
index 493304587cb..5a53219e278 100644
--- a/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/convolution_gpu_test.cpp
@@ -5280,7 +5280,7 @@ TEST_P(convolution_gpu_fs_byx_fsv32_crop, fs_byx_fsv32_crop)
 
 
     topology.add(reorder("reorder", "conv_fsv", { data_types::f16, format::bfyx, input_size }));
-    topology.add(concatenation("concat", { "left_crop", "reorder" }, concatenation::concatenation_axis::along_f));
+    topology.add(concatenation("concat", { "left_crop", "reorder" }, 1));
 
     auto ref_result = VVVVF<FLOAT16>(batch_num);
     // concatenate half ref input and ref conv output, by features
diff --git a/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp
index 5ee047ffc98..538ea0a7a00 100644
--- a/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/depth_concatenate_gpu_test.cpp
@@ -65,7 +65,7 @@ TEST(depth_concatenate_f32_gpu, test01) {
     topology topology;
     topology.add(input_layout("input1", input1->get_layout()));
     topology.add(input_layout("input2", input2->get_layout()));
-    topology.add(concatenation("depth1", {"input1", "input2"}, concatenation::along_f));
+    topology.add(concatenation("depth1", {"input1", "input2"}, 1));
 
     network network(engine, topology);
 
@@ -126,7 +126,7 @@ void concat_basic_with_reorder() {
     topology.add(input_layout("input2", input2->get_layout()));
     topology.add(reorder("to_int1", "input1", {DType, format::yxfb, {2, 2, 1, 1}}));
     topology.add(reorder("to_int2", "input2", {DType, format::yxfb, {2, 3, 1, 1}}));
-    topology.add(concatenation("depth1", {"to_int1", "to_int2"}, concatenation::along_f));
+    topology.add(concatenation("depth1", {"to_int1", "to_int2"}, 1));
     topology.add(reorder("to_float", "depth1", {data_types::f32, format::yxfb, {2, 5, 1, 1}}));
 
     network network(engine, topology);
@@ -203,7 +203,7 @@ TEST(depth_concatenate_f32_gpu, test02) {
     topology.add(input_layout("input1", input1->get_layout()));
     topology.add(input_layout("input2", input2->get_layout()));
     topology.add(input_layout("input3", input3->get_layout()));
-    topology.add(concatenation("depth1", {"input1", "input2", "input3"}, concatenation::along_f));
+    topology.add(concatenation("depth1", {"input1", "input2", "input3"}, 1));
 
     network network(engine, topology);
 
@@ -251,7 +251,7 @@ TEST(concatenate_f32_gpu, test_concatenation_of_pool_and_unpool) {
                          {1, 1, 1, 1}  /*stride*/
                          ));
     topology.add(resample("unpool1", "input1", tensor(1, 1, 2, 2), 0, resample_type::nearest));
-    topology.add(concatenation("concat1", {"pool1", "unpool1"}, cldnn::concatenation::along_x));
+    topology.add(concatenation("concat1", {"pool1", "unpool1"}, 3));
     topology.add(data("weights", weights));
     topology.add(convolution("conv", "concat1", {"weights"}));
 
@@ -283,11 +283,11 @@ TEST(depth_concatenate_f32_gpu, test03_cascade_concat_opt) {
     topology.add(input_layout("input1", input1->get_layout()));
     topology.add(activation("relu1", "input1", activation_func::relu));
     topology.add(activation("relu2", "relu1", activation_func::sqrt));
-    topology.add(concatenation("depth1", {"relu2", "relu1"}, concatenation::along_f));
+    topology.add(concatenation("depth1", {"relu2", "relu1"}, 1));
     topology.add(activation("relu3", "depth1", activation_func::sqrt));
-    topology.add(concatenation("depth2", {"relu3", "depth1"}, concatenation::along_f));
+    topology.add(concatenation("depth2", {"relu3", "depth1"}, 1));
     topology.add(activation("relu4", "depth2", activation_func::sqrt));
-    topology.add(concatenation("depth3", {"relu4", "depth2"}, concatenation::along_f));
+    topology.add(concatenation("depth3", {"relu4", "depth2"}, 1));
     topology.add(activation("relu5", "depth3", activation_func::relu));
 
     cldnn::build_options options;
@@ -339,7 +339,7 @@ TEST(depth_concatenate_f32_gpu, test04_fused_relu) {
     topology topology;
     topology.add(input_layout("input1", input1->get_layout()));
     topology.add(input_layout("input2", input2->get_layout()));
-    topology.add(concatenation("depth1", {"input1", "input2"}, concatenation::along_f));
+    topology.add(concatenation("depth1", {"input1", "input2"}, 1));
     topology.add(activation("relu1", "depth1", activation_func::relu));
 
     cldnn::build_options options;
@@ -393,7 +393,7 @@ TEST(depth_concatenate_f32_gpu, test05_different_formats) {
     topology.add(input_layout("input2", input2->get_layout()));
     topology.add(reshape("reshape1", "input1", {1, 3, 2, 2}));
     topology.add(reshape("reshape2", "input2", {1, 3, 2, 2}));
-    topology.add(concatenation("depth1", {"reshape1", "reshape2"}, concatenation::along_f));
+    topology.add(concatenation("depth1", {"reshape1", "reshape2"}, 1));
     topology.add(reorder("output", "depth1", format::bfyx, data_types::f32));
 
     cldnn::build_options options;
@@ -451,8 +451,8 @@ TEST(depth_concatenate_f32_gpu, test06_padded_input) {
     topology.add(activation("actv2", "input2", activation_func::linear, { 0.5f, 0.0f }));
     topology.add(data("weights", weights));
     topology.add(convolution("conv", "actv2", { "weights" }, tensor(1), tensor(batch(0), feature(0), spatial(1, 1, 0, 0))));
-    topology.add(concatenation("depth1", { "actv1", "actv2" }, concatenation::along_f));
-    topology.add(concatenation("depth2", { "depth1", "conv" }, concatenation::along_f));
+    topology.add(concatenation("depth1", { "actv1", "actv2" }, 1));
+    topology.add(concatenation("depth2", { "depth1", "conv" }, 1));
     topology.add(reorder("output", "depth2", format::bfyx, data_types::f32));
 
     cldnn::build_options options;
@@ -526,7 +526,7 @@ TEST(depth_concatenate_f32_gpu, test07_padded_output) {
     topology.add(input_layout("input2", input2->get_layout()));
     topology.add(activation("actv1", "input1", activation_func::linear, { 0.75f, 0.0f }));
     topology.add(activation("actv2", "input2", activation_func::linear, { 0.5f, 0.0f }));
-    topology.add(concatenation("depth1", { "actv1", "actv2" }, concatenation::along_f));
+    topology.add(concatenation("depth1", { "actv1", "actv2" }, 1));
     topology.add(data("weights", weights));
     topology.add(convolution("conv", "depth1", { "weights" }, tensor(1), tensor(batch(0), feature(0), spatial(1, 1, 0, 0))));
     topology.add(reorder("output", "conv", format::bfyx, data_types::f32));
@@ -589,7 +589,7 @@ TEST(depth_concatenate_f32_gpu, test07_concat_is_output) {
     topology.add(input_layout("input2", input2->get_layout()));
     topology.add(activation("actv1", "input1", activation_func::linear, { 0.75f, 0.0f }));
     topology.add(activation("actv2", "input2", activation_func::linear, { 0.5f, 0.0f }));
-    topology.add(concatenation("depth1", { "actv1", "actv2" }, concatenation::along_f));
+    topology.add(concatenation("depth1", { "actv1", "actv2" }, 1));
 
     cldnn::build_options options;
     options.set_option(cldnn::build_option::optimize_data(true));
@@ -650,12 +650,12 @@ TEST(depth_concatenate_f32_gpu, concat_with_different_format_inputs) {
     topology topology;
     topology.add(input_layout("input1", input1->get_layout()));
     topology.add(input_layout("input2", input2->get_layout()));
-    topology.add(concatenation("depth1", { "input1" }, concatenation::along_f));
-    topology.add(concatenation("depth2", { "input2" }, concatenation::along_f));
+    topology.add(concatenation("depth1", { "input1" }, 1));
+    topology.add(concatenation("depth2", { "input2" }, 1));
     // In the step below there will be run of buffer fusing optimization for concatenation with
     // Input1 YXFB, Input2 BFYX and Output YXFB
-    topology.add(concatenation("depth3", { "depth1", "depth2" }, concatenation::along_f));
-    topology.add(concatenation("depth4", { "depth3" }, concatenation::along_f));
+    topology.add(concatenation("depth3", { "depth1", "depth2" }, 1));
+    topology.add(concatenation("depth4", { "depth3" }, 1));
 
     build_opt.set_option(build_option::optimize_data(true));
     network network(engine, topology, build_opt);
@@ -720,8 +720,8 @@ TEST(depth_concatenate_f32_gpu, concat_with_reshape_input) {
     topology topology;
     topology.add(input_layout("input1", input1->get_layout()));
     topology.add(reshape("reshape", "input1", tensor(2, 1, 4, 2)));
-    topology.add(concatenation("depth1", { "reshape" }, concatenation::along_f));
-    topology.add(concatenation("depth2", { "depth1" }, concatenation::along_f));
+    topology.add(concatenation("depth1", { "reshape" }, 1));
+    topology.add(concatenation("depth2", { "depth1" }, 1));
 
     build_opt.set_option(build_option::optimize_data(true));
     network network(engine, topology, build_opt);
@@ -750,9 +750,9 @@ TEST(depth_concatenate_i32_gpu, optimize_data01) {
     topology topology;
     topology.add(
         input_layout("input", input->get_layout()));
-    topology.add(cldnn::concatenation("int1", {"input"}, cldnn::concatenation::along_f));
-    topology.add(cldnn::concatenation("result1", {"int1"}, cldnn::concatenation::along_f));
-    topology.add(cldnn::concatenation("result2", {"int1"}, cldnn::concatenation::along_f));
+    topology.add(cldnn::concatenation("int1", {"input"}, 1));
+    topology.add(cldnn::concatenation("result1", {"int1"}, 1));
+    topology.add(cldnn::concatenation("result2", {"int1"}, 1));
 
     std::vector<int> input_data = {4};
     std::vector<int> out_data = {4};
@@ -787,14 +787,14 @@ TEST(depth_concatenate_i32_gpu, optimize_data02) {
     topology.add(
         input_layout("input4", input4->get_layout()));
 
-    topology.add(cldnn::concatenation("concat1", {"input1", "input2"}, cldnn::concatenation::along_x));
-    topology.add(cldnn::concatenation("concat2", {"input3", "input4"}, cldnn::concatenation::along_x));
-    topology.add(cldnn::concatenation("concat3", {"input2", "input4"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat1", {"input1", "input2"}, 3));
+    topology.add(cldnn::concatenation("concat2", {"input3", "input4"}, 3));
+    topology.add(cldnn::concatenation("concat3", {"input2", "input4"}, 3));
 
-    topology.add(cldnn::concatenation("concat4", {"concat1", "concat2"}, cldnn::concatenation::along_x));
-    topology.add(cldnn::concatenation("concat5", {"concat2", "concat3"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat4", {"concat1", "concat2"}, 3));
+    topology.add(cldnn::concatenation("concat5", {"concat2", "concat3"}, 3));
 
-    topology.add(cldnn::concatenation("concat6", {"concat4", "concat5"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat6", {"concat4", "concat5"}, 3));
 
     std::vector<int> input_data1 =
         {1, 2,
@@ -845,12 +845,12 @@ TEST(depth_concatenate_i32_gpu, optimize_data03) {
     topology.add(
         input_layout("input1", input1->get_layout()));
 
-    topology.add(cldnn::concatenation("concat1", {"input1"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat1", {"input1"}, 3));
 
-    topology.add(cldnn::concatenation("concat2", {"concat1"}, cldnn::concatenation::along_x));
-    topology.add(cldnn::concatenation("concat3", {"concat1"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat2", {"concat1"}, 3));
+    topology.add(cldnn::concatenation("concat3", {"concat1"}, 3));
 
-    topology.add(cldnn::concatenation("concat4", {"concat3"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat4", {"concat3"}, 3));
 
     std::vector<int> input_data1 =
         {1, 2,
@@ -885,12 +885,12 @@ TEST(depth_concatenate_i32_gpu, optimize_data04) {
     topology.add(
         input_layout("input1", input1->get_layout()));
 
-    topology.add(cldnn::concatenation("concat1", {"input1"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat1", {"input1"}, 3));
 
-    topology.add(cldnn::concatenation("concat2", {"concat1"}, cldnn::concatenation::along_x));
-    topology.add(cldnn::concatenation("concat3", {"concat1"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat2", {"concat1"}, 3));
+    topology.add(cldnn::concatenation("concat3", {"concat1"}, 3));
 
-    topology.add(cldnn::concatenation("concat4", {"concat2", "concat3"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat4", {"concat2", "concat3"}, 3));
 
     std::vector<int> input_data1 =
         {1, 2,
@@ -925,13 +925,13 @@ TEST(depth_concatenate_i32_gpu, optimize_data05) {
     topology.add(
         input_layout("input1", input1->get_layout()));
 
-    topology.add(cldnn::concatenation("concat1", {"input1"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat1", {"input1"}, 3));
 
-    topology.add(cldnn::concatenation("concat2", {"concat1"}, cldnn::concatenation::along_x));
-    topology.add(cldnn::concatenation("concat3", {"concat1"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat2", {"concat1"}, 3));
+    topology.add(cldnn::concatenation("concat3", {"concat1"}, 3));
 
-    topology.add(cldnn::concatenation("concat4", {"concat2", "concat3"}, cldnn::concatenation::along_x));
-    topology.add(cldnn::concatenation("concat5", {"concat1", "concat4"}, cldnn::concatenation::along_x));
+    topology.add(cldnn::concatenation("concat4", {"concat2", "concat3"}, 3));
+    topology.add(cldnn::concatenation("concat5", {"concat1", "concat4"}, 3));
 
     std::vector<int> input_data1 =
         {1, 2,
@@ -971,7 +971,7 @@ TEST(depth_concatenate_f32_gpu, basic_bfwzyx_along_w) {
 
     topology topology;
     topology.add(input_layout("input1", input1->get_layout()));
-    topology.add(concatenation("concat", {"input1", "input1"}, concatenation::along_w));
+    topology.add(concatenation("concat", {"input1", "input1"}, 2));
 
     auto input_data = generate_random_1d<float>(input1->count(), -1, 1);
 
@@ -1032,7 +1032,7 @@ static network::ptr setup_depth_concatatenate_network(const std::vector<data_typ
         topology.add(input_layout(input_names[i], input->get_layout()));
     }
     //TODO: ask Uzi if something tests cases where there's missing input_names (nodes not present in the topology, etc.)
-    topology.add(concatenation("depth_concat_node", input_names, concatenation::along_f));
+    topology.add(concatenation("depth_concat_node", input_names, 1));
 
     return network::build_network(engine, topology);
 }
@@ -1086,13 +1086,13 @@ public:
 
         switch (i) {
             case 1:
-                all_layer_params.emplace_back(new concatenation("depth_concatenate", {"input0"}, concatenation::along_f));
+                all_layer_params.emplace_back(new concatenation("depth_concatenate", {"input0"}, 1));
                 break;
             case 2:
-                all_layer_params.emplace_back(new concatenation("depth_concatenate", {"input0", "input1"}, concatenation::along_f));
+                all_layer_params.emplace_back(new concatenation("depth_concatenate", {"input0", "input1"}, 1));
                 break;
             case 3:
-                all_layer_params.emplace_back(new concatenation("depth_concatenate", {"input0", "input1", "input2"}, concatenation::along_f));
+                all_layer_params.emplace_back(new concatenation("depth_concatenate", {"input0", "input1", "input2"}, 1));
                 break;
             default:
                 assert(0);
diff --git a/src/plugins/intel_gpu/tests/test_cases/lstm_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/lstm_gpu_test.cpp
index 08054fbaf5f..d549e3fa743 100644
--- a/src/plugins/intel_gpu/tests/test_cases/lstm_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/lstm_gpu_test.cpp
@@ -390,7 +390,7 @@ void generate_lstm_topology(topology& t, memory::ptr input, memory::ptr hidden,
         }
         output_ids_offsets.push_back(hiddenStr);
     }
-    t.add(concatenation("concatenation", output_ids_offsets, concatenation::along_f));
+    t.add(concatenation("concatenation", output_ids_offsets, 1));
 }
 
 template<typename T>
@@ -1056,7 +1056,7 @@ void lstm_gpu_users_test() {
                       { activation_func::logistic, activation_func::hyperbolic_tan, activation_func::hyperbolic_tan }, {},
                       lstm_output_selection::hidden, default_offset_type));
     std::vector<primitive_id> output_ids_offsets {"lstm", "hidden"};
-    topology.add(concatenation("concatenation", output_ids_offsets, concatenation::along_f));
+    topology.add(concatenation("concatenation", output_ids_offsets, 1));
 
     network network(engine, topology);
     std::map<primitive_id, network_output> outputs;
diff --git a/src/plugins/intel_gpu/tests/test_cases/memory_test.cpp b/src/plugins/intel_gpu/tests/test_cases/memory_test.cpp
index 2e736743fbd..21db9a18143 100644
--- a/src/plugins/intel_gpu/tests/test_cases/memory_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/memory_test.cpp
@@ -178,10 +178,10 @@ TEST(memory_pool, oooq) {
     topology.add(activation("relu1", "input", activation_func::relu));
     topology.add(activation("relu2", "input", activation_func::relu));
     topology.add(activation("relu3", "input", activation_func::relu));
-    topology.add(concatenation("concat1", { "relu1", "relu2" },concatenation::along_f));
+    topology.add(concatenation("concat1", { "relu1", "relu2" }, 1));
     topology.add(activation("relu4", "concat1", activation_func::relu));
     topology.add(activation("relu5", "relu3", activation_func::relu));
-    topology.add(concatenation("concat2", { "relu4", "relu5" }, concatenation::along_f));
+    topology.add(concatenation("concat2", { "relu4", "relu5" }, 1));
     topology.add(activation("relu6", "concat2", activation_func::relu));
 
     build_options bo;
@@ -223,10 +223,10 @@ TEST(memory_pool, DISABLED_shared_mem_pool_same_topology_twice) {
     topology.add(activation("relu1", "input", activation_func::relu));
     topology.add(activation("relu2", "input", activation_func::sqrt));
     topology.add(activation("relu3", "input", activation_func::square));
-    topology.add(concatenation("concat1", { "relu1", "relu2" }, concatenation::along_f));
+    topology.add(concatenation("concat1", { "relu1", "relu2" }, 1));
     topology.add(activation("relu4", "concat1", activation_func::relu));
     topology.add(activation("relu5", "relu3", activation_func::relu));
-    topology.add(concatenation("concat2", { "relu4", "relu5" }, concatenation::along_f));
+    topology.add(concatenation("concat2", { "relu4", "relu5" }, 1));
     topology.add(activation("relu6", "concat2", activation_func::linear, { 1.0f, 0.5f }));
 
     build_options bo;
@@ -430,12 +430,12 @@ TEST(memory_pool, shared_dep_two_output) {
     auto result_1_0 = cldnn::concatenation(
         "result_1_0",
         { constant_0_0 },
-        cldnn::concatenation::along_b
+        0
     );
     auto result_2_0 = cldnn::concatenation(
         "result_2_0",
         { constant_0_0 },
-        cldnn::concatenation::along_b
+        0
     );
 
     //build and execute network
@@ -469,7 +469,7 @@ TEST(memory_pool, non_opt_intermidate_opt_after) {
     auto reshape_tensor = cldnn::tensor(8, 1, 1, 1);
     auto input = cldnn::input_layout("input1", input_layout1);
     auto input2 = cldnn::input_layout("input2", input_layout2);
-    auto concat = cldnn::concatenation("concat", { "input1", "input2" }, cldnn::concatenation::along_b);
+    auto concat = cldnn::concatenation("concat", { "input1", "input2" }, 0);
     auto reshape = cldnn::reshape("reshape", "concat", reshape_tensor);
     auto crop1 = cldnn::crop("crop1", "reshape", { 1, 1, 1, 1 }, { 0, 0, 0, 0 });
     auto crop2 = cldnn::crop("crop2", "reshape", { 1, 1, 1, 1 }, { 1, 0, 0, 0 });
diff --git a/src/plugins/intel_gpu/tests/test_cases/propagate_constants_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/propagate_constants_gpu_test.cpp
index 21921d82f7c..5e56b865f90 100644
--- a/src/plugins/intel_gpu/tests/test_cases/propagate_constants_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/propagate_constants_gpu_test.cpp
@@ -35,7 +35,7 @@ TEST(propagate_constants, copy_dependecies_from_nodes) {
     topology.add(reshape("reshape1", "weights1", tensor(spatial(1, 2))));
     topology.add(reorder("reorder2", "input", layout(data_types::f32, format::byxf, tensor(4))));
     topology.add(reorder("reorder1", "reshape1", layout(data_types::f32, format::byxf, tensor(4))));
-    topology.add(concatenation("concat", { "reorder1", "weights2" }, concatenation::along_x));
+    topology.add(concatenation("concat", { "reorder1", "weights2" }, 3));
     topology.add(convolution("conv2", { "reorder2" }, { "concat" }));
     network network(engine, topology, build_opt);
     network.set_input_data("input", input);
diff --git a/src/plugins/intel_gpu/tests/test_cases/set_output_memory_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/set_output_memory_gpu_test.cpp
index 5ac00f3ff74..555bbd069bc 100644
--- a/src/plugins/intel_gpu/tests/test_cases/set_output_memory_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/set_output_memory_gpu_test.cpp
@@ -311,8 +311,7 @@ TEST(set_output_memory_gpu, basic_opt) {
     topology.add(activation("clamp2", "input2", activation_func::clamp, params2));
     topology.add(reshape("reshape1", "clamp1", ishape));
     topology.add(reshape("reshape2", "clamp2", ishape));
-    topology.add(concatenation("concat", { "reshape1", "reshape2" },
-        concatenation::concatenation_axis::along_b, data_types::f32));
+    topology.add(concatenation("concat", { "reshape1", "reshape2" }, 0, data_types::f32));
     topology.add(reshape("reshape3", "concat", oshape));
     topology.add(reorder("reorder", "reshape3", ol));
     topology.add(reorder("reorder2", "reorder", ol));
diff --git a/src/plugins/intel_gpu/tests/test_cases/spatial_concatenate_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/spatial_concatenate_gpu_test.cpp
index b0ffd68656e..3429e654ec4 100644
--- a/src/plugins/intel_gpu/tests/test_cases/spatial_concatenate_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/spatial_concatenate_gpu_test.cpp
@@ -36,7 +36,7 @@ TEST(spatial_concatenate_f32_gpu, test01) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_x));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 3));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -91,7 +91,7 @@ TEST(spatial_concatenate_f32_gpu, test02) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_y));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 2));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -148,7 +148,7 @@ TEST(spatial_concatenate_f32_gpu, test03) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_y, "", padding({ 0, 0, 1, 1 }, 0.0f)));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 2, "", padding({ 0, 0, 1, 1 }, 0.0f)));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -203,7 +203,7 @@ TEST(spatial_concatenate_f32_gpu, test04) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_x, "", padding({ 0, 0, 2, 0 }, { 0, 0, 0, 0 })));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 3, "", padding({ 0, 0, 2, 0 }, { 0, 0, 0, 0 })));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -263,7 +263,7 @@ TEST(spatial_concatenate_f32_gpu, inputs_3) {
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
     tpl.add(input_layout("in3", input3->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2", "in3" }, concatenation::along_x));
+    tpl.add(concatenation("conc", { "in1", "in2", "in3" }, 3));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -351,7 +351,7 @@ TEST(spatial_concatenate_f32_gpu, inputs_3_uneven_axis_b) {
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
     tpl.add(input_layout("in3", input3->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2", "in3" }, concatenation::along_b));
+    tpl.add(concatenation("conc", { "in1", "in2", "in3" }, 0));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -411,7 +411,7 @@ TEST(spatial_concatenate_f32_gpu, inputs3d_axis_x) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_x));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 4));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -475,7 +475,7 @@ TEST(spatial_concatenate_f32_gpu, inputs3d_axis_y) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_y));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 3));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -539,7 +539,7 @@ TEST(spatial_concatenate_f32_gpu, inputs3d_axis_z) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_z));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 2));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -614,7 +614,7 @@ TEST(spatial_concatenate_f32_gpu, inputs3d_axis_b) {
     topology tpl;
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2" }, concatenation::along_b));
+    tpl.add(concatenation("conc", { "in1", "in2" }, 0));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
@@ -744,7 +744,7 @@ TEST(spatial_concatenate_f32_gpu, inputs3d_3_uneven_axis_b) {
     tpl.add(input_layout("in1", input1->get_layout()));
     tpl.add(input_layout("in2", input2->get_layout()));
     tpl.add(input_layout("in3", input3->get_layout()));
-    tpl.add(concatenation("conc", { "in1", "in2", "in3" }, concatenation::along_b));
+    tpl.add(concatenation("conc", { "in1", "in2", "in3" }, 0));
 
     network net(engine, tpl);
     net.set_input_data("in1", input1);
diff --git a/src/plugins/intel_gpu/tests/test_cases/split_gpu_test.cpp b/src/plugins/intel_gpu/tests/test_cases/split_gpu_test.cpp
index dc33ba4f66c..c28d47adf04 100644
--- a/src/plugins/intel_gpu/tests/test_cases/split_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/split_gpu_test.cpp
@@ -221,7 +221,7 @@ TEST(split_gpu_f32, basic_split_concat_optimization) {
     }
 
     topology.add(split("split", "input", offsets));
-    topology.add(concatenation("concat", ids, concatenation::along_f));
+    topology.add(concatenation("concat", ids, 1));
     topology.add(reorder("output", "concat", format::bfyx, data_types::f32));
 
     build_options opts;
@@ -261,7 +261,7 @@ TEST(split_gpu_i64, basic_split_concat_optimization) {
     }
 
     topology.add(split("split", "input", offsets));
-    topology.add(concatenation("concat", ids, concatenation::along_f));
+    topology.add(concatenation("concat", ids, 1));
     topology.add(reorder("output", "concat", format::bfyx, data_types::i64));
 
     build_options opts;
diff --git a/src/plugins/intel_gpu/tests/test_cases/topology_test.cpp b/src/plugins/intel_gpu/tests/test_cases/topology_test.cpp
index 18e423dad76..90c8c921a3d 100644
--- a/src/plugins/intel_gpu/tests/test_cases/topology_test.cpp
+++ b/src/plugins/intel_gpu/tests/test_cases/topology_test.cpp
@@ -283,7 +283,7 @@ protected:
                 input_layouts.push_back({ input_id1, input_layout1 });
                 input_layouts.push_back({ input_id2, input_layout2 });
 
-                topology.add(cldnn::concatenation(id, { input_id1,input_id2 }, cldnn::concatenation::along_f));
+                topology.add(cldnn::concatenation(id, { input_id1,input_id2 }, 1));
                 return true;
             }
         };