diff --git a/admin/src/scenes/classe/Import.tsx b/admin/src/scenes/classe/Import.tsx
new file mode 100644
index 0000000000..f485a09004
--- /dev/null
+++ b/admin/src/scenes/classe/Import.tsx
@@ -0,0 +1,106 @@
+import React, { ChangeEvent, useRef, useState } from "react";
+import ReactLoading from "react-loading";
+import { HiOutlineDocumentAdd } from "react-icons/hi";
+
+import { MIME_TYPES, translate } from "snu-lib";
+
+import api from "@/services/api";
+import { capture } from "@/sentry";
+
+import { Button, Container, Header, Page } from "@snu/ds/admin";
+
+import { toastr } from "react-redux-toastr";
+
+const FILE_SIZE_LIMIT = 5 * 1024 * 1024;
+
+export default function Import() {
+  const [isUploading, setIsUploading] = useState(false);
+  const [uploadError, setUploadError] = useState<string | null>(null);
+  const fileInput = useRef<HTMLInputElement>(null);
+
+  function importFile(e: React.MouseEvent<HTMLButtonElement>) {
+    e.preventDefault();
+    setUploadError(null);
+    if (fileInput && fileInput.current) {
+      fileInput.current.click();
+    }
+  }
+
+  async function handleUpload(e: ChangeEvent<HTMLInputElement>) {
+    if (!e?.target?.files?.length) return;
+    const file = e.target.files[0];
+    setUploadError(null);
+    if (file.type !== MIME_TYPES.EXCEL) {
+      setUploadError("Le fichier doit être au format Excel.");
+      return;
+    }
+    if (file.size > FILE_SIZE_LIMIT) {
+      setUploadError("Votre fichier dépasse la limite de 5Mo.");
+      return;
+    }
+
+    setIsUploading(true);
+    try {
+      const res = await api.uploadFiles(`/cle/classe/importAuto/classe-importAuto`, [file]);
+      if (res.code === "FILE_CORRUPTED") {
+        setUploadError("Le fichier semble corrompu. Pouvez-vous changer le format ou regénérer votre fichier ? Si vous rencontrez toujours le problème, contactez le support.");
+      } else if (!res.ok) {
+        toastr.error("Une erreur est survenue lors de l'import du fichier", translate(res.code));
+        capture(res.code);
+        setUploadError("Une erreur s'est produite lors du téléversement de votre fichier.");
+      } else {
+        toastr.success("Succès", "Fichier importé avec succès");
+        const { data: base64Data, mimeType, fileName } = res;
+        const binaryData = Uint8Array.from(atob(base64Data), (c) => c.charCodeAt(0));
+
+        const blob = new Blob([binaryData], { type: mimeType });
+        const url = window.URL.createObjectURL(blob);
+
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = fileName;
+        document.body.appendChild(a);
+        a.click();
+
+        a.remove();
+        window.URL.revokeObjectURL(url);
+      }
+    } catch (err) {
+      setUploadError("La requête étant trop longue, nous vous avons envoyé un mail avec le fichier de résultat.");
+    }
+    setIsUploading(false);
+  }
+
+  return (
+    <Page>
+      <Header title="Import des classes" breadcrumb={[{ title: "Séjours" }, { title: "Classes" }, { title: "Import" }]} />
+      <Container>
+        <div className="mt-8 flex w-full flex-col items-center justify-center bg-white rounded-xl px-8 pt-12 pb-24">
+          <div className="bg-gray-50 w-full flex-col pb-5">
+            <h1 className="text-lg leading-6 font-medium text-gray-900 text-center mt-12 mb-2">Mettre à jour les classes</h1>
+            <p className="text-sm leading-5 font-normal text-gray-500 text-center mb-12">Importez votre fichier (au format .xlsx jusqu’à 5Mo)</p>
+
+            {!isUploading ? (
+              <>
+                <Button
+                  onClick={importFile}
+                  className="cursor-pointer text-center mx-auto text-blue-600"
+                  leftIcon={<HiOutlineDocumentAdd className="mt-0.5 mr-2" size={20} />}
+                  title="Téléversez votre fichier"></Button>
+                <input type="file" accept={MIME_TYPES.EXCEL} ref={fileInput} onChange={handleUpload} className="hidden" />
+                {uploadError && <div className="mt-8 text-center text-sm font-bold text-red-900">{uploadError}</div>}
+              </>
+            ) : (
+              <>
+                <div className="mx-auto flex justify-center mb-2">
+                  <p>Temps Estimé : 1 minute</p>
+                </div>
+                <ReactLoading className="mx-auto" type="spin" color="#2563EB" width={"40px"} height={"40px"} />
+              </>
+            )}
+          </div>
+        </div>
+      </Container>
+    </Page>
+  );
+}
diff --git a/admin/src/scenes/classe/index.jsx b/admin/src/scenes/classe/index.jsx
index 9c3c047d89..d5401826d7 100644
--- a/admin/src/scenes/classe/index.jsx
+++ b/admin/src/scenes/classe/index.jsx
@@ -6,6 +6,7 @@ import { SentryRoute } from "../../sentry";
 import Create from "./create";
 import List from "./list";
 import View from "./view";
+import Import from "./Import";
 import { toastr } from "react-redux-toastr";
 import NotFound from "@/components/layout/NotFound";
 
@@ -15,6 +16,7 @@ export default function Index() {
   return (
     <Switch>
       <SentryRoute path="/classes/create" component={Create} />
+      <SentryRoute path="/classes/import" component={Import} />
       <SentryRoute
         path="/classes/:id"
         render={({ match }) => {
diff --git a/admin/src/scenes/classe/list.tsx b/admin/src/scenes/classe/list.tsx
index 7b24495eda..5ba0eba630 100644
--- a/admin/src/scenes/classe/list.tsx
+++ b/admin/src/scenes/classe/list.tsx
@@ -10,7 +10,7 @@ import { Filters, ResultTable, Save, SelectedFilters, SortOption } from "@/compo
 import { capture } from "@/sentry";
 import api from "@/services/api";
 import { Button, Container, Header, Page } from "@snu/ds/admin";
-import { ROLES, translateStatusClasse, translate, EtablissementType, ClasseType } from "snu-lib";
+import { ROLES, translateStatusClasse, translate, EtablissementType, ClasseType, isSuperAdmin } from "snu-lib";
 import { orderCohort } from "../../components/filters-system-v2/components/filters/utils";
 
 import { getCohortGroups } from "@/services/cohort.service";
@@ -142,12 +142,18 @@ export default function List() {
           [ROLES.ADMIN, ROLES.REFERENT_REGION].includes(user.role) && (
             <Button
               title="Exporter le SR"
+              className="mr-2"
               onClick={() => exportData({ type: "schema-de-repartition" })}
               loading={exportLoading}
               disabled={!isCohortSelected}
               tooltip="Vous devez selectionner une cohort pour pouvoir exporter le SR"
             />
           ),
+          isSuperAdmin(user) && (
+            <Link to="/classes/import">
+              <Button title="Mettre à jour" className="mr-2" loading={exportLoading} />
+            </Link>
+          ),
         ].filter(Boolean)}
       />
       {!isClasses && (
diff --git a/api/package.json b/api/package.json
index 40a6d57773..36b88b0592 100644
--- a/api/package.json
+++ b/api/package.json
@@ -101,6 +101,6 @@
     "supertest": "6.3.4",
     "ts-jest": "^29.2.5",
     "typescript": "5.4.5",
-    "xlsx": "~0.18.5"
+    "xlsx": "^0.18.5"
   }
 }
diff --git a/api/src/__tests__/cle/classeImport.test.ts b/api/src/__tests__/cle/classeImport.test.ts
index 7966d20154..ac3d2b1245 100644
--- a/api/src/__tests__/cle/classeImport.test.ts
+++ b/api/src/__tests__/cle/classeImport.test.ts
@@ -107,7 +107,6 @@ ${classe3?._id},""
         importType: ClasseImportType.FIRST_CLASSE_COHORT,
       },
     ];
-    console.log(response.body);
     expect(response.body.ok).toBe(true);
     expect(response.body.data).toEqual(expectedResponse);
   });
diff --git a/api/src/__tests__/cle/classeImportAuto.test.ts b/api/src/__tests__/cle/classeImportAuto.test.ts
new file mode 100644
index 0000000000..52a3260c77
--- /dev/null
+++ b/api/src/__tests__/cle/classeImportAuto.test.ts
@@ -0,0 +1,56 @@
+import request from "supertest";
+import { ROLES } from "snu-lib";
+import { uploadFile } from "../../utils";
+import { sendTemplate } from "../../brevo";
+import { readCSVBuffer, XLSXToCSVBuffer } from "../../services/fileService";
+import { updateClasseFromExport } from "../../cle/classe/importAuto/classeImportAutoService";
+import getAppHelper from "../helpers/app";
+import { dbClose, dbConnect } from "../helpers/db";
+
+beforeAll(() => dbConnect(__filename.slice(__dirname.length + 1, -3)));
+afterAll(dbClose);
+
+jest.mock("../../utils", () => ({
+  ...jest.requireActual("../../utils"),
+  uploadFile: jest.fn(),
+}));
+
+jest.mock("../../brevo", () => ({
+  sendTemplate: jest.fn(),
+}));
+
+jest.mock("../../services/fileService", () => ({
+  XLSXToCSVBuffer: jest.fn(),
+  readCSVBuffer: jest.fn(),
+}));
+
+jest.mock("../../cle/classe/importAuto/classeImportAutoService", () => ({
+  updateClasseFromExport: jest.fn(),
+}));
+
+describe("POST /classe-importAuto", () => {
+  const xlsxMimetype = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+
+  const fileContent = "sample file content";
+  const fileBuffer = Buffer.from(fileContent);
+  const mockParsedContent = [{ classeId: "mockClasseId", status: "ASSIGNED" }];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Mock file handling services
+    (uploadFile as jest.Mock).mockResolvedValue({ location: "mockLocation" });
+    (sendTemplate as jest.Mock).mockResolvedValue(true);
+    (XLSXToCSVBuffer as jest.Mock).mockReturnValue(fileBuffer);
+    (readCSVBuffer as jest.Mock).mockResolvedValue(mockParsedContent);
+    (updateClasseFromExport as jest.Mock).mockResolvedValue(mockParsedContent);
+  });
+
+  it("should return 403 if the user does not have superadmin role", async () => {
+    const response = await request(getAppHelper({ role: ROLES.VISITOR }))
+      .post("/cle/classe/importAuto/classe-importAuto")
+      .send({});
+
+    expect(response.status).toBe(403);
+  });
+});
diff --git a/api/src/cle/classe/importAuto/classeImportAutoController.ts b/api/src/cle/classe/importAuto/classeImportAutoController.ts
new file mode 100644
index 0000000000..4ee7b64334
--- /dev/null
+++ b/api/src/cle/classe/importAuto/classeImportAutoController.ts
@@ -0,0 +1,88 @@
+import express from "express";
+import fileUpload from "express-fileupload";
+import { UploadedFile } from "express-fileupload";
+import fs from "fs";
+
+import { isSuperAdmin, SENDINBLUE_TEMPLATES } from "snu-lib";
+import { sendTemplate } from "../../../brevo";
+import { ERRORS, uploadFile } from "../../../utils";
+import { UserRequest } from "../../../controllers/request";
+import { capture } from "../../../sentry";
+import { readCSVBuffer, generateCSVStream, getHeaders, streamToBuffer, XLSXToCSVBuffer } from "../../../services/fileService";
+import { accessControlMiddleware } from "../../../middlewares/accessControlMiddleware";
+import { authMiddleware } from "../../../middlewares/authMiddleware";
+
+import { updateClasseFromExport } from "./classeImportAutoService";
+import { ClasseFromCSV } from "./classeImportAutoType";
+
+const router = express.Router();
+router.use(authMiddleware("referent"));
+const xlsxMimetype = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+
+router.post(
+  "/classe-importAuto",
+  [accessControlMiddleware([])],
+  fileUpload({ limits: { fileSize: 5 * 1024 * 1024 }, useTempFiles: true, tempFileDir: "/tmp/" }),
+  async (req: UserRequest, res) => {
+    if (!isSuperAdmin(req.user)) {
+      return res.status(403).send({ ok: false, code: ERRORS.OPERATION_UNAUTHORIZED });
+    }
+
+    try {
+      const user = req.user;
+      const files = Object.values(req.files || {});
+      if (files.length === 0) {
+        return res.status(400).send({ ok: false, code: ERRORS.INVALID_BODY });
+      }
+
+      const file: UploadedFile = files[0];
+      if (file.mimetype !== xlsxMimetype) {
+        return res.status(400).send({ ok: false, code: ERRORS.INVALID_BODY });
+      }
+      const filePath = file.tempFilePath;
+      const timestamp = `${new Date().toISOString()?.replaceAll(":", "-")?.replace(".", "-")}`;
+
+      const data = fs.readFileSync(filePath);
+
+      uploadFile(`file/appelAProjet/import/import-classe/import-${timestamp}/${timestamp}-exported-classes.xlsx`, {
+        data: data,
+        encoding: "",
+        mimetype: xlsxMimetype,
+      });
+
+      const csvBuffer = XLSXToCSVBuffer(filePath);
+      const parsedContent: ClasseFromCSV[] = await readCSVBuffer(csvBuffer);
+      const importedClasseCohort = await updateClasseFromExport(parsedContent);
+
+      const headers = getHeaders(importedClasseCohort);
+      const csvDataReponse = generateCSVStream(importedClasseCohort, headers);
+      const responseFileName = `${timestamp}-updated-classes.csv`;
+      uploadFile(`file/appelAProjet/import/import-classe/import-${timestamp}/${responseFileName}`, {
+        data: csvDataReponse,
+        encoding: "",
+        mimetype: "text/csv",
+      });
+
+      const csvBufferResponse = Buffer.from(await streamToBuffer(csvDataReponse));
+
+      const contentData = csvBufferResponse.toString("base64");
+
+      await sendTemplate(SENDINBLUE_TEMPLATES.CLE.IMPORT_DES_CLASSES, {
+        emailTo: [{ name: `${user.firstName} ${user.lastName}`, email: user.email! }],
+        attachment: [{ content: contentData, name: responseFileName }],
+      });
+
+      return res.status(200).send({
+        data: contentData,
+        mimeType: "text/csv",
+        fileName: responseFileName,
+        ok: true,
+      });
+    } catch (error) {
+      capture(error);
+      return res.status(422).send({ ok: false, code: error.message });
+    }
+  },
+);
+
+export default router;
diff --git a/api/src/cle/classe/importAuto/classeImportAutoMapper.ts b/api/src/cle/classe/importAuto/classeImportAutoMapper.ts
new file mode 100644
index 0000000000..da753cc685
--- /dev/null
+++ b/api/src/cle/classe/importAuto/classeImportAutoMapper.ts
@@ -0,0 +1,15 @@
+import { ClasseFromCSV, ClasseMapped } from "./classeImportAutoType";
+
+export const mapClassesForUpdate = (classesChortes: ClasseFromCSV[]): ClasseMapped[] => {
+  return classesChortes.map((classeCohorte) => {
+    const classeCohorteMapped: ClasseMapped = {
+      classeId: classeCohorte["Identifiant de la classe engagée"],
+      cohortCode: classeCohorte["Session formule"],
+      classeTotalSeats: classeCohorte["Effectif de jeunes concernés"],
+      centerCode: classeCohorte["Désignation du centre"],
+      pdrCode: classeCohorte["Code point de rassemblement initial"],
+      sessionCode: `${classeCohorte["Session : Code de la session"]}_${classeCohorte["Désignation du centre"]}`,
+    };
+    return classeCohorteMapped;
+  });
+};
diff --git a/api/src/cle/classe/importAuto/classeImportAutoService.test.ts b/api/src/cle/classe/importAuto/classeImportAutoService.test.ts
new file mode 100644
index 0000000000..559eeaedcc
--- /dev/null
+++ b/api/src/cle/classe/importAuto/classeImportAutoService.test.ts
@@ -0,0 +1,283 @@
+import { updateYoungsCohorts, updateClasseFromExport, updateClasse } from "./classeImportAutoService";
+import * as classeImportService from "./classeImportAutoService";
+import { CohortDocument, ClasseModel, ClasseDocument, YoungModel, CohesionCenterModel, PointDeRassemblementModel, SessionPhase1Model } from "../../../models";
+import { ERRORS, FUNCTIONAL_ERRORS, STATUS_CLASSE, STATUS_PHASE1_CLASSE } from "snu-lib";
+import mongoose from "mongoose";
+import { ClasseMapped, ClasseUpdateFileResult } from "./classeImportAutoType";
+import { mapClassesForUpdate } from "./classeImportAutoMapper";
+import { findCohortBySnuIdOrThrow } from "../../../cohort/cohortService";
+
+jest.mock("../../../models", () => ({
+  CohortModel: { findById: jest.fn() },
+  ClasseModel: { findById: jest.fn(), save: jest.fn() },
+  YoungModel: { find: jest.fn(), save: jest.fn() },
+  CohesionCenterModel: { findOne: jest.fn() },
+  PointDeRassemblementModel: { findOne: jest.fn() },
+  SessionPhase1Model: { findOne: jest.fn() },
+}));
+
+jest.mock("./classeImportAutoMapper", () => ({
+  mapClassesForUpdate: jest.fn(),
+}));
+
+jest.mock("../../../cohort/cohortService", () => ({
+  findCohortBySnuIdOrThrow: jest.fn(),
+}));
+
+describe("updateClasseFromExport", () => {
+  beforeAll(() => {
+    jest.spyOn(classeImportService, "updateClasse").mockImplementationOnce(() => {
+      return Promise.resolve({
+        updatedClasse: {
+          _id: "1",
+          cohort: "Cohort 101",
+          cohortId: "101",
+          status: "OPEN",
+          totalSeats: 1,
+        } as ClasseDocument,
+        updatedFields: ["cohort", "cohortId", "status", "totalSeats"],
+        error: [],
+      });
+    });
+    jest.spyOn(classeImportService, "updateClasse").mockImplementationOnce(() => {
+      throw new Error(ERRORS.COHORT_NOT_FOUND);
+    });
+  });
+
+  it("should successfully import classe cohorts", async () => {
+    const mockCSV = [
+      { "Identifiant de la classe engagée": "1", "Session formule": "Cohort 101", "Effectif de jeunes concernés": 1 },
+      { "Identifiant de la classe engagée": "2", "Session formule": "Cohort 102", "Effectif de jeunes concernés": 2 },
+    ];
+    const mappedClassesCohorts = [
+      { classeId: "1", cohortCode: "IDF_101" },
+      { classeId: "2", cohortCode: "IDF_102" },
+    ];
+    const mockImportResult = [
+      {
+        result: "success",
+        classeId: "1",
+        cohortCode: "IDF_101",
+        cohortId: "101",
+        cohortName: "Cohort 101",
+        classeStatus: "OPEN",
+        classeTotalSeats: 1,
+        updated: "cohort, cohortId, status, totalSeats",
+      },
+      { result: "error", classeId: "2", cohortCode: "IDF_102", error: ERRORS.COHORT_NOT_FOUND, classeTotalSeats: undefined },
+    ];
+
+    (mapClassesForUpdate as jest.Mock).mockReturnValue(mappedClassesCohorts);
+
+    const result = await updateClasseFromExport(mockCSV);
+
+    expect(mapClassesForUpdate).toHaveBeenCalledWith(mockCSV);
+    expect(updateClasse).toHaveBeenCalledTimes(2);
+    expect(updateClasse).toHaveBeenCalledWith({ classeId: "1", cohortCode: "IDF_101" });
+    expect(updateClasse).toHaveBeenCalledWith({ classeId: "2", cohortCode: "IDF_102" });
+    expect(result).toEqual(mockImportResult);
+  });
+});
+
+describe("updateYoungsCohorts", () => {
+  const classeId = new mongoose.Types.ObjectId().toString();
+  const cohortId = new mongoose.Types.ObjectId().toString();
+  const cohortName = "Cohort 2024";
+  const cohortMock: CohortDocument = {
+    _id: cohortId,
+    name: cohortName,
+  } as CohortDocument;
+  const youngId = new mongoose.Types.ObjectId().toString();
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it("should update youngs with new cohort information", async () => {
+    const youngMock = {
+      _id: youngId,
+      cohortId: "originalCohortId",
+      cohort: "Original Cohort Name",
+      set: jest.fn().mockReturnThis(),
+      save: jest.fn(),
+    };
+
+    (YoungModel.find as jest.Mock).mockResolvedValue([youngMock]);
+
+    await updateYoungsCohorts(classeId, cohortMock);
+
+    expect(YoungModel.find).toHaveBeenCalledWith({ classeId });
+    expect(youngMock.set).toHaveBeenCalledWith({
+      cohort: cohortName,
+      cohortId: cohortId,
+      originalCohort: "Original Cohort Name",
+      originalCohortId: "originalCohortId",
+      cohortChangeReason: "Import SI-SNU",
+    });
+    expect(youngMock.save).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fromUser: expect.objectContaining({
+          firstName: expect.stringContaining("UPDATE_CLASSE_COHORT"),
+        }),
+      }),
+    );
+  });
+
+  it("should not throw an error if no youngs are found", async () => {
+    (YoungModel.find as jest.Mock).mockResolvedValue([]);
+
+    await expect(updateYoungsCohorts(classeId, cohortMock)).resolves.not.toThrow();
+
+    expect(YoungModel.find).toHaveBeenCalledWith({ classeId });
+  });
+});
+
+describe("updateClasse", () => {
+  let mockClasse: any;
+  let mockCohort: any;
+  let mockSession: any;
+  let mockCohesionCenter: any;
+  let mockPDR: any;
+  let mockUpdateYoungsCohorts: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockClasse = {
+      _id: "mockClasseId",
+      status: STATUS_CLASSE.VERIFIED,
+      set: jest.fn(),
+      save: jest.fn(),
+      cohortId: "oldCohortId",
+    };
+
+    mockUpdateYoungsCohorts = jest.spyOn(classeImportService, "updateYoungsCohorts").mockResolvedValue();
+
+    mockCohort = { _id: "newCohortId", name: "New Cohort" };
+    mockSession = { _id: "mockSessionId" };
+    mockCohesionCenter = { _id: "mockCohesionCenterId" };
+    mockPDR = { _id: "mockPdrId" };
+
+    ClasseModel.findById = jest.fn().mockResolvedValue(mockClasse);
+    (findCohortBySnuIdOrThrow as jest.Mock).mockResolvedValue(mockCohort);
+    SessionPhase1Model.findOne = jest.fn().mockResolvedValue(mockSession);
+    CohesionCenterModel.findOne = jest.fn().mockResolvedValue(mockCohesionCenter);
+    PointDeRassemblementModel.findOne = jest.fn().mockResolvedValue(mockPDR);
+  });
+
+  it("should throw an error if no classeId is provided", async () => {
+    const classeToUpdateMapped = {} as ClasseMapped;
+
+    await expect(updateClasse(classeToUpdateMapped)).rejects.toThrow(FUNCTIONAL_ERRORS.NO_CLASSE_ID_PROVIDED);
+  });
+
+  it("should throw an error if classe is not found", async () => {
+    ClasseModel.findById = jest.fn().mockResolvedValue(null);
+
+    const classeToUpdateMapped = { classeId: "invalidClasseId" } as ClasseMapped;
+
+    await expect(updateClasse(classeToUpdateMapped)).rejects.toThrow(ERRORS.CLASSE_NOT_FOUND);
+  });
+
+  it("should update cohort, status, and fields when all valid fields are provided", async () => {
+    const classeToUpdateMapped: ClasseMapped = {
+      classeId: "mockClasseId",
+      cohortCode: "newCohortCode",
+      classeTotalSeats: 30,
+      sessionCode: "session123",
+      centerCode: "center456",
+      pdrCode: "pdr789",
+    };
+
+    const result: ClasseUpdateFileResult = await updateClasse(classeToUpdateMapped);
+
+    expect(ClasseModel.findById).toHaveBeenCalledWith(classeToUpdateMapped.classeId);
+    expect(findCohortBySnuIdOrThrow).toHaveBeenCalledWith(classeToUpdateMapped.cohortCode);
+    expect(updateYoungsCohorts).toHaveBeenCalledWith(mockClasse._id, mockCohort);
+
+    // Check the fields that should have been updated
+    expect(mockClasse.set).toHaveBeenCalledWith({
+      cohortId: mockCohort._id,
+      cohort: mockCohort.name,
+      totalSeats: classeToUpdateMapped.classeTotalSeats,
+    });
+    expect(mockClasse.set).toHaveBeenCalledWith({
+      status: STATUS_CLASSE.ASSIGNED,
+    });
+    expect(mockClasse.set).toHaveBeenCalledWith({
+      sessionId: mockSession._id,
+    });
+    expect(mockClasse.set).toHaveBeenCalledWith({
+      cohesionCenterId: mockCohesionCenter._id,
+    });
+    expect(mockClasse.set).toHaveBeenCalledWith({
+      pointDeRassemblementId: mockPDR._id,
+      statusPhase1: STATUS_PHASE1_CLASSE.AFFECTED,
+    });
+
+    // Ensure save is called
+    expect(mockClasse.save).toHaveBeenCalledWith({
+      fromUser: expect.objectContaining({
+        firstName: expect.stringContaining("UPDATE_CLASSE_COHORT_"),
+      }),
+    });
+
+    // Check result
+    expect(result.updatedFields).toEqual(
+      expect.arrayContaining(["cohortId", "cohort", "totalSeats", "status", "sessionId", "cohesionCenterId", "pointDeRassemblementId", "statusPhase1"]),
+    );
+    expect(result.error).toEqual([]);
+  });
+
+  it("should add errors if session is not found", async () => {
+    SessionPhase1Model.findOne = jest.fn().mockResolvedValue(null);
+
+    const classeToUpdateMapped: ClasseMapped = {
+      classeId: "mockClasseId",
+      cohortCode: "newCohortCode",
+      classeTotalSeats: 30,
+      sessionCode: "session123",
+      centerCode: "center456",
+    };
+
+    const result = await updateClasse(classeToUpdateMapped);
+
+    expect(result.error).toEqual([ERRORS.SESSION_NOT_FOUND]);
+    expect(result.updatedFields).toEqual(expect.arrayContaining(["cohortId", "cohort", "totalSeats", "status"]));
+  });
+
+  it("should add errors if cohesion center is not found", async () => {
+    CohesionCenterModel.findOne = jest.fn().mockResolvedValue(null);
+
+    const classeToUpdateMapped: ClasseMapped = {
+      classeId: "mockClasseId",
+      cohortCode: "newCohortCode",
+      classeTotalSeats: 30,
+      sessionCode: "session123",
+      centerCode: "center456",
+    };
+
+    const result = await updateClasse(classeToUpdateMapped);
+
+    expect(result.error).toEqual([ERRORS.COHESION_CENTER_NOT_FOUND]);
+    expect(result.updatedFields).toEqual(expect.arrayContaining(["cohortId", "cohort", "totalSeats", "status", "sessionId"]));
+  });
+
+  it("should handle missing PDR and add error if PDR is not found", async () => {
+    PointDeRassemblementModel.findOne = jest.fn().mockResolvedValue(null);
+
+    const classeToUpdateMapped: ClasseMapped = {
+      classeId: "mockClasseId",
+      cohortCode: "newCohortCode",
+      classeTotalSeats: 30,
+      sessionCode: "session123",
+      centerCode: "center456",
+      pdrCode: "pdr789",
+    };
+
+    const result = await updateClasse(classeToUpdateMapped);
+
+    expect(result.error).toEqual([ERRORS.PDR_NOT_FOUND]);
+    expect(result.updatedFields).toEqual(expect.arrayContaining(["cohortId", "cohort", "totalSeats", "status", "sessionId", "cohesionCenterId"]));
+  });
+});
diff --git a/api/src/cle/classe/importAuto/classeImportAutoService.ts b/api/src/cle/classe/importAuto/classeImportAutoService.ts
new file mode 100644
index 0000000000..a42c3a3c4d
--- /dev/null
+++ b/api/src/cle/classe/importAuto/classeImportAutoService.ts
@@ -0,0 +1,131 @@
+import { ClasseFromCSV, ClasseUpdateResult, ClasseMapped, ClasseUpdateFileResult } from "./classeImportAutoType";
+import { mapClassesForUpdate } from "./classeImportAutoMapper";
+import { ClasseModel, CohortDocument, YoungModel, PointDeRassemblementModel, SessionPhase1Model, CohesionCenterModel } from "../../../models";
+import { ERRORS, FUNCTIONAL_ERRORS, STATUS_CLASSE, STATUS_PHASE1_CLASSE } from "snu-lib";
+import { findCohortBySnuIdOrThrow } from "../../../cohort/cohortService";
+import { logger } from "../../../logger";
+
+const timestamp = `${new Date().toISOString()?.replaceAll(":", "-")?.replace(".", "-")}`;
+
+export const updateClasseFromExport = async (classesCohortsToUpdate: ClasseFromCSV[]) => {
+  const classesToUpdateMapped = mapClassesForUpdate(classesCohortsToUpdate);
+
+  const classesToUpdateResult: ClasseUpdateResult[] = [];
+  for (const classeToUpdateMapped of classesToUpdateMapped) {
+    const classeCohortImportResult: ClasseUpdateResult = { ...classeToUpdateMapped };
+    try {
+      const { updatedClasse, updatedFields, error }: ClasseUpdateFileResult = await updateClasse(classeToUpdateMapped);
+      classeCohortImportResult.cohortId = updatedClasse.cohortId;
+      classeCohortImportResult.cohortName = updatedClasse.cohort;
+      classeCohortImportResult.classeStatus = updatedClasse.status;
+      classeCohortImportResult.classeTotalSeats = updatedClasse.totalSeats;
+      classeCohortImportResult.result = "success";
+      classeCohortImportResult.updated = updatedFields.join(", ");
+      classeCohortImportResult.error = error.length ? error.join(", ") : undefined;
+    } catch (error) {
+      logger.warn(error.stack);
+      classeCohortImportResult.result = "error";
+      classeCohortImportResult.error = error.message;
+    } finally {
+      classeCohortImportResult.cohortCode = classeToUpdateMapped.cohortCode;
+      classesToUpdateResult.push(classeCohortImportResult);
+    }
+  }
+  return classesToUpdateResult;
+};
+
+export const updateYoungsCohorts = async (classeId: string, cohort: CohortDocument) => {
+  const youngsCohortToUpdate = await YoungModel.find({ classeId: classeId });
+  for (const young of youngsCohortToUpdate) {
+    const originalCohortId = young.cohortId;
+    const originalCohortName = young.cohort;
+    young.set({
+      cohort: cohort.name,
+      cohortId: cohort._id,
+      originalCohort: originalCohortName,
+      originalCohortId: originalCohortId,
+      cohortChangeReason: `Import SI-SNU`,
+    });
+    young.save({ fromUser: { firstName: `UPDATE_CLASSE_COHORT_${timestamp}` } });
+    logger.info(`classeImportService - updateYoungsCohorts() - Young ${young._id} updated with cohort ${cohort.name} - ${cohort._id}`);
+  }
+};
+
+export const updateClasse = async (classeToUpdateMapped: ClasseMapped): Promise<ClasseUpdateFileResult> => {
+  if (!classeToUpdateMapped.classeId) {
+    throw new Error(FUNCTIONAL_ERRORS.NO_CLASSE_ID_PROVIDED);
+  }
+  const classe = await ClasseModel.findById(classeToUpdateMapped.classeId);
+  if (!classe) {
+    throw new Error(ERRORS.CLASSE_NOT_FOUND);
+  }
+
+  if (!classeToUpdateMapped.cohortCode) {
+    throw new Error(FUNCTIONAL_ERRORS.NO_COHORT_CODE_PROVIDED);
+  }
+  const cohort = await findCohortBySnuIdOrThrow(classeToUpdateMapped.cohortCode);
+  const cohortId = cohort._id;
+
+  let updatedFields: string[] = [];
+  let error: string[] = [];
+
+  classe.set({ cohortId: cohortId, cohort: cohort.name, totalSeats: classeToUpdateMapped.classeTotalSeats });
+  updatedFields.push("cohortId", "cohort", "totalSeats");
+
+  if (classe.status === STATUS_CLASSE.VERIFIED) {
+    classe.set({ status: STATUS_CLASSE.ASSIGNED });
+    updatedFields.push("status");
+  }
+  if (cohortId.toString() !== classe.cohortId) {
+    await updateYoungsCohorts(classe._id, cohort);
+    updatedFields.push("youngsCohorts");
+  }
+
+  try {
+    if (classeToUpdateMapped.sessionCode) {
+      const session = await SessionPhase1Model.findOne({ sejourSnuId: classeToUpdateMapped.sessionCode });
+      if (!session) {
+        error.push(ERRORS.SESSION_NOT_FOUND);
+      } else {
+        classe.set({ sessionId: session._id });
+        updatedFields.push("sessionId");
+
+        // Only search for the cohesion center if there is a sessionCode and session is found
+        if (classeToUpdateMapped.centerCode) {
+          try {
+            const cohesionCenter = await CohesionCenterModel.findOne({ matricule: classeToUpdateMapped.centerCode });
+            if (!cohesionCenter) {
+              error.push(ERRORS.COHESION_CENTER_NOT_FOUND);
+            } else {
+              classe.set({ cohesionCenterId: cohesionCenter._id });
+              updatedFields.push("cohesionCenterId");
+
+              // Only search for the PDR if a cohesion center was found
+              if (classeToUpdateMapped.pdrCode) {
+                try {
+                  const pdr = await PointDeRassemblementModel.findOne({ matricule: classeToUpdateMapped.pdrCode });
+                  if (!pdr) {
+                    error.push(ERRORS.PDR_NOT_FOUND);
+                  } else {
+                    classe.set({ pointDeRassemblementId: pdr._id, statusPhase1: STATUS_PHASE1_CLASSE.AFFECTED });
+                    updatedFields.push("pointDeRassemblementId", "statusPhase1");
+                  }
+                } catch (pdrError) {
+                  error.push(`Error finding PDR: ${pdrError.message}`);
+                }
+              }
+            }
+          } catch (centerError) {
+            error.push(`Error finding cohesion center: ${centerError.message}`);
+          }
+        }
+      }
+    }
+  } catch (sessionError) {
+    error.push(`Error finding session: ${sessionError.message}`);
+  }
+
+  await classe.save({ fromUser: { firstName: `UPDATE_CLASSE_COHORT_${timestamp}` } });
+  logger.info(`classeImportService - Classe ${classe._id} updated`);
+  return { updatedClasse: classe, updatedFields, error };
+};
diff --git a/api/src/cle/classe/importAuto/classeImportAutoType.ts b/api/src/cle/classe/importAuto/classeImportAutoType.ts
new file mode 100644
index 0000000000..e20f264afe
--- /dev/null
+++ b/api/src/cle/classe/importAuto/classeImportAutoType.ts
@@ -0,0 +1,35 @@
+import { STATUS_CLASSE } from "snu-lib";
+import { ClasseDocument } from "../../../models";
+
+export interface ClasseFromCSV {
+  "Session formule": string;
+  "Identifiant de la classe engagée": string;
+  "Effectif de jeunes concernés": number;
+  "Session : Code de la session"?: string;
+  "Désignation du centre"?: string;
+  "Code point de rassemblement initial"?: string;
+}
+
+export interface ClasseMapped {
+  cohortCode?: string;
+  classeId: string;
+  classeTotalSeats?: number;
+  centerCode?: string;
+  pdrCode?: string;
+  sessionCode?: string;
+}
+
+export interface ClasseUpdateResult extends ClasseMapped {
+  classeStatus?: keyof typeof STATUS_CLASSE;
+  cohortId?: string;
+  cohortName?: string;
+  result?: "success" | "error";
+  error?: string;
+  updated?: string;
+}
+
+export type ClasseUpdateFileResult = {
+  updatedClasse: ClasseDocument;
+  updatedFields: string[];
+  error: string[];
+};
diff --git a/api/src/cle/index.ts b/api/src/cle/index.ts
index afdb77be52..17a7b6aa89 100644
--- a/api/src/cle/index.ts
+++ b/api/src/cle/index.ts
@@ -4,6 +4,7 @@ const router = express.Router();
 router.use("/appel-a-projet", require("./appelAProjetCle/appelAProjetController").default);
 router.use("/classe", require("./classe/classeController").default);
 router.use("/classe/import", require("./classe/import/classeImportController").default);
+router.use("/classe/importAuto", require("./classe/importAuto/classeImportAutoController").default);
 router.use("/etablissement", require("./etablissement/etablissementController").default);
 router.use("/referent", require("./referent/referentController").default);
 router.use("/referent-signup", require("./referent/referentSignupController").default);
diff --git a/api/src/services/fileService.ts b/api/src/services/fileService.ts
index dd33c6b5e5..37966c01ca 100644
--- a/api/src/services/fileService.ts
+++ b/api/src/services/fileService.ts
@@ -1,5 +1,7 @@
 import { format } from "@fast-csv/format";
 import { parse, ParserOptionsArgs } from "@fast-csv/parse";
+import { Transform } from "stream";
+import xlsx from "xlsx";
 
 import { ERRORS } from "snu-lib";
 
@@ -13,6 +15,25 @@ export function generateCSVStream(data: any[], headers: null | boolean | string[
   return csvStream;
 }
 
+export function streamToBuffer(stream: Transform): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", (err) => reject(err));
+  });
+}
+
+export function XLSXToCSVBuffer(filePath: string): Buffer {
+  const workbook = xlsx.readFile(filePath);
+  const sheetName = workbook.SheetNames[0];
+  const worksheet = workbook.Sheets[sheetName];
+
+  const csvData = xlsx.utils.sheet_to_csv(worksheet, { FS: "," });
+
+  return Buffer.from(csvData, "utf-8");
+}
+
 export function readCSVBuffer<T>(buffer: Buffer, options: ParserOptionsArgs = { headers: true }): Promise<T[]> {
   return new Promise((resolve, reject) => {
     const content: T[] = [];
diff --git a/package-lock.json b/package-lock.json
index e86fd20b20..a088bddf74 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -900,7 +900,7 @@
         "supertest": "6.3.4",
         "ts-jest": "^29.2.5",
         "typescript": "5.4.5",
-        "xlsx": "~0.18.5"
+        "xlsx": "^0.18.5"
       },
       "engines": {
         "node": "^18.20",
@@ -28100,7 +28100,8 @@
     },
     "node_modules/xlsx": {
       "version": "0.18.5",
-      "license": "Apache-2.0",
+      "resolved": "https://registry.npmjs.org/xlsx/-/xlsx-0.18.5.tgz",
+      "integrity": "sha512-dmg3LCjBPHZnQp5/F/+nnTa+miPJxUXB6vtk42YjBBKayDNagxGEeIdWApkYPOf3Z3pm3k62Knjzp7lMeTEtFQ==",
       "dependencies": {
         "adler-32": "~1.3.0",
         "cfb": "~1.2.1",
diff --git a/packages/lib/src/constants/email.ts b/packages/lib/src/constants/email.ts
index 49f7926df4..10e93b2461 100644
--- a/packages/lib/src/constants/email.ts
+++ b/packages/lib/src/constants/email.ts
@@ -207,6 +207,7 @@ const SENDINBLUE_TEMPLATES = {
     INVITATION_REFERENT_CLASSE_TO_INSCRIPTION_TEMPLATE: "1391",
     INVITATION_REFERENT_CLASSE_TO_CONFIRMATION_TEMPLATE: "1427",
     SUPPRESSION_ANCIEN_REFERENT_CLASSE_TEMPLATE: "",
+    IMPORT_DES_CLASSES: "2324",
   },
 };