diff --git a/_templates/meta_refresh.html b/_templates/meta_refresh.html
index b940c76..fde0998 100644
--- a/_templates/meta_refresh.html
+++ b/_templates/meta_refresh.html
@@ -1,5 +1,6 @@
 <!--
-SPDX-FileCopyrightText: © 2020 Open Networking Foundation <support@opennetworking.org>
+SPDX-FileCopyrightText: 2020-2023 Open Networking Foundation (ONF) and the ONF Contributors
+
 SPDX-License-Identifier: Apache-2.0
 --!>
 <html><head>
diff --git a/_templates/versions.html b/_templates/versions.html
index 8ed5e31..85dc1eb 100644
--- a/_templates/versions.html
+++ b/_templates/versions.html
@@ -1,5 +1,5 @@
 <!--
-SPDX-FileCopyrightText: © 2020 Open Networking Foundation <support@opennetworking.org>
+SPDX-FileCopyrightText: 2020-2023 Open Networking Foundation (ONF) and the ONF Contributors
 SPDX-License-Identifier: Apache-2.0
 --!>
 {%- if current_version %}
