diff --git a/docs/specs/safe-bag.rst b/docs/specs/safe-bag.rst
index b4ae80a..5d90ae7 100644
--- a/docs/specs/safe-bag.rst
+++ b/docs/specs/safe-bag.rst
@@ -4,7 +4,7 @@
 Sometimes it may be necessary to export an identity's credentials (i.e., private key and associated
 certificate) from one machine and import them into another. This requires a secure container to
 carry the sensitive information. For this purpose, we define the **SafeBag** format, which contains
-an `NDN certificate <https://named-data.net/doc/NDN-packet-spec/0.3/certificate.html>`__ and the
+an `NDN certificate <https://docs.named-data.net/NDN-packet-spec/0.3/certificate.html>`__ and the
 corresponding private key in encrypted form. The private key is formatted as a DER-encoded
 :rfc:`EncryptedPrivateKeyInfo <5208#section-6>` structure as described in PKCS #8.
 
