diff --git a/duniterpy/api/bma/blockchain.py b/duniterpy/api/bma/blockchain.py
index 2357755e82e485896480a08930c7500d34908a13..047a254d43237cb7a6ad6c3a0370061fa1131443 100644
--- a/duniterpy/api/bma/blockchain.py
+++ b/duniterpy/api/bma/blockchain.py
@@ -226,7 +226,7 @@ def parameters(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/parameters", schema=PARAMETERS_SCHEMA)
+    return client.get(f"{MODULE}/parameters", schema=PARAMETERS_SCHEMA)
 
 
 def memberships(client: Client, search: str) -> dict:
@@ -237,7 +237,7 @@ def memberships(client: Client, search: str) -> dict:
     :param search: UID/Public key
     :return:
     """
-    return client.get(MODULE + "/memberships/%s" % search, schema=MEMBERSHIPS_SCHEMA)
+    return client.get(f"{MODULE}/memberships/{search}", schema=MEMBERSHIPS_SCHEMA)
 
 
 def membership(client: Client, membership_signed_raw: str) -> HTTPResponse:
@@ -249,7 +249,7 @@ def membership(client: Client, membership_signed_raw: str) -> HTTPResponse:
     :return:
     """
     return client.post(
-        MODULE + "/membership",
+        f"{MODULE}/membership",
         {"membership": membership_signed_raw},
         rtype=RESPONSE_HTTP,
     )
@@ -262,7 +262,7 @@ def current(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/current", schema=BLOCK_SCHEMA)
+    return client.get(f"{MODULE}/current", schema=BLOCK_SCHEMA)
 
 
 def block(
@@ -280,12 +280,12 @@ def block(
     # POST block
     if block_raw is not None and signature is not None:
         return client.post(
-            MODULE + "/block",
+            f"{MODULE}/block",
             {"block": block_raw, "signature": signature},
             rtype=RESPONSE_HTTP,
         )
     # GET block
-    return client.get(MODULE + "/block/%d" % number, schema=BLOCK_SCHEMA)
+    return client.get(f"{MODULE}/block/{number}", schema=BLOCK_SCHEMA)
 
 
 def blocks(client: Client, count: int, start: int) -> list:
@@ -300,7 +300,7 @@ def blocks(client: Client, count: int, start: int) -> list:
     assert type(count) is int
     assert type(start) is int
 
-    return client.get(MODULE + "/blocks/%d/%d" % (count, start), schema=BLOCKS_SCHEMA)
+    return client.get(f"{MODULE}/blocks/{count}/{start}", schema=BLOCKS_SCHEMA)
 
 
 def hardship(client: Client, pubkey: str) -> dict:
@@ -311,7 +311,7 @@ def hardship(client: Client, pubkey: str) -> dict:
     :param pubkey:  Public key of the member
     :return:
     """
-    return client.get(MODULE + "/hardship/%s" % pubkey, schema=HARDSHIP_SCHEMA)
+    return client.get(f"{MODULE}/hardship/{pubkey}", schema=HARDSHIP_SCHEMA)
 
 
 def difficulties(client: Client) -> dict:
@@ -321,7 +321,7 @@ def difficulties(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/difficulties", schema=DIFFICULTIES_SCHEMA)
+    return client.get(f"{MODULE}/difficulties", schema=DIFFICULTIES_SCHEMA)
 
 
 def branches(client: Client) -> list:
@@ -331,7 +331,7 @@ def branches(client: Client) -> list:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/branches", schema=BRANCHES_SCHEMA)
+    return client.get(f"{MODULE}/branches", schema=BRANCHES_SCHEMA)
 
 
 def newcomers(client: Client) -> dict:
@@ -341,7 +341,7 @@ def newcomers(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/newcomers", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/newcomers", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def certifications(client: Client) -> dict:
@@ -351,7 +351,7 @@ def certifications(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/certs", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/certs", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def joiners(client: Client) -> dict:
@@ -361,7 +361,7 @@ def joiners(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/joiners", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/joiners", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def actives(client: Client) -> dict:
@@ -371,7 +371,7 @@ def actives(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/actives", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/actives", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def leavers(client: Client) -> dict:
@@ -381,7 +381,7 @@ def leavers(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/leavers", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/leavers", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def revoked(client: Client) -> dict:
@@ -391,7 +391,7 @@ def revoked(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/revoked", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/revoked", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def excluded(client: Client) -> dict:
@@ -401,7 +401,7 @@ def excluded(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/excluded", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/excluded", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def ud(client: Client) -> dict:
@@ -411,7 +411,7 @@ def ud(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/ud", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/ud", schema=BLOCK_NUMBERS_SCHEMA)
 
 
 def tx(client: Client) -> dict:
@@ -421,4 +421,4 @@ def tx(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/with/tx", schema=BLOCK_NUMBERS_SCHEMA)
+    return client.get(f"{MODULE}/with/tx", schema=BLOCK_NUMBERS_SCHEMA)
diff --git a/duniterpy/api/bma/network.py b/duniterpy/api/bma/network.py
index 581264bb230a7bf6b646c297ad31d3853667b8fb..c6476efafb4d9409d199bdd55718c9e9740c4d0b 100644
--- a/duniterpy/api/bma/network.py
+++ b/duniterpy/api/bma/network.py
@@ -125,7 +125,7 @@ def peers(client: Client) -> dict:
     :return:
     """
 
-    return client.get(MODULE + "/peers", schema=PEERS_SCHEMA)
+    return client.get(f"{MODULE}/peers", schema=PEERS_SCHEMA)
 
 
 def peering(client: Client) -> dict:
@@ -135,7 +135,7 @@ def peering(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/peering", schema=PEERING_SCHEMA)
+    return client.get(f"{MODULE}/peering", schema=PEERING_SCHEMA)
 
 
 def peering_peers(client: Client, leaves: bool = False, leaf: str = "") -> dict:
@@ -149,11 +149,11 @@ def peering_peers(client: Client, leaves: bool = False, leaf: str = "") -> dict:
     """
     if leaves is True:
         response = client.get(
-            MODULE + "/peering/peers", {"leaves": "true"}, schema=PEERING_PEERS_SCHEMA
+            f"{MODULE}/peering/peers", {"leaves": "true"}, schema=PEERING_PEERS_SCHEMA
         )
     else:
         response = client.get(
-            MODULE + "/peering/peers", {"leaf": leaf}, schema=PEERING_PEERS_SCHEMA
+            f"{MODULE}/peering/peers", {"leaf": leaf}, schema=PEERING_PEERS_SCHEMA
         )
     return response
 
@@ -167,7 +167,7 @@ def peer(client: Client, peer_signed_raw: str) -> HTTPResponse:
     :return:
     """
     return client.post(
-        MODULE + "/peering/peers", {"peer": peer_signed_raw}, rtype=RESPONSE_HTTP
+        f"{MODULE}/peering/peers", {"peer": peer_signed_raw}, rtype=RESPONSE_HTTP
     )
 
 
@@ -178,4 +178,4 @@ def ws2p_heads(client: Client) -> dict:
     :param client: Client to connect to the api
     :rtype: dict
     """
-    return client.get(MODULE + "/ws2p/heads", schema=WS2P_HEADS_SCHEMA)
+    return client.get(f"{MODULE}/ws2p/heads", schema=WS2P_HEADS_SCHEMA)
diff --git a/duniterpy/api/bma/node.py b/duniterpy/api/bma/node.py
index 573c3669697e4ba238b66e776a6c18527920ad78..0f0cecbf9fc0ddc2384837a9f0809ab7fa5249bd 100644
--- a/duniterpy/api/bma/node.py
+++ b/duniterpy/api/bma/node.py
@@ -61,7 +61,7 @@ def summary(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/summary", schema=SUMMARY_SCHEMA)
+    return client.get(f"{MODULE}/summary", schema=SUMMARY_SCHEMA)
 
 
 def sandboxes(client: Client) -> dict:
@@ -71,4 +71,4 @@ def sandboxes(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/sandboxes", schema=SANDBOXES_SCHEMA)
+    return client.get(f"{MODULE}/sandboxes", schema=SANDBOXES_SCHEMA)
diff --git a/duniterpy/api/bma/tx.py b/duniterpy/api/bma/tx.py
index 17fe68caa28ff8c5ab29d002134f90ae4133222e..83e539d6d9a7ee04ae3933591350162e4bb37c28 100644
--- a/duniterpy/api/bma/tx.py
+++ b/duniterpy/api/bma/tx.py
@@ -130,7 +130,7 @@ def history(client: Client, pubkey: str) -> dict:
     :param pubkey: Public key
     :return:
     """
-    return client.get(MODULE + "/history/%s" % pubkey, schema=HISTORY_SCHEMA)
+    return client.get(f"{MODULE}/history/{pubkey}", schema=HISTORY_SCHEMA)
 
 
 def process(client: Client, transaction_signed_raw: str) -> HTTPResponse:
@@ -142,7 +142,7 @@ def process(client: Client, transaction_signed_raw: str) -> HTTPResponse:
     :return:
     """
     return client.post(
-        MODULE + "/process",
+        f"{MODULE}/process",
         {"transaction": transaction_signed_raw},
         rtype=RESPONSE_HTTP,
     )
@@ -156,7 +156,7 @@ def sources(client: Client, pubkey: str) -> dict:
     :param pubkey: Public key
     :return:
     """
-    return client.get(MODULE + "/sources/%s" % pubkey, schema=SOURCES_SCHEMA)
+    return client.get(f"{MODULE}/sources/{pubkey}", schema=SOURCES_SCHEMA)
 
 
 def pending(client: Client, pubkey: str) -> dict:
@@ -167,7 +167,7 @@ def pending(client: Client, pubkey: str) -> dict:
     :param pubkey: Public key
     :return:
     """
-    return client.get(MODULE + "/history/%s/pending" % pubkey, schema=HISTORY_SCHEMA)
+    return client.get(f"{MODULE}/history/{pubkey}/pending", schema=HISTORY_SCHEMA)
 
 
 def blocks(client: Client, pubkey: str, start: int, end: int) -> dict:
@@ -181,7 +181,7 @@ def blocks(client: Client, pubkey: str, start: int, end: int) -> dict:
     :return:
     """
     return client.get(
-        MODULE + f"/history/{pubkey}/blocks/{start}/{end}",
+        f"{MODULE}/history/{pubkey}/blocks/{start}/{end}",
         schema=HISTORY_SCHEMA,
     )
 
@@ -197,5 +197,5 @@ def times(client: Client, pubkey: str, start: int, end: int) -> dict:
     :return:
     """
     return client.get(
-        MODULE + f"/history/{pubkey}/times/{start}/{end}", schema=HISTORY_SCHEMA
+        f"{MODULE}/history/{pubkey}/times/{start}/{end}", schema=HISTORY_SCHEMA
     )
diff --git a/duniterpy/api/bma/ud.py b/duniterpy/api/bma/ud.py
index b4cb2e7053f4a9b86a304a39b574295c2ce270cc..1980218aba26579c51dafa3c4afa201acae2357d 100644
--- a/duniterpy/api/bma/ud.py
+++ b/duniterpy/api/bma/ud.py
@@ -57,4 +57,4 @@ def history(client: Client, pubkey: str) -> dict:
     :param pubkey:  Public key of the member
     :return:
     """
-    return client.get(MODULE + "/history/%s" % pubkey, schema=UD_SCHEMA)
+    return client.get(f"{MODULE}/history/{pubkey}", schema=UD_SCHEMA)
diff --git a/duniterpy/api/bma/wot.py b/duniterpy/api/bma/wot.py
index 56c8d2802aff0dc0907b5afdf075937886163982..f43334fbb7322907cf5b7137a82d31179aa92a68 100644
--- a/duniterpy/api/bma/wot.py
+++ b/duniterpy/api/bma/wot.py
@@ -236,7 +236,7 @@ def add(client: Client, identity_signed_raw: str) -> HTTPResponse:
     :return:
     """
     return client.post(
-        MODULE + "/add", {"identity": identity_signed_raw}, rtype=RESPONSE_HTTP
+        f"{MODULE}/add", {"identity": identity_signed_raw}, rtype=RESPONSE_HTTP
     )
 
 
@@ -249,7 +249,7 @@ def certify(client: Client, certification_signed_raw: str) -> HTTPResponse:
     :return:
     """
     return client.post(
-        MODULE + "/certify", {"cert": certification_signed_raw}, rtype=RESPONSE_HTTP
+        f"{MODULE}/certify", {"cert": certification_signed_raw}, rtype=RESPONSE_HTTP
     )
 
 
@@ -262,7 +262,7 @@ def revoke(client: Client, revocation_signed_raw: str) -> HTTPResponse:
     :return:
     """
     return client.post(
-        MODULE + "/revoke",
+        f"{MODULE}/revoke",
         {"revocation": revocation_signed_raw},
         rtype=RESPONSE_HTTP,
     )
@@ -276,7 +276,7 @@ def lookup(client: Client, search: str) -> dict:
     :param search: UID or public key
     :return:
     """
-    return client.get(MODULE + "/lookup/%s" % search, schema=LOOKUP_SCHEMA)
+    return client.get(f"{MODULE}/lookup/{search}", schema=LOOKUP_SCHEMA)
 
 
 def certifiers_of(client: Client, search: str) -> dict:
@@ -287,9 +287,7 @@ def certifiers_of(client: Client, search: str) -> dict:
     :param search: UID or public key
     :return:
     """
-    return client.get(
-        MODULE + "/certifiers-of/%s" % search, schema=CERTIFICATIONS_SCHEMA
-    )
+    return client.get(f"{MODULE}/certifiers-of/{search}", schema=CERTIFICATIONS_SCHEMA)
 
 
 def certified_by(client: Client, search: str) -> dict:
@@ -300,9 +298,7 @@ def certified_by(client: Client, search: str) -> dict:
     :param search: UID or public key
     :return:
     """
-    return client.get(
-        MODULE + "/certified-by/%s" % search, schema=CERTIFICATIONS_SCHEMA
-    )
+    return client.get(f"{MODULE}/certified-by/{search}", schema=CERTIFICATIONS_SCHEMA)
 
 
 def members(client: Client) -> dict:
@@ -312,7 +308,7 @@ def members(client: Client) -> dict:
     :param client: Client to connect to the api
     :return:
     """
-    return client.get(MODULE + "/members", schema=MEMBERS_SCHEMA)
+    return client.get(f"{MODULE}/members", schema=MEMBERS_SCHEMA)
 
 
 def requirements(client: Client, search: str) -> dict:
@@ -323,7 +319,7 @@ def requirements(client: Client, search: str) -> dict:
     :param search: UID or public key
     :return:
     """
-    return client.get(MODULE + "/requirements/%s" % search, schema=REQUIREMENTS_SCHEMA)
+    return client.get(f"{MODULE}/requirements/{search}", schema=REQUIREMENTS_SCHEMA)
 
 
 def requirements_of_pending(client: Client, minsig: int) -> dict:
@@ -335,7 +331,7 @@ def requirements_of_pending(client: Client, minsig: int) -> dict:
     :return:
     """
     return client.get(
-        MODULE + "/requirements-of-pending/%d" % minsig, schema=REQUIREMENTS_SCHEMA
+        f"{MODULE}/requirements-of-pending/{minsig}", schema=REQUIREMENTS_SCHEMA
     )
 
 
@@ -347,4 +343,4 @@ def identity_of(client: Client, search: str) -> dict:
     :param search: UID or public key
     :return:
     """
-    return client.get(MODULE + "/identity-of/%s" % search, schema=IDENTITY_OF_SCHEMA)
+    return client.get(f"{MODULE}/identity-of/{search}", schema=IDENTITY_OF_SCHEMA)
diff --git a/duniterpy/api/bma/ws.py b/duniterpy/api/bma/ws.py
index adbfcc911d5c4754e934a5eb157542dff3c1f21c..54af6dec55b6baa330cc7cf7b7a1ad679857470b 100644
--- a/duniterpy/api/bma/ws.py
+++ b/duniterpy/api/bma/ws.py
@@ -34,7 +34,7 @@ def block(client: Client) -> WSConnection:
     :param client: Client to connect to the api
     :return:
     """
-    return client.connect_ws(MODULE + "/block")
+    return client.connect_ws(f"{MODULE}/block")
 
 
 def peer(client: Client) -> WSConnection:
@@ -44,4 +44,4 @@ def peer(client: Client) -> WSConnection:
     :param client: Client to connect to the api
     :return:
     """
-    return client.connect_ws(MODULE + "/peer")
+    return client.connect_ws(f"{MODULE}/peer")
diff --git a/duniterpy/api/client.py b/duniterpy/api/client.py
index f0264c020101c0b4f80825543972b7d4459c14cd..e0fac12a6d492b14e4e9c34898c3b57624e1c81c 100644
--- a/duniterpy/api/client.py
+++ b/duniterpy/api/client.py
@@ -189,16 +189,9 @@ class API:
 
         address, port = self.connection_handler.address, self.connection_handler.port
         if self.connection_handler.path:
-            url = "{scheme}://{address}:{port}/{api_path}".format(
-                scheme=scheme,
-                address=address,
-                port=port,
-                api_path=self.connection_handler.path,
-            )
+            url = f"{scheme}://{address}:{port}/{self.connection_handler.path}"
         else:
-            url = "{scheme}://{address}:{port}".format(
-                scheme=scheme, address=address, port=port
-            )
+            url = f"{scheme}://{address}:{port}"
 
         if len(path.strip()) > 0:
             return f"{url}/{path}"
@@ -228,7 +221,7 @@ class API:
         :return:
         """
         logging.debug(
-            "Request : %s", self.reverse_url(self.connection_handler.http_scheme, path)
+            "Request: %s", self.reverse_url(self.connection_handler.http_scheme, path)
         )
         url = self.reverse_url(self.connection_handler.http_scheme, path)
         duniter_request = request.Request(url, method=method)
@@ -266,12 +259,10 @@ class API:
                         raise DuniterError(error_data)
                     except (TypeError, jsonschema.ValidationError) as exception:
                         raise ValueError(
-                            "status code != 200 => %d (%s)" % (response.status, content)
+                            f"status code != 200 => {response.status} ({content})"
                         ) from exception
 
-                raise ValueError(
-                    "status code != 200 => %d (%s)" % (response.status, content)
-                )
+                raise ValueError(f"status code != 200 => {response.status} ({content})")
 
             # get response content
             return_response = copy.copy(response)
diff --git a/duniterpy/api/endpoint.py b/duniterpy/api/endpoint.py
index d82977ba36f7e59f80fe39e63e63fce5341cb7c8..02ae356059948a846d0d58edb418a35a55672e08 100644
--- a/duniterpy/api/endpoint.py
+++ b/duniterpy/api/endpoint.py
@@ -52,7 +52,7 @@ class ConnectionHandler:
         self.proxy = proxy
 
     def __str__(self) -> str:
-        return "connection info: %s:%d" % (self.address, self.port)
+        return f"connection info: {self.address}:{self.port}"
 
 
 # required to type hint cls in classmethod
@@ -124,7 +124,8 @@ class UnknownEndpoint(Endpoint):
         return ConnectionHandler("", "", "", 0, "")
 
     def __str__(self) -> str:
-        return "{} {}".format(self.api, " ".join([f"{p}" for p in self.properties]))
+        properties = " ".join([f"{p}" for p in self.properties])
+        return f"{self.api} {properties}"
 
     def __eq__(self, other: Any) -> bool:
         if not isinstance(other, UnknownEndpoint):
@@ -182,12 +183,10 @@ class BMAEndpoint(Endpoint):
 
         :return:
         """
-        return BMAEndpoint.API + "{DNS}{IPv4}{IPv6}{PORT}".format(
-            DNS=(f" {self.host}" if self.host else ""),
-            IPv4=(f" {self.ipv4}" if self.ipv4 else ""),
-            IPv6=(f" {self.ipv6}" if self.ipv6 else ""),
-            PORT=(f" {self.port}" if self.port else ""),
-        )
+        inlined = [
+            str(info) for info in (self.host, self.ipv4, self.ipv6, self.port) if info
+        ]
+        return f'{self.API} {" ".join(inlined)}'
 
     def conn_handler(self, proxy: str = None) -> ConnectionHandler:
         """
@@ -284,7 +283,7 @@ class SecuredBMAEndpoint(BMAEndpoint):
             for info in (self.host, self.ipv4, self.ipv6, self.port, self.path)
             if info
         ]
-        return SecuredBMAEndpoint.API + " " + " ".join(inlined)
+        return f'{self.API} {" ".join(inlined)}'
 
     def conn_handler(self, proxy: str = None) -> ConnectionHandler:
         """
@@ -353,7 +352,7 @@ class WS2PEndpoint(Endpoint):
         inlined = [
             str(info) for info in (self.ws2pid, self.host, self.port, self.path) if info
         ]
-        return WS2PEndpoint.API + " " + " ".join(inlined)
+        return f'{self.API} {" ".join(inlined)}'
 
     def conn_handler(self, proxy: str = None) -> ConnectionHandler:
         """
@@ -424,7 +423,7 @@ class ESCoreEndpoint(Endpoint):
         :return:
         """
         inlined = [str(info) for info in (self.host, self.port) if info]
-        return ESCoreEndpoint.API + " " + " ".join(inlined)
+        return f'{self.API} {" ".join(inlined)}'
 
     def conn_handler(self, proxy: str = None) -> ConnectionHandler:
         """
@@ -483,7 +482,7 @@ class ESUserEndpoint(Endpoint):
         :return:
         """
         inlined = [str(info) for info in (self.host, self.port) if info]
-        return ESUserEndpoint.API + " " + " ".join(inlined)
+        return f'{self.API} {" ".join(inlined)}'
 
     def conn_handler(self, proxy: str = None) -> ConnectionHandler:
         """
@@ -546,7 +545,7 @@ class ESSubscribtionEndpoint(Endpoint):
         :return:
         """
         inlined = [str(info) for info in (self.host, self.port) if info]
-        return ESSubscribtionEndpoint.API + " " + " ".join(inlined)
+        return f'{self.API} {" ".join(inlined)}'
 
     def conn_handler(self, proxy: str = None) -> ConnectionHandler:
         """
@@ -645,7 +644,7 @@ class GVAEndpoint(Endpoint):
             )
             if info
         ]
-        return self.API + " " + " ".join(inlined)
+        return f'{self.API} {" ".join(inlined)}'
 
     def conn_handler(self, proxy: str = None) -> ConnectionHandler:
         """
@@ -722,7 +721,7 @@ def endpoint(value: Any) -> Any:
     elif isinstance(value, str):
         # find Endpoint instance
         for api, cls in MANAGED_API.items():
-            if value.startswith(api + " "):
+            if value.startswith(f"{api} "):
                 result = cls.from_inline(value)
     else:
         raise TypeError(f"Cannot convert {value} to endpoint")
diff --git a/duniterpy/api/errors.py b/duniterpy/api/errors.py
index e1b6dd5d3b1990d58753635ee4de94afe6f7c39b..f5ee16d06b9a5335d13a962ff89d49978894a06c 100644
--- a/duniterpy/api/errors.py
+++ b/duniterpy/api/errors.py
@@ -25,7 +25,7 @@ class DuniterError(Exception):
 
         :param data: Error informations
         """
-        super().__init__("Error code {} - {}".format(data["ucode"], data["message"]))
+        super().__init__(f'Error code {data["ucode"]} - {data["message"]}')
         self.ucode = data["ucode"]
         self.message = data["message"]
 
diff --git a/duniterpy/constants.py b/duniterpy/constants.py
index dc64f472e4a120b07d1797acc449f0cab74dd081..e0f8b022266ab7c1e8bdbc3e6b49c0a3069cd523 100644
--- a/duniterpy/constants.py
+++ b/duniterpy/constants.py
@@ -20,13 +20,9 @@ BLOCK_HASH_REGEX = "[0-9a-fA-F]{5,64}"
 TRANSACTION_HASH_REGEX = "[0-9a-fA-F]{5,64}"
 HASH_REGEX = "[A-F0-9]{64}"
 BLOCK_NUMBER_REGEX = "[0-9]+"
-BLOCK_ID_REGEX = "{block_number_regex}-{block_hash_regex}".format(
-    block_number_regex=BLOCK_NUMBER_REGEX, block_hash_regex=BLOCK_HASH_REGEX
-)
+BLOCK_ID_REGEX = f"{BLOCK_NUMBER_REGEX}-{BLOCK_HASH_REGEX}"
 CONDITIONS_REGEX = (
-    "(&&|\\|\\|| |[()]|(SIG\\({pubkey_regex}\\)|(XHX\\({hash_regex}\\))))*".format(
-        pubkey_regex=PUBKEY_REGEX, hash_regex=HASH_REGEX
-    )
+    f"(&&|\\|\\|| |[()]|(SIG\\({PUBKEY_REGEX}\\)|(XHX\\({HASH_REGEX}\\))))*"
 )
 # https://stackoverflow.com/a/17871737
 IPV4SEG = "(?:25[0-5]|(?:2[0-4]|1?\\d)?\\d)"