diff --git a/CHANGELOG.md b/CHANGELOG.md
index fed11ecd72..92590cd39b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,7 @@ Versions with only mechanical changes will be omitted from the following list.
 * Fix `duration_round` panic on rounding by `Duration::zero()` (#658)
 * Add optional rkyv support.
 * Add support for microseconds timestamps serde serialization for `NaiveDateTime`.
+* Add support for optional timestamps serde serialization for `NaiveDateTime`.
 
 ## 0.4.19
 
diff --git a/src/naive/datetime/serde.rs b/src/naive/datetime/serde.rs
index 996777a9da..a30d43b552 100644
--- a/src/naive/datetime/serde.rs
+++ b/src/naive/datetime/serde.rs
@@ -170,12 +170,12 @@ pub mod ts_nanoseconds {
     where
         D: de::Deserializer<'de>,
     {
-        d.deserialize_i64(NaiveDateTimeFromNanoSecondsVisitor)
+        d.deserialize_i64(NanoSecondsTimestampVisitor)
     }
 
-    struct NaiveDateTimeFromNanoSecondsVisitor;
+    pub(super) struct NanoSecondsTimestampVisitor;
 
-    impl<'de> de::Visitor<'de> for NaiveDateTimeFromNanoSecondsVisitor {
+    impl<'de> de::Visitor<'de> for NanoSecondsTimestampVisitor {
         type Value = NaiveDateTime;
 
         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -203,6 +203,161 @@ pub mod ts_nanoseconds {
     }
 }
 
+/// Ser/de to/from optional timestamps in nanoseconds
+///
+/// Intended for use with `serde`'s `with` attribute.
+///
+/// # Example:
+///
+/// ```rust
+/// # // We mark this ignored so that we can test on 1.13 (which does not
+/// # // support custom derive), and run tests with --ignored on beta and
+/// # // nightly to actually trigger these.
+/// #
+/// # #[macro_use] extern crate serde_derive;
+/// # #[macro_use] extern crate serde_json;
+/// # extern crate chrono;
+/// # use chrono::naive::{NaiveDate, NaiveDateTime};
+/// use chrono::naive::serde::ts_nanoseconds_option;
+/// #[derive(Deserialize, Serialize)]
+/// struct S {
+///     #[serde(with = "ts_nanoseconds_option")]
+///     time: Option<NaiveDateTime>
+/// }
+///
+/// # fn example() -> Result<S, serde_json::Error> {
+/// let time = Some(NaiveDate::from_ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733));
+/// let my_s = S {
+///     time: time.clone(),
+/// };
+///
+/// let as_string = serde_json::to_string(&my_s)?;
+/// assert_eq!(as_string, r#"{"time":1526522699918355733}"#);
+/// let my_s: S = serde_json::from_str(&as_string)?;
+/// assert_eq!(my_s.time, time);
+/// # Ok(my_s)
+/// # }
+/// # fn main() { example().unwrap(); }
+/// ```
+pub mod ts_nanoseconds_option {
+    use core::fmt;
+    use serde::{de, ser};
+
+    use super::ts_nanoseconds::NanoSecondsTimestampVisitor;
+    use crate::NaiveDateTime;
+
+    /// Serialize a datetime into an integer number of nanoseconds since the epoch or none
+    ///
+    /// Intended for use with `serde`s `serialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_nanoseconds_option::serialize as to_nano_tsopt;
+    /// #[derive(Serialize)]
+    /// struct S {
+    ///     #[serde(serialize_with = "to_nano_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<String, serde_json::Error> {
+    /// let my_s = S {
+    ///     time: Some(NaiveDate::from_ymd(2018, 5, 17).and_hms_nano(02, 04, 59, 918355733)),
+    /// };
+    /// let as_string = serde_json::to_string(&my_s)?;
+    /// assert_eq!(as_string, r#"{"time":1526522699918355733}"#);
+    /// # Ok(as_string)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn serialize<S>(opt: &Option<NaiveDateTime>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        match *opt {
+            Some(ref dt) => serializer.serialize_some(&dt.timestamp_nanos()),
+            None => serializer.serialize_none(),
+        }
+    }
+
+    /// Deserialize a `NaiveDateTime` from a nanosecond timestamp or none
+    ///
+    /// Intended for use with `serde`s `deserialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_nanoseconds_option::deserialize as from_nano_tsopt;
+    /// #[derive(Deserialize)]
+    /// struct S {
+    ///     #[serde(deserialize_with = "from_nano_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<S, serde_json::Error> {
+    /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355733 }"#)?;
+    /// # Ok(my_s)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn deserialize<'de, D>(d: D) -> Result<Option<NaiveDateTime>, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        d.deserialize_option(OptionNanoSecondsTimestampVisitor)
+    }
+
+    struct OptionNanoSecondsTimestampVisitor;
+
+    impl<'de> de::Visitor<'de> for OptionNanoSecondsTimestampVisitor {
+        type Value = Option<NaiveDateTime>;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a unix timestamp in nanoseconds or none")
+        }
+
+        /// Deserialize a timestamp in nanoseconds since the epoch
+        fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            d.deserialize_i64(NanoSecondsTimestampVisitor).map(Some)
+        }
+
+        /// Deserialize a timestamp in nanoseconds since the epoch
+        fn visit_none<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+
+        /// Deserialize a timestamp in nanoseconds since the epoch
+        fn visit_unit<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+    }
+}
+
 /// Used to serialize/deserialize from microsecond-precision timestamps
 ///
 /// # Example:
@@ -320,12 +475,12 @@ pub mod ts_microseconds {
     where
         D: de::Deserializer<'de>,
     {
-        d.deserialize_i64(NaiveDateTimeFromMicroSecondsVisitor)
+        d.deserialize_i64(MicroSecondsTimestampVisitor)
     }
 
-    struct NaiveDateTimeFromMicroSecondsVisitor;
+    pub(super) struct MicroSecondsTimestampVisitor;
 
-    impl<'de> de::Visitor<'de> for NaiveDateTimeFromMicroSecondsVisitor {
+    impl<'de> de::Visitor<'de> for MicroSecondsTimestampVisitor {
         type Value = NaiveDateTime;
 
         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -356,6 +511,161 @@ pub mod ts_microseconds {
     }
 }
 
+/// Ser/de to/from optional timestamps in microseconds
+///
+/// Intended for use with `serde`'s `with` attribute.
+///
+/// # Example:
+///
+/// ```rust
+/// # // We mark this ignored so that we can test on 1.13 (which does not
+/// # // support custom derive), and run tests with --ignored on beta and
+/// # // nightly to actually trigger these.
+/// #
+/// # #[macro_use] extern crate serde_derive;
+/// # #[macro_use] extern crate serde_json;
+/// # extern crate chrono;
+/// # use chrono::naive::{NaiveDate, NaiveDateTime};
+/// use chrono::naive::serde::ts_microseconds_option;
+/// #[derive(Deserialize, Serialize)]
+/// struct S {
+///     #[serde(with = "ts_microseconds_option")]
+///     time: Option<NaiveDateTime>
+/// }
+///
+/// # fn example() -> Result<S, serde_json::Error> {
+/// let time = Some(NaiveDate::from_ymd(2018, 5, 17).and_hms_micro(02, 04, 59, 918355));
+/// let my_s = S {
+///     time: time.clone(),
+/// };
+///
+/// let as_string = serde_json::to_string(&my_s)?;
+/// assert_eq!(as_string, r#"{"time":1526522699918355}"#);
+/// let my_s: S = serde_json::from_str(&as_string)?;
+/// assert_eq!(my_s.time, time);
+/// # Ok(my_s)
+/// # }
+/// # fn main() { example().unwrap(); }
+/// ```
+pub mod ts_microseconds_option {
+    use core::fmt;
+    use serde::{de, ser};
+
+    use super::ts_microseconds::MicroSecondsTimestampVisitor;
+    use crate::NaiveDateTime;
+
+    /// Serialize a datetime into an integer number of microseconds since the epoch or none
+    ///
+    /// Intended for use with `serde`s `serialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_microseconds_option::serialize as to_micro_tsopt;
+    /// #[derive(Serialize)]
+    /// struct S {
+    ///     #[serde(serialize_with = "to_micro_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<String, serde_json::Error> {
+    /// let my_s = S {
+    ///     time: Some(NaiveDate::from_ymd(2018, 5, 17).and_hms_micro(02, 04, 59, 918355)),
+    /// };
+    /// let as_string = serde_json::to_string(&my_s)?;
+    /// assert_eq!(as_string, r#"{"time":1526522699918355}"#);
+    /// # Ok(as_string)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn serialize<S>(opt: &Option<NaiveDateTime>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        match *opt {
+            Some(ref dt) => serializer.serialize_some(&dt.timestamp_micros()),
+            None => serializer.serialize_none(),
+        }
+    }
+
+    /// Deserialize a `NaiveDateTime` from a nanosecond timestamp or none
+    ///
+    /// Intended for use with `serde`s `deserialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_microseconds_option::deserialize as from_micro_tsopt;
+    /// #[derive(Deserialize)]
+    /// struct S {
+    ///     #[serde(deserialize_with = "from_micro_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<S, serde_json::Error> {
+    /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355 }"#)?;
+    /// # Ok(my_s)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn deserialize<'de, D>(d: D) -> Result<Option<NaiveDateTime>, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        d.deserialize_option(OptionMicroSecondsTimestampVisitor)
+    }
+
+    struct OptionMicroSecondsTimestampVisitor;
+
+    impl<'de> de::Visitor<'de> for OptionMicroSecondsTimestampVisitor {
+        type Value = Option<NaiveDateTime>;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a unix timestamp in microseconds or none")
+        }
+
+        /// Deserialize a timestamp in microseconds since the epoch
+        fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            d.deserialize_i64(MicroSecondsTimestampVisitor).map(Some)
+        }
+
+        /// Deserialize a timestamp in microseconds since the epoch
+        fn visit_none<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+
+        /// Deserialize a timestamp in microseconds since the epoch
+        fn visit_unit<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+    }
+}
+
 /// Used to serialize/deserialize from millisecond-precision timestamps
 ///
 /// # Example:
@@ -473,12 +783,12 @@ pub mod ts_milliseconds {
     where
         D: de::Deserializer<'de>,
     {
-        d.deserialize_i64(NaiveDateTimeFromMilliSecondsVisitor)
+        d.deserialize_i64(MilliSecondsTimestampVisitor)
     }
 
-    struct NaiveDateTimeFromMilliSecondsVisitor;
+    pub(super) struct MilliSecondsTimestampVisitor;
 
-    impl<'de> de::Visitor<'de> for NaiveDateTimeFromMilliSecondsVisitor {
+    impl<'de> de::Visitor<'de> for MilliSecondsTimestampVisitor {
         type Value = NaiveDateTime;
 
         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -506,6 +816,161 @@ pub mod ts_milliseconds {
     }
 }
 
+/// Ser/de to/from optional timestamps in milliseconds
+///
+/// Intended for use with `serde`'s `with` attribute.
+///
+/// # Example:
+///
+/// ```rust
+/// # // We mark this ignored so that we can test on 1.13 (which does not
+/// # // support custom derive), and run tests with --ignored on beta and
+/// # // nightly to actually trigger these.
+/// #
+/// # #[macro_use] extern crate serde_derive;
+/// # #[macro_use] extern crate serde_json;
+/// # extern crate chrono;
+/// # use chrono::naive::{NaiveDate, NaiveDateTime};
+/// use chrono::naive::serde::ts_milliseconds_option;
+/// #[derive(Deserialize, Serialize)]
+/// struct S {
+///     #[serde(with = "ts_milliseconds_option")]
+///     time: Option<NaiveDateTime>
+/// }
+///
+/// # fn example() -> Result<S, serde_json::Error> {
+/// let time = Some(NaiveDate::from_ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918));
+/// let my_s = S {
+///     time: time.clone(),
+/// };
+///
+/// let as_string = serde_json::to_string(&my_s)?;
+/// assert_eq!(as_string, r#"{"time":1526522699918}"#);
+/// let my_s: S = serde_json::from_str(&as_string)?;
+/// assert_eq!(my_s.time, time);
+/// # Ok(my_s)
+/// # }
+/// # fn main() { example().unwrap(); }
+/// ```
+pub mod ts_milliseconds_option {
+    use core::fmt;
+    use serde::{de, ser};
+
+    use super::ts_milliseconds::MilliSecondsTimestampVisitor;
+    use crate::NaiveDateTime;
+
+    /// Serialize a datetime into an integer number of milliseconds since the epoch or none
+    ///
+    /// Intended for use with `serde`s `serialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_milliseconds_option::serialize as to_milli_tsopt;
+    /// #[derive(Serialize)]
+    /// struct S {
+    ///     #[serde(serialize_with = "to_milli_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<String, serde_json::Error> {
+    /// let my_s = S {
+    ///     time: Some(NaiveDate::from_ymd(2018, 5, 17).and_hms_milli(02, 04, 59, 918)),
+    /// };
+    /// let as_string = serde_json::to_string(&my_s)?;
+    /// assert_eq!(as_string, r#"{"time":1526522699918}"#);
+    /// # Ok(as_string)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn serialize<S>(opt: &Option<NaiveDateTime>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        match *opt {
+            Some(ref dt) => serializer.serialize_some(&dt.timestamp_millis()),
+            None => serializer.serialize_none(),
+        }
+    }
+
+    /// Deserialize a `NaiveDateTime` from a nanosecond timestamp or none
+    ///
+    /// Intended for use with `serde`s `deserialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_milliseconds_option::deserialize as from_milli_tsopt;
+    /// #[derive(Deserialize)]
+    /// struct S {
+    ///     #[serde(deserialize_with = "from_milli_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<S, serde_json::Error> {
+    /// let my_s: S = serde_json::from_str(r#"{ "time": 1526522699918355 }"#)?;
+    /// # Ok(my_s)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn deserialize<'de, D>(d: D) -> Result<Option<NaiveDateTime>, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        d.deserialize_option(OptionMilliSecondsTimestampVisitor)
+    }
+
+    struct OptionMilliSecondsTimestampVisitor;
+
+    impl<'de> de::Visitor<'de> for OptionMilliSecondsTimestampVisitor {
+        type Value = Option<NaiveDateTime>;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a unix timestamp in milliseconds or none")
+        }
+
+        /// Deserialize a timestamp in milliseconds since the epoch
+        fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            d.deserialize_i64(MilliSecondsTimestampVisitor).map(Some)
+        }
+
+        /// Deserialize a timestamp in milliseconds since the epoch
+        fn visit_none<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+
+        /// Deserialize a timestamp in milliseconds since the epoch
+        fn visit_unit<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+    }
+}
+
 /// Used to serialize/deserialize from second-precision timestamps
 ///
 /// # Example:
@@ -623,12 +1088,12 @@ pub mod ts_seconds {
     where
         D: de::Deserializer<'de>,
     {
-        d.deserialize_i64(NaiveDateTimeFromSecondsVisitor)
+        d.deserialize_i64(SecondsTimestampVisitor)
     }
 
-    struct NaiveDateTimeFromSecondsVisitor;
+    pub(super) struct SecondsTimestampVisitor;
 
-    impl<'de> de::Visitor<'de> for NaiveDateTimeFromSecondsVisitor {
+    impl<'de> de::Visitor<'de> for SecondsTimestampVisitor {
         type Value = NaiveDateTime;
 
         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -653,6 +1118,161 @@ pub mod ts_seconds {
     }
 }
 
+/// Ser/de to/from optional timestamps in seconds
+///
+/// Intended for use with `serde`'s `with` attribute.
+///
+/// # Example:
+///
+/// ```rust
+/// # // We mark this ignored so that we can test on 1.13 (which does not
+/// # // support custom derive), and run tests with --ignored on beta and
+/// # // nightly to actually trigger these.
+/// #
+/// # #[macro_use] extern crate serde_derive;
+/// # #[macro_use] extern crate serde_json;
+/// # extern crate chrono;
+/// # use chrono::naive::{NaiveDate, NaiveDateTime};
+/// use chrono::naive::serde::ts_seconds_option;
+/// #[derive(Deserialize, Serialize)]
+/// struct S {
+///     #[serde(with = "ts_seconds_option")]
+///     time: Option<NaiveDateTime>
+/// }
+///
+/// # fn example() -> Result<S, serde_json::Error> {
+/// let time = Some(NaiveDate::from_ymd(2018, 5, 17).and_hms(02, 04, 59));
+/// let my_s = S {
+///     time: time.clone(),
+/// };
+///
+/// let as_string = serde_json::to_string(&my_s)?;
+/// assert_eq!(as_string, r#"{"time":1526522699}"#);
+/// let my_s: S = serde_json::from_str(&as_string)?;
+/// assert_eq!(my_s.time, time);
+/// # Ok(my_s)
+/// # }
+/// # fn main() { example().unwrap(); }
+/// ```
+pub mod ts_seconds_option {
+    use core::fmt;
+    use serde::{de, ser};
+
+    use super::ts_seconds::SecondsTimestampVisitor;
+    use crate::NaiveDateTime;
+
+    /// Serialize a datetime into an integer number of seconds since the epoch or none
+    ///
+    /// Intended for use with `serde`s `serialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_seconds_option::serialize as to_tsopt;
+    /// #[derive(Serialize)]
+    /// struct S {
+    ///     #[serde(serialize_with = "to_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<String, serde_json::Error> {
+    /// let my_s = S {
+    ///     time: Some(NaiveDate::from_ymd(2018, 5, 17).and_hms(02, 04, 59)),
+    /// };
+    /// let as_string = serde_json::to_string(&my_s)?;
+    /// assert_eq!(as_string, r#"{"time":1526522699}"#);
+    /// # Ok(as_string)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn serialize<S>(opt: &Option<NaiveDateTime>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ser::Serializer,
+    {
+        match *opt {
+            Some(ref dt) => serializer.serialize_some(&dt.timestamp()),
+            None => serializer.serialize_none(),
+        }
+    }
+
+    /// Deserialize a `NaiveDateTime` from a second timestamp or none
+    ///
+    /// Intended for use with `serde`s `deserialize_with` attribute.
+    ///
+    /// # Example:
+    ///
+    /// ```rust
+    /// # // We mark this ignored so that we can test on 1.13 (which does not
+    /// # // support custom derive), and run tests with --ignored on beta and
+    /// # // nightly to actually trigger these.
+    /// #
+    /// # #[macro_use] extern crate serde_derive;
+    /// # #[macro_use] extern crate serde_json;
+    /// # extern crate chrono;
+    /// # use chrono::naive::{NaiveDate, NaiveDateTime};
+    /// use chrono::naive::serde::ts_seconds_option::deserialize as from_tsopt;
+    /// #[derive(Deserialize)]
+    /// struct S {
+    ///     #[serde(deserialize_with = "from_tsopt")]
+    ///     time: Option<NaiveDateTime>
+    /// }
+    ///
+    /// # fn example() -> Result<S, serde_json::Error> {
+    /// let my_s: S = serde_json::from_str(r#"{ "time": 1431684000 }"#)?;
+    /// # Ok(my_s)
+    /// # }
+    /// # fn main() { example().unwrap(); }
+    /// ```
+    pub fn deserialize<'de, D>(d: D) -> Result<Option<NaiveDateTime>, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        d.deserialize_option(OptionSecondsTimestampVisitor)
+    }
+
+    struct OptionSecondsTimestampVisitor;
+
+    impl<'de> de::Visitor<'de> for OptionSecondsTimestampVisitor {
+        type Value = Option<NaiveDateTime>;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a unix timestamp in seconds or none")
+        }
+
+        /// Deserialize a timestamp in seconds since the epoch
+        fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
+        where
+            D: de::Deserializer<'de>,
+        {
+            d.deserialize_i64(SecondsTimestampVisitor).map(Some)
+        }
+
+        /// Deserialize a timestamp in seconds since the epoch
+        fn visit_none<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+
+        /// Deserialize a timestamp in seconds since the epoch
+        fn visit_unit<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+    }
+}
+
 #[test]
 fn test_serde_serialize() {
     super::test_encodable_json(serde_json::to_string);