diff --git a/src/main/java/org/wikitolearn/wikirating/service/RevisionService.java b/src/main/java/org/wikitolearn/wikirating/service/RevisionService.java
index 1f6c5cb..982cf0e 100644
--- a/src/main/java/org/wikitolearn/wikirating/service/RevisionService.java
+++ b/src/main/java/org/wikitolearn/wikirating/service/RevisionService.java
@@ -1,125 +1,126 @@
 /**
  * 
  */
 package org.wikitolearn.wikirating.service;
 
 import java.util.Date;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 import org.wikitolearn.wikirating.exception.RevisionNotFoundException;
 import org.wikitolearn.wikirating.model.Page;
 import org.wikitolearn.wikirating.model.Revision;
 import org.wikitolearn.wikirating.repository.PageRepository;
 import org.wikitolearn.wikirating.repository.RevisionRepository;
 import org.wikitolearn.wikirating.service.mediawiki.RevisionMediaWikiService;
 
 /**
  * 
  * @author aletundo, valsdav
  *
  */
 @Service
 public class RevisionService {
 	private static final Logger LOG = LoggerFactory.getLogger(RevisionService.class);
 	@Autowired
 	private RevisionMediaWikiService revisionMediaWikiService;
 	@Autowired
 	private RevisionRepository revisionRepository;
 	@Autowired
 	private PageRepository pageRepository;
 
 	/**
 	 * Initialize the revisions for the first time querying the MediaWiki API.
 	 * This method adds the revisions and sets the FIRST_REVISION,
 	 * LAST_REVISION and PREVIOUS_REVISION relationships.
 	 * @param lang the domain language
 	 * @param apiUrl the MediaWiki API url
 	 * @return CompletableFuture
 	 */
 	@Async
 	public CompletableFuture<Boolean> initRevisions(String lang, String apiUrl) {
-		Iterable<Page> pages = pageRepository.findAll();
-		pages.forEach(page -> {
+		Iterable<Page> pages = pageRepository.findAllByLang(lang);
+		for(Page page : pages){
 			List<Revision> revisions = revisionMediaWikiService.getAllRevisionByPageId(apiUrl, page.getPageid());
 			// Set the first and the last revisions for the current page
 			page.setFistRevision(revisions.get(0));
 			page.setLastRevision(revisions.get(revisions.size() - 1));
             ListIterator<Revision> it = revisions.listIterator();
             while(it.hasNext()){
                 Revision rev = it.next();
                 rev.setLangRevId(lang + "_" + rev.getRevid());
                 rev.setLang(lang);
                 if (it.previousIndex() != 0){
                     rev.setPreviousRevision(revisions.get(it.previousIndex()-1));
                 }
             }
 			// Saving all the revisions node and the page node
 			revisionRepository.save(revisions);
 			pageRepository.save(page);
 			LOG.info("Inserted revisions for page {}", page.getLangPageId());
-		});
+		}
+
 		return CompletableFuture.completedFuture(true);
 	}
 
     /**
      * Add a new Revision to the graph
      * @param revid
      * @param lang
      * @param userid
      * @param parentid
      * @param length
      * @param timestamp
      * @return
      */
 	public Revision addRevision(int revid, String lang, int userid, int parentid, int length, Date timestamp){
 		Revision rev = new Revision(revid, lang,userid, parentid, length, timestamp);
 		revisionRepository.save(rev);
 		return rev;
 	}
 	
 	/**
 	 * Delete a revision given its langPageId
 	 * @param langPageId the langPageId of the revision
 	 */
 	public void deleteRevisionsOfPage(String langPageId) throws RevisionNotFoundException{
         Set<Revision> revisions = revisionRepository.findAllRevisionOfPage(langPageId);
         if (revisions.size() == 0){
         	LOG.error("Revisions of page {} not found", langPageId);
         	throw new RevisionNotFoundException("Revisions of page "+langPageId+" not found");
 		}
         revisionRepository.delete(revisions);
     }
 	
 	/**
 	 * Get the requested revision
 	 * @param langRevId the langRevId of the revision
 	 * @return the revision
 	 * @throws RevisionNotFoundException
 	 */
 	public Revision getRevision(String langRevId) throws RevisionNotFoundException{
 		Revision revision = revisionRepository.findByLangRevId(langRevId);
 		if(revision == null){
 			LOG.error("Revision {} not found", langRevId);
 			throw new RevisionNotFoundException();
 		}
 		return revision;
 	}
 	
 	/**
 	 * Update the given revision
 	 * @param revision
 	 * @return the updated revision
 	 */
 	public Revision updateRevision(Revision revision){
 		revisionRepository.save(revision);
 		return revision;
 	}
 }
diff --git a/src/main/java/org/wikitolearn/wikirating/service/mediawiki/RevisionMediaWikiService.java b/src/main/java/org/wikitolearn/wikirating/service/mediawiki/RevisionMediaWikiService.java
index 05d23e7..b4490e5 100644
--- a/src/main/java/org/wikitolearn/wikirating/service/mediawiki/RevisionMediaWikiService.java
+++ b/src/main/java/org/wikitolearn/wikirating/service/mediawiki/RevisionMediaWikiService.java
@@ -1,79 +1,78 @@
 package org.wikitolearn.wikirating.service.mediawiki;
 
 import com.fasterxml.jackson.core.type.TypeReference;
 
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.springframework.stereotype.Service;
 import org.wikidata.wdtk.wikibaseapi.ApiConnection;
 import org.wikitolearn.wikirating.model.Revision;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 /**
  * 
  * @author aletundo, valsdav
  *
  */
 @Service
 public class RevisionMediaWikiService extends MediaWikiService<Revision>{
 	
 	private Map<String, String> parameters;
 
     /**
      * Get all the revisions of a page.
      * @param apiUrl String The MediaWiki API url
      * @return revisions List<Revision> A list that contains all the fetched revisions
      */
 	@Override
     public List<Revision> getAll(String apiUrl){
         ApiConnection connection = mediaWikiApiUtils.getApiConnection(apiUrl);
         InputStream response;
         boolean moreRevs = true;
         JSONArray revsJson = new JSONArray();
         List<JSONArray> toBeConcat = new ArrayList<>();
         List<Revision> revs = new ArrayList<>();
 
         try {
             while(moreRevs){
                 response = mediaWikiApiUtils.sendRequest(connection, "GET", parameters);
                 JSONObject responseJson = mediaWikiApiUtils.streamToJson(response);
-
                 toBeConcat.add(responseJson.getJSONObject("query").getJSONObject("pages").
                         getJSONObject(parameters.get("pageids")).getJSONArray("revisions"));
 
                 if(responseJson.has("continue")){
                     String continueFrom = responseJson.getJSONObject("continue").getString("rvcontinue");
                     parameters.put("rvcontinue", continueFrom);
                 }else{
                     moreRevs = false;
                     revsJson = concatArrays(toBeConcat);
                 }
             }
             revs = mapper.readValue(revsJson.toString(), new TypeReference<List<Revision>>(){});
             return revs;
         } catch (JSONException e){
             LOG.error("An error occurred while a JSONObject or JSONArray. {}", e.getMessage());
         } catch(IOException e){
             LOG.error("An error occurred while converting an InputStream to JSONObject. {}", e.getMessage());
         }
         return revs;
     }
 	
     /**
      * Get all the revisions for a specific page querying MediaWiki API
      * @param apiUrl String The MediaWiki API url
      * @param pageid int The id the page of which getting the revisions
      * @return revisions List<Revision> A list that contains all the fetched revisions
      */
 	public List<Revision> getAllRevisionByPageId(String apiUrl, int pageId) {
 		parameters = mediaWikiApiUtils.getRevisionParams(pageId);
 		return getAll(apiUrl);
 	}
 
 }