diff --git a/roulier/carriersv2/__init__.py b/roulier/carriersv2/__init__.py
index 1a84411..3c6afac 100644
--- a/roulier/carriersv2/__init__.py
+++ b/roulier/carriersv2/__init__.py
@@ -1 +1,2 @@
+from .colissimo_fr import transporter
 from .mondialrelay import transporter
diff --git a/roulier/carriersv2/colissimo_fr/__init__.py b/roulier/carriersv2/colissimo_fr/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/roulier/carriersv2/colissimo_fr/schema.py b/roulier/carriersv2/colissimo_fr/schema.py
new file mode 100644
index 0000000..8fe8257
--- /dev/null
+++ b/roulier/carriersv2/colissimo_fr/schema.py
@@ -0,0 +1,665 @@
+# Copyright 2024 Akretion (http://www.akretion.com).
+# @author Florian Mounier <florian.mounier@akretion.com>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+from base64 import b64encode
+from datetime import date, datetime
+from enum import Enum
+from pathlib import Path
+from pydantic import BaseModel, model_validator
+
+from ..helpers import merge
+from ..schema import (
+    LabelInput,
+    Address,
+    LabelOutput,
+    Auth,
+    Service,
+    Parcel,
+    ParcelLabel,
+    Label,
+    Tracking,
+    PackingSlipInput,
+    PackingSlipOutput,
+    PackingSlip,
+    PackingSlipClient,
+    PackingSlipSupportSite,
+    DocumentService,
+    GetDocumentService,
+    GetDocumentInput,
+    GetDocumentsInput,
+    CreateUpdateDocumentService,
+    CreateUpdateDocumentInput,
+    DocumentOutput,
+)
+
+
+class Format(Enum):
+    # Shortcuts
+    PDF = "PDF"
+    ZPL = "ZPL"
+    DPL = "DPL"
+    # Formats
+    ZPL_10x15_203dpi = "ZPL_10x15_203dpi"
+    ZPL_10x15_300dpi = "ZPL_10x15_300dpi"
+    DPL_10x15_203dpi = "DPL_10x15_203dpi"
+    DPL_10x15_300dpi = "DPL_10x15_300dpi"
+    PDF_10x15_300dpi = "PDF_10x15_300dpi"
+    PDF_A4_300dpi = "PDF_A4_300dpi"
+    ZPL_10x10_203dpi = "ZPL_10x10_203dpi"
+    ZPL_10x10_300dpi = "ZPL_10x10_300dpi"
+    DPL_10x10_203dpi = "DPL_10x10_203dpi"
+    DPL_10x10_300dpi = "DPL_10x10_300dpi"
+    PDF_10x10_300dpi = "PDF_10x10_300dpi"
+    ZPL_10x15_203dpi_UL = "ZPL_10x15_203dpi_UL"
+    ZPL_10x15_300dpi_UL = "ZPL_10x15_300dpi_UL"
+    DPL_10x15_203dpi_UL = "DPL_10x15_203dpi_UL"
+    DPL_10x15_300dpi_UL = "DPL_10x15_300dpi_UL"
+    PDF_10x15_300dpi_UL = "PDF_10x15_300dpi_UL"
+    PDF_A4_300dpi_UL = "PDF_A4_300dpi_UL"
+
+    @property
+    def final_value(self):
+        return (
+            {
+                Format.PDF: Format.PDF_10x15_300dpi,
+                Format.ZPL: Format.ZPL_10x15_300dpi,
+                Format.DPL: Format.DPL_10x15_300dpi,
+            }
+            .get(self, self)
+            .value
+        )
+
+
+class ColissimoFrAuth(Auth):
+    login: str | None = None
+    password: str | None = None
+    apiKey: str | None = None
+
+    def params(self):
+        if self.apiKey:
+            return {"apiKey": self.apiKey}
+        return {
+            "contractNumber": self.login,
+            "password": self.password,
+        }
+
+    @model_validator(mode="after")
+    def check_login_pass_or_apikey(self):
+        if self.apiKey:
+            if self.login or self.password:
+                raise ValueError("Only one of login/password or apiKey is allowed")
+        else:
+            if not self.login or not self.password:
+                raise ValueError("Without apiKey, login and password are required")
+
+        return self
+
+
+class ColissimoFrAddress(Address):
+    country: str
+    firstName: str | None = None
+    zip: str
+    city: str
+    street0: str | None = None
+    street1: str
+    street2: str | None = None
+    street3: str | None = None
+    door1: str | None = None
+    door2: str | None = None
+    intercom: str | None = None
+    language: str = "FR"
+    landlinePhone: str | None = None
+    stateOrProvinceCode: str | None = None
+
+    def params(self):
+        return {
+            "companyName": self.company,
+            "lastName": self.name,
+            "firstName": self.firstName,
+            "line0": self.street0,
+            "line1": self.street1,
+            "line2": self.street2,
+            "line3": self.street3,
+            "countryCode": self.country,
+            "city": self.city,
+            "zipCode": self.zip,
+            "phoneNumber": self.landlinePhone,
+            "mobileNumber": self.phone,
+            "doorCode1": self.door1,
+            "doorCode2": self.door2,
+            "intercom": self.intercom,
+            "email": self.email,
+            "language": self.language,
+            "stateOrProvinceCode": self.stateOrProvinceCode,
+        }
+
+
+class ColissimoFrService(Service):
+    labelFormat_x: int = 0
+    labelFormat_y: int = 0
+    labelFormat: Format | None = Format.PDF
+    dematerialized: bool = False
+    returnType: str | None = None
+    printCoDDocument: bool = False
+
+    product: str
+    pickupLocationId: str | None = None
+
+    mailBoxPicking: bool = False
+    mailBoxPickingDate: date | None = None
+    vatCode: int | None = None
+    vatPercentage: int | None = None
+    vatAmount: int | None = None
+    transportationAmount: int | None = None
+    totalAmount: int | None = None
+    commercialName: str | None = None
+    returnTypeChoice: int | None = None
+    reseauPostal: str | None = None
+
+    codeBarForReference: bool | None = None
+    serviceInfo: str | None = None
+    promotionCode: str | None = None
+
+    codSenderAddress: ColissimoFrAddress | None = None
+
+    @model_validator(mode="after")
+    def check_format(self):
+        if self.labelFormat is None:
+            self.labelFormat = Format.PDF
+        return self
+
+    def params(self):
+        return {
+            "outputFormat": {
+                "x": self.labelFormat_x,
+                "y": self.labelFormat_y,
+                "outputPrintingType": self.labelFormat.final_value,
+                "dematerialized": self.dematerialized,
+                "returnType": self.returnType,
+                "printCoDDocument": self.printCoDDocument,
+            },
+            "letter": {
+                "service": {
+                    "productCode": self.product,
+                    "depositDate": self.shippingDate.isoformat(),
+                    "mailBoxPicking": self.mailBoxPicking,
+                    "mailBoxPickingDate": (
+                        self.mailBoxPickingDate.isoformat()
+                        if self.mailBoxPickingDate
+                        else None
+                    ),
+                    "vatCode": self.vatCode,
+                    "vatPercentage": self.vatPercentage,
+                    "vatAmount": self.vatAmount,
+                    "transportationAmount": self.transportationAmount,
+                    "totalAmount": self.totalAmount,
+                    "orderNumber": self.reference1,
+                    "commercialName": self.commercialName,
+                    "returnTypeChoice": self.returnTypeChoice,
+                    "reseauPostal": self.reseauPostal,
+                },
+                "parcel": {
+                    "pickupLocationId": self.pickupLocationId,
+                },
+                "sender": {
+                    "senderParcelRef": self.reference1,
+                },
+                "addressee": {
+                    "addresseeParcelRef": self.reference2,
+                    "codeBarForReference": self.codeBarForReference,
+                    "serviceInfo": self.serviceInfo,
+                    "promotionCode": self.promotionCode,
+                },
+                "codSenderAddress": (
+                    self.codSenderAddress.params() if self.codSenderAddress else None
+                ),
+            },
+        }
+
+
+class ColissimoFrArticle(BaseModel):
+    description: str | None = None
+    quantity: int | None = None
+    weight: float | None = None
+    value: float | None = None
+    hsCode: str | None = None
+    originCountry: str | None = None
+    originCountryLabel: str | None = None
+    currency: str | None = "EUR"
+    artref: str | None = None
+    originalIdent: str | None = None
+    vatAmount: float | None = None
+    customsFees: float | None = None
+
+    def params(self):
+        return {
+            "description": self.description,
+            "quantity": self.quantity,
+            "weight": self.weight,
+            "value": self.value,
+            "hsCode": self.hsCode,
+            "originCountry": self.originCountry,
+            "originCountryLabel": self.originCountryLabel,
+            "currency": self.currency,
+            "artref": self.artref,
+            "originalIdent": self.originalIdent,
+            "vatAmount": self.vatAmount,
+            "customsFees": self.customsFees,
+        }
+
+
+class ColissimoFrOriginal(BaseModel):
+    originalIdent: str | None = None
+    originalInvoiceNumber: str | None = None
+    originalInvoiceDate: str | None = None
+    originalParcelNumber: str | None = None
+
+    def params(self):
+        return {
+            "originalIdent": self.originalIdent,
+            "originalInvoiceNumber": self.originalInvoiceNumber,
+            "originalInvoiceDate": self.originalInvoiceDate,
+            "originalParcelNumber": self.originalParcelNumber,
+        }
+
+
+class ColissimoFrCustoms(BaseModel):
+    includesCustomsDeclarations: bool = False
+    numberOfCopies: int | None = None
+
+    # contents
+    articles: list[ColissimoFrArticle] = []
+    category: int
+    original: list[ColissimoFrOriginal] = []
+    explanations: str | None = None
+
+    importersReference: str | None = None
+    importersContact: str | None = None
+    officeOrigin: str | None = None
+    comments: str | None = None
+    description: str | None = None
+    invoiceNumber: str | None = None
+    licenseNumber: str | None = None
+    certificatNumber: str | None = None
+    importerAddress: ColissimoFrAddress | None = None
+
+    def params(self):
+        return {
+            "includesCustomsDeclarations": True,
+            "numberOfCopies": self.numberOfCopies,
+            "contents": {
+                "article": [article.params() for article in self.articles],
+                "category": {
+                    "value": self.category,
+                },
+                "original": [orig.params() for orig in self.original],
+                "explanations": self.explanations,
+            },
+            "importersReference": self.importersReference,
+            "importersContact": self.importersContact,
+            "officeOrigin": self.officeOrigin,
+            "comments": self.comments,
+            "description": self.description,
+            "invoiceNumber": self.invoiceNumber,
+            "licenseNumber": self.licenseNumber,
+            "certificatNumber": self.certificatNumber,
+            "importerAddress": (
+                self.importerAddress.params() if self.importerAddress else None
+            ),
+        }
+
+
+class ColissimoFrParcel(Parcel):
+    parcelNumber: str | None = None
+    insuranceAmount: int | None = None
+    insuranceValue: int | None = None
+    recommendationLevel: str | None = None
+    nonMachinable: bool = False
+    returnReceipt: bool = False
+    instructions: str | None = None
+    pickupLocationId: str | None = None
+    ftd: bool = False
+    ddp: bool = False
+    disabledDeliveryBlockingCode: str | None = None
+    cod: bool = False
+    codamount: int | None = None
+    codcurrency: str | None = None
+
+    customs: ColissimoFrCustoms | None = None
+
+    length: int | None = None
+    width: int | None = None
+    height: int | None = None
+
+    def params(self):
+        return {
+            "letter": {
+                "parcel": {
+                    "parcelNumber": self.parcelNumber,
+                    "insuranceAmount": self.insuranceAmount,
+                    "insuranceValue": self.insuranceValue,
+                    "recommendationLevel": self.recommendationLevel,
+                    "weight": self.weight,
+                    "nonMachinable": self.nonMachinable,
+                    "returnReceipt": self.returnReceipt,
+                    "instructions": self.instructions,
+                    "pickupLocationId": self.pickupLocationId,  # TODO
+                    "ftd": self.ftd,
+                    "ddp": self.ddp,
+                    "disabledDeliveryBlockingCode": self.disabledDeliveryBlockingCode,
+                    "cod": self.cod,
+                    "codamount": self.codamount,
+                    "codcurrency": self.codcurrency,
+                },
+                "customsDeclarations": self.customs.params() if self.customs else None,
+            },
+            "fields": (
+                {
+                    "field": [
+                        {"key": key.upper(), "value": getattr(self, key)}
+                        for key in ["length", "width", "height"]
+                        if getattr(self, key)
+                    ]
+                }
+                if self.length or self.width or self.height
+                else None
+            ),
+        }
+
+
+class ColissimoFrLabelInput(LabelInput):
+    auth: ColissimoFrAuth
+    service: ColissimoFrService
+    parcels: list[ColissimoFrParcel]
+    to_address: ColissimoFrAddress
+    from_address: ColissimoFrAddress
+
+    def params(self):
+        return merge(
+            self.auth.params(),
+            self.service.params(),
+            self.parcels[0].params(),
+            {
+                "letter": {
+                    "sender": {"address": self.from_address.params()},
+                    "addressee": {"address": self.to_address.params()},
+                }
+            },
+        )
+
+
+class ColissimoFrTracking(Tracking):
+    @classmethod
+    def from_params(cls, result):
+        return cls.model_construct(
+            number=result["parcelNumber"],
+            url=result["pdfUrl"],
+            partner=result["parcelNumberPartner"],
+        )
+
+
+class ColissimoFrLabel(Label):
+    @classmethod
+    def from_params(cls, result, name, format):
+        return cls.model_construct(
+            data=b64encode(result).decode("utf-8"),
+            name=name,
+            type=format,
+        )
+
+
+class ColissimoFrParcelLabel(ParcelLabel):
+    label: ColissimoFrLabel | None = None
+    tracking: ColissimoFrTracking | None = None
+
+    @classmethod
+    def from_params(cls, result, input):
+        return cls.model_construct(
+            id=1,
+            reference=input.parcels[0].reference,
+            label=(
+                ColissimoFrLabel.from_params(
+                    result["<label>"], "label", input.service.labelFormat.value
+                )
+                if "<label>" in result
+                else None
+            ),
+            tracking=ColissimoFrTracking.from_params(
+                result["<jsonInfos>"]["labelV2Response"]
+            ),
+        )
+
+
+class ColissimoFrLabelOutput(LabelOutput):
+    parcels: list[ColissimoFrParcelLabel]
+    annexes: list[ColissimoFrLabel]
+
+    @classmethod
+    def from_params(cls, results, input):
+        return cls.model_construct(
+            parcels=[ColissimoFrParcelLabel.from_params(results, input)],
+            annexes=[
+                ColissimoFrLabel.from_params(
+                    data, annex, input.service.labelFormat.value
+                )
+                for annex, data in results.items()
+                if annex not in ["<label>", "<jsonInfos>"]
+            ],
+        )
+
+
+class ColissimoFrPackingSlipInput(PackingSlipInput):
+    auth: ColissimoFrAuth
+
+    def params(self):
+        params = {
+            **self.auth.params(),
+        }
+        if self.parcels_numbers:
+            params["generateBordereauParcelNumberList"] = {
+                "parcelsNumbers": self.parcels_numbers
+            }
+
+        return params
+
+
+class ColissimoFrPackingSlip(PackingSlip):
+    @classmethod
+    def from_params(cls, result):
+        return cls.model_construct(
+            number=result["bordereauNumber"],
+            published_datetime=(
+                datetime.fromtimestamp(result["publishingDate"] / 1000)
+                if result["publishingDate"]
+                else None
+            ),
+            number_of_parcels=result["numberOfParcels"],
+            client=PackingSlipClient(
+                number=result["clientNumber"],
+                address=result["address"],
+                company=result["company"],
+            ),
+            site_pch=PackingSlipSupportSite(
+                code=result["codeSitePCH"], name=result["nameSitePCH"]
+            ),
+        )
+
+
+class ColissimoFrPackingSlipOutput(PackingSlipOutput):
+    packing_slip: ColissimoFrPackingSlip
+    annexes: list[Label] = []
+
+    @classmethod
+    def from_params(cls, results):
+        return cls.model_construct(
+            packing_slip=ColissimoFrPackingSlip.from_params(
+                results["<jsonInfos>"]["bordereauHeader"]
+            ),
+            annexes=[
+                ColissimoFrLabel.from_params(data, annex.strip("<>"), Format.PDF.value)
+                for annex, data in results.items()
+                if annex not in ["<jsonInfos>"]
+            ],
+        )
+
+
+class Lang(str, Enum):
+    fr_FR = "fr_FR"
+    en_GB = "en_GB"
+    es_ES = "es_ES"
+    de_DE = "de_DE"
+    it_IT = "it_IT"
+
+
+class DocumentType(str, Enum):
+    certificate_of_origin = "CERTIFICATE_OF_ORIGIN"  # Certificat d'origine
+    export_license = "EXPORT_LICENSE"  # Licence d'exportation
+    commercial_invoice = "COMMERCIAL_INVOICE"  # Facture du colis
+    other = "OTHER"  # Autre
+
+
+class ColissimoFrDocumentAuth(ColissimoFrAuth):
+    def params(self):
+        credential = {}
+        if self.apiKey:
+            credential["apiKey"] = self.apiKey
+        else:
+            credential["login"] = self.login
+            credential["password"] = self.password
+
+        return {
+            "credential": credential,
+        }
+
+
+class ColissimoFrDocumentService(DocumentService):
+    language: Lang = Lang.fr_FR
+
+    def params(self):
+        return {
+            "lang": self.language.value,
+            "cab": self.parcel_number,
+        }
+
+
+class ColissimoFrGetDocumentsInput(GetDocumentsInput):
+    auth: ColissimoFrDocumentAuth
+    service: ColissimoFrDocumentService
+
+    def params(self):
+        return {
+            **self.auth.params(),
+            **self.service.params(),
+        }
+
+
+class ColissimoFrGetDocumentService(GetDocumentService, ColissimoFrDocumentService):
+    uuid: str | None = None
+
+    def params(self):
+        return {
+            **super().params(),
+            "path": self.document_id,
+            "uuid": self.uuid,
+        }
+
+
+class ColissimoFrGetDocumentInput(GetDocumentInput):
+    auth: ColissimoFrDocumentAuth
+    service: ColissimoFrGetDocumentService
+
+    def params(self):
+        return {
+            **self.auth.params(),
+            **self.service.params(),
+        }
+
+
+class ColissimoFrCreateUpdateDocumentService(
+    CreateUpdateDocumentService, ColissimoFrDocumentService
+):
+    document_type: DocumentType
+    account_number: str
+    parcel_number: str
+    parcel_number_list: str | None = None
+
+    def params(self):
+        return {
+            **super().params(),
+            "documentType": self.document_type.value,
+            "accountNumber": self.account_number,
+            "parcelNumber": self.parcel_number,
+            "parcelNumberList": self.parcel_number_list,
+            "filename": Path(self.document_path).name,
+        }
+
+
+class ColissimoFrCreateUpdateDocumentInput(CreateUpdateDocumentInput):
+    auth: ColissimoFrDocumentAuth
+    service: ColissimoFrCreateUpdateDocumentService
+
+    def params(self):
+        return {
+            **self.auth.params(),
+            **self.service.params(),
+        }
+
+
+class ColissimoFrDocumentOutput(DocumentOutput):
+    file: str
+
+    @classmethod
+    def from_params(cls, result):
+        return cls.model_construct(
+            file=b64encode(result).decode("utf-8"),
+        )
+
+
+class ColissimoFrDocument(BaseModel):
+    url: str
+    code: str | None = None
+    date: datetime | None = None
+    site_code: str | None = None
+    site_name: str | None = None
+    site_type: str | None = None
+    document_type: str
+    document_path: str | None = None
+    uuid: str | None = None
+    parcel_number: str | None = None
+
+    @classmethod
+    def from_params(cls, result):
+        return cls.model_construct(
+            url=result["url"],
+            code=result["eventCode"],
+            date=datetime.fromisoformat(result["eventDate"]),
+            site_code=result["eventSiteCode"],
+            site_name=result["eventSiteName"],
+            site_type=result["eventSiteType"],
+            document_type=result["documentType"],
+            document_path=result["path"],
+            uuid=result["uuid"],
+            parcel_number=result["cab"],
+        )
+
+
+class ColissimoFrDocumentsOutput(DocumentOutput):
+    documents: list[ColissimoFrDocument]
+
+    @classmethod
+    def from_params(cls, result):
+        return cls.model_construct(
+            documents=[
+                ColissimoFrDocument.from_params(doc) for doc in result["documents"]
+            ],
+        )
+
+
+class ColissimoFrCreateUpdateDocumentOutput(DocumentOutput):
+    document_id: str
+
+    @classmethod
+    def from_params(cls, result):
+        return cls.model_construct(
+            document_id=result["documentId"],
+        )
diff --git a/roulier/carriersv2/colissimo_fr/transporter.py b/roulier/carriersv2/colissimo_fr/transporter.py
new file mode 100644
index 0000000..a90975e
--- /dev/null
+++ b/roulier/carriersv2/colissimo_fr/transporter.py
@@ -0,0 +1,229 @@
+# Copyright 2024 Akretion (http://www.akretion.com).
+# @author Florian Mounier <florian.mounier@akretion.com>
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+import logging
+import base64
+import json
+import requests
+from requests_toolbelt import MultipartDecoder
+from ..api import Transporter, action
+from ...exception import CarrierError
+from .schema import (
+    ColissimoFrLabelInput,
+    ColissimoFrLabelOutput,
+    ColissimoFrPackingSlipInput,
+    ColissimoFrPackingSlipOutput,
+    ColissimoFrGetDocumentsInput,
+    ColissimoFrGetDocumentInput,
+    ColissimoFrCreateUpdateDocumentInput,
+    ColissimoFrDocumentOutput,
+    ColissimoFrDocumentsOutput,
+    ColissimoFrCreateUpdateDocumentOutput,
+)
+
+
+_logger = logging.getLogger(__name__)
+
+
+def int_maybe(value):
+    try:
+        return int(value)
+    except ValueError:
+        return value
+
+
+class ColissimoFr(Transporter):
+    __key__ = "colissimo_fr"
+    __url__ = "https://ws.colissimo.fr/sls-ws/SlsServiceWSRest/2.0"
+    __doc_url__ = "https://ws.colissimo.fr/api-document/rest"
+    __auth_url__ = "https://ws.colissimo.fr/widget-colissimo/rest"
+
+    def _raise_for_status(self, response):
+        try:
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as e:
+            try:
+                json = response.json()
+                if "error" in json:
+                    msg = [{"id": 0, "message": json["error"]}]
+                elif "errors" in json:
+                    msg = [
+                        {
+                            "id": int_maybe(error.get("code", 0)),
+                            "message": error["message"],
+                        }
+                        for error in json["errors"]
+                    ]
+                elif "messages" in json:
+                    msg = [
+                        {
+                            "id": int_maybe(error["id"]),
+                            "message": error["messageContent"],
+                        }
+                        for error in json["messages"]
+                        if error["type"] == "ERROR"
+                    ]
+                elif "errorCode" in json and json["errorCode"] != "000":
+                    msg = [
+                        {
+                            "id": int_maybe(json["errorCode"]),
+                            "message": json["errorLabel"],
+                        }
+                    ]
+                else:
+                    raise
+            except Exception:
+                msg = response.text
+
+            raise CarrierError(response, msg) from e
+
+        return response
+
+    def _raise_for_error_code(self, response):
+        if "errorCode" in response and response["errorCode"] != "000":
+            raise CarrierError(
+                response,
+                [
+                    {
+                        "id": int_maybe(response["errorCode"]),
+                        "message": response["errorLabel"],
+                    }
+                ],
+            )
+
+    def request(self, method, json, url=None):
+        headers = {}
+        if json and "apiKey" in json:
+            json = json.copy()
+            headers["apiKey"] = json.pop("apiKey")
+
+        response = requests.post(
+            f"{url or self.__url__}/{method}", json=json, headers=headers
+        )
+        self._raise_for_status(response)
+        return response
+
+    def doc_request(self, method, json, files=None):
+        kwargs = {}
+        if files:
+            kwargs["headers"] = json.pop("credential")
+            kwargs["data"] = json
+            kwargs["files"] = files
+        else:
+            kwargs["json"] = json
+
+        response = requests.post(f"{self.__doc_url__}/{method}", **kwargs)
+        self._raise_for_status(response)
+        return response
+
+    def validate(self, params):
+        response = self.request("checkGenerateLabel", params)
+        _logger.debug("Validation response: %s", response.text)
+        return response.text
+
+    def _parse_response(self, response):
+        parsed = {}
+        decoder = MultipartDecoder.from_response(response)
+        for part in decoder.parts:
+            content_id = part.headers.get(b"Content-ID", b"").decode("utf-8")
+            content_type = part.headers.get(b"Content-Type", b"").decode("utf-8")
+
+            content = part.content
+
+            # Process each part based on its content type
+            if "application/json" in content_type:
+                parsed[content_id] = json.loads(content.decode("utf-8"))
+            elif (
+                "application/pdf" in content_type
+                or "application/octet-stream" in content_type
+            ):
+                parsed[content_id] = content
+            else:
+                _logger.warning(
+                    "Unknown content type: %s for id : %s", content_type, content_id
+                )
+        return parsed
+
+    @action
+    def get_label(self, input: ColissimoFrLabelInput) -> ColissimoFrLabelOutput:
+        params = input.params()
+        self.validate(params)
+        response = self.request("generateLabel", params)
+
+        result = self._parse_response(response)
+        return ColissimoFrLabelOutput.from_params(result, input)
+
+    @action
+    def get_packing_slip(
+        self, input: ColissimoFrPackingSlipInput
+    ) -> ColissimoFrPackingSlipOutput:
+
+        params = input.params()
+
+        if input.packing_slip_number:
+            raise NotImplementedError(
+                "Fetching packing slip by number does not seem to "
+                "be supported by the REST API"
+            )
+            # Getting the auth token
+            params["login"] = params.pop("contractNumber")
+            response = self.request("authenticate.rest", params, url=self.__auth_url__)
+            self._raise_for_status(response)
+            response = response.json()
+            headers = {"token": response["token"]}
+            # partnerClientCode
+            response = requests.get(
+                f"{self.__url__}/SlsInternalService/getBordereauByNumber/{input.packing_slip_number}",
+                headers=headers,
+            )
+            self._raise_for_status(response)
+            result = self._parse_response(response)
+        else:
+            response = self.request("generateBordereauByParcelsNumbers", params)
+            result = self._parse_response(response)
+
+        return ColissimoFrPackingSlipOutput.from_params(result)
+
+    @action
+    def get_documents(
+        self, input: ColissimoFrGetDocumentsInput
+    ) -> ColissimoFrDocumentsOutput:
+        params = input.params()
+        response = self.doc_request("documents", params)
+        result = response.json()
+        self._raise_for_error_code(result)
+        return ColissimoFrDocumentsOutput.from_params(result)
+
+    @action
+    def get_document(
+        self, input: ColissimoFrGetDocumentInput
+    ) -> ColissimoFrDocumentOutput:
+        params = input.params()
+        response = self.doc_request("document", params)
+        return ColissimoFrDocumentOutput.from_params(response.content)
+
+    @action
+    def create_document(
+        self, input: ColissimoFrCreateUpdateDocumentInput
+    ) -> ColissimoFrCreateUpdateDocumentOutput:
+        params = input.params()
+
+        with open(input.service.document_path, "rb") as file:
+            files = {"file": (params["filename"], file.read())}
+
+        response = self.doc_request("storedocument", params, files)
+        result = response.json()
+        return ColissimoFrCreateUpdateDocumentOutput.from_params(result)
+
+    @action
+    def update_document(
+        self, input: ColissimoFrCreateUpdateDocumentInput
+    ) -> ColissimoFrCreateUpdateDocumentOutput:
+        params = input.params()
+
+        with open(input.service.document_path, "rb") as file:
+            files = {"file": (params["filename"], file.read())}
+
+        response = self.doc_request("updatedocument", params, files)
+        result = response.json()
+        return ColissimoFrCreateUpdateDocumentOutput.from_params(result)
diff --git a/roulier/carriersv2/schema.py b/roulier/carriersv2/schema.py
index beef5ae..a26d8c4 100644
--- a/roulier/carriersv2/schema.py
+++ b/roulier/carriersv2/schema.py
@@ -1,8 +1,8 @@
 # Copyright 2024 Akretion (http://www.akretion.com).
 # @author Florian Mounier <florian.mounier@akretion.com>
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
-from datetime import date
-from pydantic import BaseModel
+from datetime import date, datetime
+from pydantic import BaseModel, model_validator
 
 
 class Auth(BaseModel):
@@ -107,3 +107,79 @@ class PickupSite(BaseModel):
 
 class PickupSiteOutput(BaseModel):
     sites: list[PickupSite]
+
+
+class PackingSlipInput(BaseModel):
+    auth: Auth
+    packing_slip_number: str | None = None
+    parcels_numbers: list[str] | None = None
+
+    @model_validator(mode="after")
+    def check_only_one_parameter(self):
+        if not self.packing_slip_number and not self.parcels_numbers:
+            raise ValueError(
+                "At least one of packing_slip_number or parcels_numbers is required"
+            )
+
+        if self.packing_slip_number and self.parcels_numbers:
+            raise ValueError(
+                "Only one of packing_slip_number or parcels_numbers is allowed"
+            )
+
+        return self
+
+
+class PackingSlipSupportSite(BaseModel):
+    code: int
+    name: str
+
+
+class PackingSlipClient(BaseModel):
+    number: str
+    address: str
+    company: str | None = None
+
+
+class PackingSlip(BaseModel):
+    number: int
+    published_datetime: datetime
+    number_of_parcels: int
+    site_pch: PackingSlipSupportSite
+    client: PackingSlipClient
+
+
+class PackingSlipOutput(BaseModel):
+    packing_slip: PackingSlip
+    annexes: list[Label] = []
+
+
+class DocumentService(BaseModel):
+    parcel_number: str
+
+
+class GetDocumentsInput(BaseModel):
+    auth: Auth
+    service: DocumentService
+
+
+class GetDocumentService(DocumentService):
+    document_id: str
+
+
+class GetDocumentInput(BaseModel):
+    auth: Auth
+    service: GetDocumentService
+
+
+class CreateUpdateDocumentService(DocumentService):
+    document_type: str
+    document_path: str
+
+
+class CreateUpdateDocumentInput(BaseModel):
+    auth: Auth
+    service: CreateUpdateDocumentService
+
+
+class DocumentOutput(BaseModel):
+    pass
diff --git a/setup.py b/setup.py
index 9083957..f44a59d 100755
--- a/setup.py
+++ b/setup.py
@@ -22,6 +22,7 @@
         # v2
         "pydantic",
         "zeep",
+        "requests-toolbelt",
     ],
     extras_requires={
         "dev": ["ptpython", "pytest"],