diff --git a/swh/graphql/app.py b/swh/graphql/app.py
index b10c7bc..059867e 100644
--- a/swh/graphql/app.py
+++ b/swh/graphql/app.py
@@ -1,19 +1,20 @@
 from ariadne import gql, load_schema_from_path, make_executable_schema
 
 from .resolvers import resolvers, scalars
 
 type_defs = gql(load_schema_from_path("swh/graphql/schema/schema.graphql"))
 
 schema = make_executable_schema(
     type_defs,
     resolvers.query,
     resolvers.origin,
     resolvers.visit,
     resolvers.visitstatus,
     resolvers.snapshot,
     resolvers.branch,
     resolvers.target,
     scalars.datetime_scalar,
     scalars.swhid_scalar,
     scalars.binary_text_scalar,
+    scalars.datetimezone_scalar,
 )
diff --git a/swh/graphql/resolvers/scalars.py b/swh/graphql/resolvers/scalars.py
index 9a1c999..9c0ce57 100644
--- a/swh/graphql/resolvers/scalars.py
+++ b/swh/graphql/resolvers/scalars.py
@@ -1,22 +1,28 @@
 from ariadne import ScalarType
 
 datetime_scalar = ScalarType("DateTime")
 swhid_scalar = ScalarType("SWHId")
 binary_text_scalar = ScalarType("BinaryText")
+datetimezone_scalar = ScalarType("DateTimeZone")
 
 
 @datetime_scalar.serializer
 def serialize_datetime(value):
     # FIXME, consider timezone, use core functions
     return value.timestamp()
 
 
 @swhid_scalar.serializer
 def serialize_swid(value):
     return value.hex()
 
 
 @binary_text_scalar.serializer
 def serialize_binary_text(value):
     # FIXME, consider non utf-8
     return value.decode("utf-8")
+
+
+@datetimezone_scalar.serializer
+def serialize_datetimezone(value):
+    return value.to_datetime().timestamp()
diff --git a/swh/graphql/schema/schema.graphql b/swh/graphql/schema/schema.graphql
index 6b844d9..17fee99 100644
--- a/swh/graphql/schema/schema.graphql
+++ b/swh/graphql/schema/schema.graphql
@@ -1,244 +1,246 @@
 scalar SWHId
 
 scalar DateTime
 
+scalar DateTimeZone
+
 scalar BinaryText
 
 interface Node {
   id: ID!
 }
 
 interface SWHNode {
   id: SWHId!
 }
 
 type PageInfo {
   endCursor: String
   hasNextPage: Boolean!
 }
 
 type OriginConnection {
   edges: [OriginEdge]
   nodes: [Origin]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type OriginEdge {
   cursor: String!
   node: Origin
 }
 
 type Origin implements SWHNode {
   id: SWHId!  # FIXME, this is not swhid
   url: String!
   visits(
     first: Int
     after: String
   ): VisitConnection!
 }
 
 type VisitConnection {
   edges: [VisitEdge]
   nodes: [Visit]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type VisitEdge {
   cursor: String!
   node: Visit
 }
 
 type Visit implements Node {
   id: ID!
   date: DateTime!
   type: String
   status(
     first: Int
     after: String
   ): VisitStatusConnection
   # origin: Origin # FIXME, this can be added later
 }
 
 type VisitStatusConnection {
   edges: [VisitStatusEdge]
   nodes: [VisitStatus]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type VisitStatusEdge {
   cursor: String!
   node: VisitStatus
 }
 
 type VisitStatus implements Node {
   id: ID!
   status: String!
   date: DateTime!
   snapshot: Snapshot
   type: String
 }
 
 # FIXME, add OriginSnapshotConnection
 
 type Snapshot implements SWHNode {
   id: SWHId!
 
   branches(
     first: Int
     after: String
   ): BranchConnection
 
   # releases(
   #   first: Int
   #   after: String
   # ): ReleaseConnection
   # FIXME, add alias type as well
 }
 
 type BranchConnection {
   edges: [BranchConnectionEdge]
   nodes: [Branch]
   pageInfo: PageInfo!
   totalCount: Int
 }
 
 type BranchConnectionEdge {
   cursor: String!
   node: [Branch]
 }
 
 # FIXME, this could be alias or Directory as well
 union BranchTarget = Revision | Release
 
 type Branch implements Node {
   id: ID!
   name: BinaryText
   type: String  # FIXME, change to an enum
   target: BranchTarget
 }
 
 # type RevisionConnection {
 # }
 
 # type RevisionEdge {
 # }
 
 type Person {
   email: BinaryText
   name: BinaryText
   fullname: BinaryText
 }
 
 type Revision implements SWHNode {
   id: SWHId!
   message: BinaryText
   author: Person
   committer: Person
-  date: DateTime
+  date: DateTimeZone
   type: String
   directory: SWHId
 }
 
 # type ReleaseConnection {
 # }
 
 # type ReleasEdge {
 # }
 
 type Release implements SWHNode {
   id: SWHId!
   name: BinaryText
   message: BinaryText
   author: Person
-  date: DateTime
+  date: DateTimeZone
 }
 
 type Directory implements SWHNode {
   id: SWHId!
 }
 
 type Content implements SWHNode {
   id: SWHId!
 }
 
 type Query {
   """
   Get an origin with its url
   """
   # FIXME, find some unique id to help cache
   # maybe base64 encode the URL
   origin(
     url: String!
   ): Origin
 
   """
   Get a list of origins
   matching the given filters
   Can also be used to search for an origin
   """
   # FIMXE, use Input types to make this cleaner
   origins(
     first: Int
     after: String
   ): OriginConnection
 
   """
   Get a visit object with its id
   and/or origin and visit id
   """
   # FIXME, find some unique id to help cache
   visit(
     originUrl: String!
     id: String!
   ): Visit
 
   """
   Get a snapshot with SWHId
   """
   snapshot(
     SWHId: String!
   ): Snapshot
 
   # """
   # Get all the snapshot for the given origin
   # """
   # originSnapshot(
   #   originUrl: String!
   #   first: Int
   #   after: String
   # ): SnapshotConnection
 
   """
   Get the revision with the given swhid
   """
   revision(
     SWHId: String!
   ): Revision
 
   """
   Get the release with the given swhid
   """
   release(
     SWHId: String!
   ): Release
 
   # """
   # Get the directory with the given swhid
   # """
   # directory
 
   # """
   # Get the content with the given swhid
   # """
   # content(
   #   SWHId: String!
   # ): Content
 
   # """
   # Search with the given swhid
   # """
   # searchWithSwhid
 }