diff --git a/Changes b/Changes
index dfbeed5..ced2a3d 100644
--- a/Changes
+++ b/Changes
@@ -1,4 +1,4 @@
-0.25 2017-02-08
+0.25 2017-02-16
         - Updated to Mojolicious 7.20
         - Fixed meta treatment in case analytic and monogr
           are available
@@ -6,6 +6,7 @@
         - Liberated document and text sigle handling to be
           compliant with CoRoLa.
         - Added support for pagebreak annotations.
+        - Renamed "pages" to "srcPages".
 
 0.24 2016-12-21
         - Added --base-sentences and --base-paragraphs options
diff --git a/lib/KorAP/XML/Meta/I5.pm b/lib/KorAP/XML/Meta/I5.pm
index c829eb0..81f8e5f 100644
--- a/lib/KorAP/XML/Meta/I5.pm
+++ b/lib/KorAP/XML/Meta/I5.pm
@@ -296,7 +296,7 @@
     if ($temp = $dom->at('biblStruct biblScope[type=pp]')) {
       $temp = _squish $temp->all_text;
       if ($temp && $temp =~ m/(\d+)\s*-\s*(\d+)/) {
-        $self->{pages} = $1 . '-' . $2;
+        $self->{src_pages} = $1 . '-' . $2;
       };
     };
   };
diff --git a/t/real/goethe-2.t b/t/real/goethe-2.t
index d216651..8b5374e 100644
--- a/t/real/goethe-2.t
+++ b/t/real/goethe-2.t
@@ -44,7 +44,7 @@
 ok(!$meta->{text_domain}, 'Correct Text Domain');
 is($meta->{creation_date}, '18200000', 'Creation Date');
 is($meta->{availability}, 'QAO-NC', 'License');
-is($meta->{pages}, '529-547', 'Pages');
+is($meta->{src_pages}, '529-547', 'Pages');
 ok(!$meta->{file_edition_statement}, 'File Ed Statement');
 ok(!$meta->{bibl_edition_statement}, 'Bibl Ed Statement');
 is($meta->{reference} . "\n", <<'REF', 'Author');
@@ -109,7 +109,7 @@
 ok(!exists $output->{textDomain}, 'Correct Text Type');
 is($output->{creationDate}, '18200000', 'Creation Date');
 is($output->{availability}, 'QAO-NC', 'License');
-is($output->{pages}, '529-547', 'Pages');
+is($output->{srcPages}, '529-547', 'Pages');
 ok(!exists $output->{fileEditionStatement}, 'Correct Text Type');
 ok(!exists $output->{biblEditionStatement}, 'Correct Text Type');
 is($output->{reference} . "\n", <<'REF', 'Author');
diff --git a/t/real/goethe-tagged.t b/t/real/goethe-tagged.t
index 58d30ce..6e0e179 100644
--- a/t/real/goethe-tagged.t
+++ b/t/real/goethe-tagged.t
@@ -45,7 +45,7 @@
 ok(!$meta->{text_domain}, 'Correct Text Domain');
 is($meta->{creation_date}, '18200000', 'Creation Date');
 
-is($meta->{pages}, '529-547', 'Pages');
+is($meta->{src_pages}, '529-547', 'Pages');
 ok(!$meta->{file_edition_statement}, 'File Ed Statement');
 ok(!$meta->{bibl_edition_statement}, 'Bibl Ed Statement');
 is($meta->{reference} . "\n", <<'REF', 'Author');
@@ -109,7 +109,7 @@
 ok(!exists $output->{textColumn}, 'Correct Text Type');
 ok(!exists $output->{textDomain}, 'Correct Text Type');
 is($output->{creationDate}, '18200000', 'Creation Date');
-is($output->{pages}, '529-547', 'Pages');
+is($output->{srcPages}, '529-547', 'Pages');
 ok(!exists $output->{fileEditionStatement}, 'Correct Text Type');
 ok(!exists $output->{biblEditionStatement}, 'Correct Text Type');
 is($output->{reference} . "\n", <<'REF', 'Author');
diff --git a/t/real/goethe.t b/t/real/goethe.t
index 07d4eae..fc13cca 100644
--- a/t/real/goethe.t
+++ b/t/real/goethe.t
@@ -43,7 +43,7 @@
 ok(!$meta->{text_domain}, 'Correct Text Domain');
 is($meta->{creation_date}, '18200000', 'Creation Date');
 is($meta->{availability}, 'QAO-NC', 'License');
-is($meta->{pages}, '529-547', 'Pages');
+is($meta->{src_pages}, '529-547', 'Pages');
 ok(!$meta->{file_edition_statement}, 'File Ed Statement');
 ok(!$meta->{bibl_edition_statement}, 'Bibl Ed Statement');
 is($meta->{reference} . "\n", <<'REF', 'Author');
@@ -108,7 +108,7 @@
 ok(!exists $output->{textDomain}, 'Correct Text Type');
 is($output->{creationDate}, '18200000', 'Creation Date');
 is($output->{availability}, 'QAO-NC', 'License');
-is($output->{pages}, '529-547', 'Pages');
+is($output->{srcPages}, '529-547', 'Pages');
 ok(!exists $output->{fileEditionStatement}, 'Correct Text Type');
 ok(!exists $output->{biblEditionStatement}, 'Correct Text Type');
 is($output->{reference} . "\n", <<'REF', 'Author');
