diff --git a/CHANGELOG.md b/CHANGELOG.md
index 24ec3670f..ee725cf46 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@
 
 ### Changes
 
+  * [#757](https://github.com/toptal/chewy/pull/757): **(Breaking)** Fix `Chewy::Index.index` & `Chewy::Index.aliases` to correctly report indexes and aliases ([@mpeychich][], [@dalthon][])
   * [#761](https://github.com/toptal/chewy/pull/761): Avoid fetching scope data to check if it is blank ([@dalthon][])
 
 ### Bugs Fixed
diff --git a/lib/chewy/index/actions.rb b/lib/chewy/index/actions.rb
index 4e6e451d3..9183b8927 100644
--- a/lib/chewy/index/actions.rb
+++ b/lib/chewy/index/actions.rb
@@ -182,7 +182,7 @@ def #{method}(*args)
         def reset!(suffix = nil, apply_journal: true, journal: false, **import_options)
           result = if suffix.present?
             start_time = Time.now
-            indexes = self.indexes
+            indexes = self.indexes - [index_name]
             create! suffix, alias: false
 
             general_name = index_name
diff --git a/lib/chewy/index/aliases.rb b/lib/chewy/index/aliases.rb
index 6a8a93b1f..21feebf8d 100644
--- a/lib/chewy/index/aliases.rb
+++ b/lib/chewy/index/aliases.rb
@@ -5,14 +5,25 @@ module Aliases
 
       module ClassMethods
         def indexes
-          client.indices.get_alias(name: index_name).keys
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound
-          []
+          get_args = {index: index_name}
+          get_args[:include_type_name] = true if Runtime.version >= '6.7.0'
+          indexes = empty_if_not_found { client.indices.get(**get_args).keys }
+          indexes += empty_if_not_found { client.indices.get_alias(name: index_name).keys }
+          indexes.compact.uniq
         end
 
         def aliases
-          name = index_name
-          client.indices.get_alias(index: name, name: '*')[name].try(:[], 'aliases').try(:keys) || []
+          empty_if_not_found do
+            client.indices.get_alias(index: index_name, name: '*').values.flat_map do |aliases|
+              aliases['aliases'].keys
+            end
+          end.compact.uniq
+        end
+
+      private
+
+        def empty_if_not_found
+          yield
         rescue Elasticsearch::Transport::Transport::Errors::NotFound
           []
         end
diff --git a/spec/chewy/index/actions_spec.rb b/spec/chewy/index/actions_spec.rb
index 7fbbd822d..d8c50ac12 100644
--- a/spec/chewy/index/actions_spec.rb
+++ b/spec/chewy/index/actions_spec.rb
@@ -3,7 +3,10 @@
 describe Chewy::Index::Actions do
   before { Chewy.massacre }
 
-  before { stub_index :dummies }
+  before do
+    stub_index :dummies
+    stub_index :dummies_suffixed
+  end
 
   describe '.exists?' do
     specify { expect(DummiesIndex.exists?).to eq(false) }
@@ -25,26 +28,40 @@
     end
 
     context do
-      before { DummiesIndex.create '2013' }
+      before do
+        DummiesIndex.create '2013'
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify { expect(DummiesIndex.create('2013')).to eq(false) }
       specify { expect(DummiesIndex.create('2014')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.create '2014' }
+
         specify { expect(DummiesIndex.indexes).to match_array(%w[dummies_2013 dummies_2014]) }
       end
     end
 
     context do
-      before { DummiesIndex.create '2013', alias: false }
+      before do
+        DummiesIndex.create '2013', alias: false
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.exists?).to eq(false) }
+      # Unfortunately, without alias we can't figure out that this dummies_2013 index is related to DummiesIndex
+      # it would be awesome to have the following specs passing
+      # specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
+      # specify { expect(DummiesIndex.exists?).to eq(true) }
     end
   end
 
@@ -53,7 +70,11 @@
     specify { expect(DummiesIndex.create!('2013')['acknowledged']).to eq(true) }
 
     context do
-      before { DummiesIndex.create }
+      before do
+        DummiesIndex.create
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify do
         expect { DummiesIndex.create! }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/already exists.*dummies/)
       end
@@ -61,10 +82,14 @@
     end
 
     context do
-      before { DummiesIndex.create! '2013' }
+      before do
+        DummiesIndex.create! '2013'
+        DummiesSuffixedIndex.create! 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       specify do
         expect { DummiesIndex.create!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::BadRequest).with_message(/already exists.*dummies_2013/)
@@ -73,16 +98,26 @@
 
       context do
         before { DummiesIndex.create! '2014' }
+
         specify { expect(DummiesIndex.indexes).to match_array(%w[dummies_2013 dummies_2014]) }
       end
     end
 
     context do
-      before { DummiesIndex.create! '2013', alias: false }
+      before do
+        DummiesIndex.create! '2013', alias: false
+        DummiesSuffixedIndex.create! 'should_not_appear'
+      end
+
       specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
       specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
       specify { expect(DummiesIndex.aliases).to eq([]) }
       specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.exists?).to eq(false) }
+      # Unfortunately, without alias we can't figure out that this dummies_2013 index is related to DummiesIndex
+      # it would be awesome to have the following specs passing
+      # specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
+      # specify { expect(DummiesIndex.exists?).to eq(true) }
     end
   end
 
@@ -91,27 +126,40 @@
     specify { expect(DummiesIndex.delete('dummies_2013')).to eq(false) }
 
     context do
-      before { DummiesIndex.create }
+      before do
+        DummiesIndex.create
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
     end
 
     context do
-      before { DummiesIndex.create '2013' }
+      before do
+        DummiesIndex.create '2013'
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete('2013')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete('2013') }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
         specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
 
       context do
-        before { DummiesIndex.create '2014' }
+        before do
+          DummiesIndex.create '2014'
+        end
+
         specify { expect(DummiesIndex.delete['acknowledged']).to eq(true) }
 
         context do
@@ -119,6 +167,7 @@
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
 
         context do
@@ -126,6 +175,7 @@
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
       end
     end
@@ -136,27 +186,38 @@
     specify { expect { DummiesIndex.delete!('2013') }.to raise_error(Elasticsearch::Transport::Transport::Errors::NotFound) }
 
     context do
-      before { DummiesIndex.create }
+      before do
+        DummiesIndex.create
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete!['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete! }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
     end
 
     context do
-      before { DummiesIndex.create '2013' }
+      before do
+        DummiesIndex.create '2013'
+        DummiesSuffixedIndex.create 'should_not_appear'
+      end
+
       specify { expect(DummiesIndex.delete!('2013')['acknowledged']).to eq(true) }
 
       context do
         before { DummiesIndex.delete!('2013') }
         specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
         specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
+        specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
       end
 
       context do
         before { DummiesIndex.create '2014' }
+
         specify { expect(DummiesIndex.delete!['acknowledged']).to eq(true) }
 
         context do
@@ -164,6 +225,7 @@
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(false) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
 
         context do
@@ -171,6 +233,7 @@
           specify { expect(Chewy.client.indices.exists(index: 'dummies')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2013')).to eq(true) }
           specify { expect(Chewy.client.indices.exists(index: 'dummies_2014')).to eq(false) }
+          specify { expect(Chewy.client.indices.exists(index: 'dummies_suffixed')).to eq(true) }
         end
       end
     end
@@ -184,19 +247,19 @@
       before { DummiesIndex.purge }
       specify { expect(DummiesIndex).to be_exists }
       specify { expect(DummiesIndex.aliases).to eq([]) }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
 
       context do
         before { DummiesIndex.purge }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge('2013') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       end
     end
@@ -204,20 +267,20 @@
     context do
       before { DummiesIndex.purge('2013') }
       specify { expect(DummiesIndex).to be_exists }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
 
       context do
         before { DummiesIndex.purge }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge('2014') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2014']) }
       end
     end
@@ -231,19 +294,19 @@
       before { DummiesIndex.purge! }
       specify { expect(DummiesIndex).to be_exists }
       specify { expect(DummiesIndex.aliases).to eq([]) }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
 
       context do
         before { DummiesIndex.purge! }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge!('2013') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
       end
     end
@@ -251,20 +314,20 @@
     context do
       before { DummiesIndex.purge!('2013') }
       specify { expect(DummiesIndex).to be_exists }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
       specify { expect(DummiesIndex.indexes).to eq(['dummies_2013']) }
 
       context do
         before { DummiesIndex.purge! }
         specify { expect(DummiesIndex).to be_exists }
         specify { expect(DummiesIndex.aliases).to eq([]) }
-        specify { expect(DummiesIndex.indexes).to eq([]) }
+        specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
       end
 
       context do
         before { DummiesIndex.purge!('2014') }
         specify { expect(DummiesIndex).to be_exists }
-        specify { expect(DummiesIndex.aliases).to eq([]) }
+        specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
         specify { expect(DummiesIndex.indexes).to eq(['dummies_2014']) }
       end
     end
@@ -361,13 +424,13 @@
 
         specify { expect(CitiesIndex.all).to have(1).item }
         specify { expect(CitiesIndex.aliases).to eq([]) }
-        specify { expect(CitiesIndex.indexes).to eq([]) }
+        specify { expect(CitiesIndex.indexes).to eq(['cities']) }
 
         context do
           before { CitiesIndex.reset!('2013') }
 
           specify { expect(CitiesIndex.all).to have(1).item }
-          specify { expect(CitiesIndex.aliases).to eq([]) }
+          specify { expect(CitiesIndex.aliases).to eq(['cities']) }
           specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
         end
 
@@ -376,7 +439,7 @@
 
           specify { expect(CitiesIndex.all).to have(1).item }
           specify { expect(CitiesIndex.aliases).to eq([]) }
-          specify { expect(CitiesIndex.indexes).to eq([]) }
+          specify { expect(CitiesIndex.indexes).to eq(['cities']) }
         end
       end
 
@@ -384,14 +447,14 @@
         before { CitiesIndex.reset!('2013') }
 
         specify { expect(CitiesIndex.all).to have(1).item }
-        specify { expect(CitiesIndex.aliases).to eq([]) }
+        specify { expect(CitiesIndex.aliases).to eq(['cities']) }
         specify { expect(CitiesIndex.indexes).to eq(['cities_2013']) }
 
         context do
           before { CitiesIndex.reset!('2014') }
 
           specify { expect(CitiesIndex.all).to have(1).item }
-          specify { expect(CitiesIndex.aliases).to eq([]) }
+          specify { expect(CitiesIndex.aliases).to eq(['cities']) }
           specify { expect(CitiesIndex.indexes).to eq(['cities_2014']) }
           specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
         end
@@ -401,7 +464,7 @@
 
           specify { expect(CitiesIndex.all).to have(1).item }
           specify { expect(CitiesIndex.aliases).to eq([]) }
-          specify { expect(CitiesIndex.indexes).to eq([]) }
+          specify { expect(CitiesIndex.indexes).to eq(['cities']) }
           specify { expect(Chewy.client.indices.exists(index: 'cities_2013')).to eq(false) }
         end
       end
diff --git a/spec/chewy/index/aliases_spec.rb b/spec/chewy/index/aliases_spec.rb
index 6c654481d..dc29e1189 100644
--- a/spec/chewy/index/aliases_spec.rb
+++ b/spec/chewy/index/aliases_spec.rb
@@ -10,13 +10,13 @@
 
     context do
       before { DummiesIndex.create! }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
     end
 
     context do
       before { DummiesIndex.create! }
       before { Chewy.client.indices.put_alias index: 'dummies', name: 'dummies_2013' }
-      specify { expect(DummiesIndex.indexes).to eq([]) }
+      specify { expect(DummiesIndex.indexes).to eq(['dummies']) }
     end
 
     context do
@@ -43,7 +43,7 @@
 
     context do
       before { DummiesIndex.create! '2013' }
-      specify { expect(DummiesIndex.aliases).to eq([]) }
+      specify { expect(DummiesIndex.aliases).to eq(['dummies']) }
     end
   end
 end