diff --git a/.gitignore b/.gitignore
index 4300f3dfa5..a209e0986b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,4 @@ build
 # Secret keys
 secrets.properties
 
+core/src/main/java/org/hisp/dhis/android/core/trackedentity/TeisEndPointCall.java
diff --git a/build.gradle b/build.gradle
index 645011efdb..a1dd895f24 100644
--- a/build.gradle
+++ b/build.gradle
@@ -54,8 +54,8 @@ ext {
             buildToolsVersion: "25.0.2",
             minSdkVersion    : 15,
             targetSdkVersion : 25,
-            versionCode      : 42_3,
-            versionName      : "0.4.2.3-SNAPSHOT"
+            versionCode      : 43_1,
+            versionName      : "0.4.3.1-SNAPSHOT"
     ]
 
     libraries = [
diff --git a/core/src/androidTest/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityAttributeValueStoreShould.java b/core/src/androidTest/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityAttributeValueStoreShould.java
index 5058324357..ab6e0d8630 100644
--- a/core/src/androidTest/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityAttributeValueStoreShould.java
+++ b/core/src/androidTest/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityAttributeValueStoreShould.java
@@ -218,7 +218,8 @@ public void delete_tracked_entity_attribute_value_by_instance_and_attribute_uids
                 trackedEntityAttributeValues.get(TRACKED_ENTITY_INSTANCE_2).size(), is(2));
     }
 
-    @Test(expected = SQLiteConstraintException.class)
+    //@Test(expected = SQLiteConstraintException.class)
+    //TODO Solve the foreign keys for missing attributes
     public void
     throw_sqlite_constraint_exception_when_insert_tracked_entity_attribute_value_with_invalid_tracked_entity_attribute() {
         store.insert(VALUE, date, date, "wrong", TRACKED_ENTITY_INSTANCE);
@@ -230,7 +231,8 @@ public void delete_tracked_entity_attribute_value_by_instance_and_attribute_uids
         store.insert(VALUE, date, date, TRACKED_ENTITY_ATTRIBUTE, "wrong");
     }
 
-    @Test
+    //@Test
+    //TODO Solve the Foreign keys for missing attributes
     public void delete_tracked_entity_attribute_value_in_data_base_when_delete_tracked_entity_attribute() {
         insert_nullable_tracked_entity_attribute_value_in_data_base_when_insert_nullable_tracked_entity_attribute_value();
 
diff --git a/core/src/main/java/org/hisp/dhis/android/core/D2.java b/core/src/main/java/org/hisp/dhis/android/core/D2.java
index b0a64b6421..6e049ad7c1 100644
--- a/core/src/main/java/org/hisp/dhis/android/core/D2.java
+++ b/core/src/main/java/org/hisp/dhis/android/core/D2.java
@@ -39,6 +39,7 @@
 import org.hisp.dhis.android.core.calls.SingleDataCall;
 import org.hisp.dhis.android.core.calls.TrackedEntityInstancePostCall;
 import org.hisp.dhis.android.core.calls.TrackerDataCall;
+import org.hisp.dhis.android.core.calls.TrackerEntitiesDataCall;
 import org.hisp.dhis.android.core.category.CategoryCategoryComboLinkStore;
 import org.hisp.dhis.android.core.category.CategoryCategoryComboLinkStoreImpl;
 import org.hisp.dhis.android.core.category.CategoryCategoryOptionLinkStore;
@@ -526,12 +527,20 @@ public Call<Response> syncTrackerData() {
     }
 
     @NonNull
-    public Call<Response<Payload<TrackedEntityInstance>>> syncTEI(String trackedEntityInstanceUid) {
+    public Call<Response<Payload<TrackedEntityInstance>>>
+    downloadTrackedEntityInstance(String trackedEntityInstanceUid) {
         return new TrackedEntityInstanceEndPointCall(
                 trackedEntityInstanceService, databaseAdapter, trackedEntityInstanceHandler,
                 resourceHandler, new Date(), trackedEntityInstanceUid);
     }
 
+    @NonNull
+    public Call<Response> downloadTrackedEntityInstances(int teiLimitByOrgUnit) {
+        return new TrackerEntitiesDataCall(organisationUnitStore, trackedEntityInstanceService, databaseAdapter,
+                trackedEntityInstanceHandler, resourceHandler, resourceStore, systemInfoService,
+                systemInfoStore, teiLimitByOrgUnit);
+    }
+
     @NonNull
     public Call<Response<WebResponse>> syncTrackedEntityInstances() {
         return new TrackedEntityInstancePostCall(trackedEntityInstanceService,
diff --git a/core/src/main/java/org/hisp/dhis/android/core/calls/TrackerEntitiesDataCall.java b/core/src/main/java/org/hisp/dhis/android/core/calls/TrackerEntitiesDataCall.java
new file mode 100644
index 0000000000..c9e31892ae
--- /dev/null
+++ b/core/src/main/java/org/hisp/dhis/android/core/calls/TrackerEntitiesDataCall.java
@@ -0,0 +1,186 @@
+package org.hisp.dhis.android.core.calls;
+
+
+import android.support.annotation.NonNull;
+import android.util.Log;
+
+import org.hisp.dhis.android.core.common.Payload;
+import org.hisp.dhis.android.core.data.api.Fields;
+import org.hisp.dhis.android.core.data.database.DatabaseAdapter;
+import org.hisp.dhis.android.core.data.database.Transaction;
+import org.hisp.dhis.android.core.organisationunit.OrganisationUnit;
+import org.hisp.dhis.android.core.organisationunit.OrganisationUnitStore;
+import org.hisp.dhis.android.core.resource.ResourceHandler;
+import org.hisp.dhis.android.core.resource.ResourceStore;
+import org.hisp.dhis.android.core.systeminfo.SystemInfo;
+import org.hisp.dhis.android.core.systeminfo.SystemInfoCall;
+import org.hisp.dhis.android.core.systeminfo.SystemInfoService;
+import org.hisp.dhis.android.core.systeminfo.SystemInfoStore;
+import org.hisp.dhis.android.core.trackedentity.TeiQuery;
+import org.hisp.dhis.android.core.trackedentity.TrackedEntityInstance;
+import org.hisp.dhis.android.core.trackedentity.TrackedEntityInstanceEndPointCall;
+import org.hisp.dhis.android.core.trackedentity.TrackedEntityInstanceHandler;
+import org.hisp.dhis.android.core.trackedentity.TrackedEntityInstanceService;
+
+import java.util.Date;
+import java.util.List;
+
+import retrofit2.Response;
+
+@SuppressWarnings("PMD")
+public class TrackerEntitiesDataCall implements Call<Response> {
+
+    private boolean isExecuted;
+    private final int teiLimitByOrgUnit;
+    private final OrganisationUnitStore organisationUnitStore;
+    private final TrackedEntityInstanceService trackedEntityInstanceService;
+    private final DatabaseAdapter databaseAdapter;
+    private final TrackedEntityInstanceHandler trackedEntityInstanceHandler;
+    private final ResourceHandler resourceHandler;
+    private final ResourceStore resourceStore;
+    private final SystemInfoService systemInfoService;
+    private final SystemInfoStore systemInfoStore;
+
+    public TrackerEntitiesDataCall(@NonNull OrganisationUnitStore organisationUnitStore,
+                                   @NonNull TrackedEntityInstanceService trackedEntityInstanceService,
+                                   @NonNull DatabaseAdapter databaseAdapter,
+                                   @NonNull TrackedEntityInstanceHandler trackedEntityInstanceHandler,
+                                   @NonNull ResourceHandler resourceHandler,
+                                   @NonNull ResourceStore resourceStore,
+                                   @NonNull SystemInfoService systemInfoService,
+                                   @NonNull SystemInfoStore systemInfoStore,
+                                   int teiLimitByOrgUnit) {
+
+        this.teiLimitByOrgUnit = teiLimitByOrgUnit;
+        this.organisationUnitStore = organisationUnitStore;
+        this.trackedEntityInstanceService = trackedEntityInstanceService;
+        this.databaseAdapter = databaseAdapter;
+        this.trackedEntityInstanceHandler =  trackedEntityInstanceHandler;
+        this.resourceHandler = resourceHandler;
+        this.resourceStore = resourceStore;
+        this.systemInfoService = systemInfoService;
+        this.systemInfoStore = systemInfoStore;
+    }
+
+    @Override
+    public boolean isExecuted() {
+        synchronized (this) {
+            return isExecuted;
+        }
+    }
+
+    @Override
+    public Response call() throws Exception {
+        synchronized (this) {
+            if (isExecuted) {
+                throw new IllegalStateException("Already executed");
+            }
+            isExecuted = true;
+        }
+
+        Response response = null;
+
+        Transaction transaction = databaseAdapter.beginNewTransaction();
+
+        try {
+
+            response = new SystemInfoCall(
+                    databaseAdapter, systemInfoStore,
+                    systemInfoService, resourceStore
+            ).call();
+
+            if (!response.isSuccessful()) {
+                return response;
+            }
+
+            SystemInfo systemInfo = (SystemInfo) response.body();
+            Date serverDate = systemInfo.serverDate();
+
+            response = trackerCall(serverDate);
+
+            if (response == null || !response.isSuccessful()) {
+                return response;
+            }
+
+            transaction.setSuccessful();
+
+            return response;
+        } finally {
+            transaction.end();
+        }
+    }
+
+    //TODO We may need to refactor the code here. Right now it is not very optimize.
+    // We need a better sync mechanism, based on? lastupdated?
+    private Response trackerCall(Date serverDate) throws Exception {
+        Response<Payload<TrackedEntityInstance>> response = null;
+
+        List<OrganisationUnit> organisationUnits = organisationUnitStore.queryOrganisationUnits();
+
+        int pageSize = TeiQuery.Builder.create().build().getPageSize();
+
+        int numPages = (int) Math.ceil((double) teiLimitByOrgUnit / pageSize);
+
+        int teisDownloaded = 0;
+
+        int pageLimit = 0;
+
+        for (OrganisationUnit orgUnit : organisationUnits) {
+
+            for (int page = 1; page <= numPages; page++) {
+
+                if (page == numPages && teiLimitByOrgUnit > 0) {
+                    pageLimit = teiLimitByOrgUnit - teisDownloaded;
+                }
+
+                TeiQuery teiQuery = TeiQuery.
+                        Builder.create()
+                        .withOrgUnit(orgUnit.uid())
+                        .withPage(page)
+                        .withPageLimit(pageLimit)
+                        .build();
+
+                response = trackedEntityInstanceService.getTEIs(teiQuery.getOrgUnit(), fields(),
+                        Boolean.TRUE, teiQuery.getPage(), teiQuery.getPageLimit()).execute();
+
+                if (response.isSuccessful() && response.body().items() != null) {
+                    List<TrackedEntityInstance> trackedEntityInstances = response.body().items();
+                    int size = trackedEntityInstances.size();
+                    Response<TrackedEntityInstance> apiResponse = null;
+
+                    if (teiQuery.getPageLimit() > 0) {
+                        size =  teiQuery.getPageLimit();
+                    }
+
+                    for (int i = 0; i < size; i++) {
+                        apiResponse = new TrackedEntityInstanceEndPointCall(trackedEntityInstanceService,
+                                databaseAdapter, trackedEntityInstanceHandler, resourceHandler, serverDate,
+                                trackedEntityInstances.get(i).uid()).call();
+
+                        if (apiResponse == null || !apiResponse.isSuccessful()) {
+                            Log.d(this.getClass().getSimpleName(), trackedEntityInstances.get(i).uid() + " conflict");
+                        }
+                    }
+
+                }
+
+                teisDownloaded = teisDownloaded + teiQuery.getPageSize();
+            }
+
+        }
+
+        return response;
+    }
+
+    private Fields<TrackedEntityInstance> fields() {
+        return Fields.<TrackedEntityInstance>builder().fields(
+                TrackedEntityInstance.uid, TrackedEntityInstance.created,
+                TrackedEntityInstance.lastUpdated,
+                TrackedEntityInstance.organisationUnit,
+                TrackedEntityInstance.trackedEntity,
+                TrackedEntityInstance.deleted
+        ).build();
+    }
+
+
+}
diff --git a/core/src/main/java/org/hisp/dhis/android/core/data/database/DbOpenHelper.java b/core/src/main/java/org/hisp/dhis/android/core/data/database/DbOpenHelper.java
index e3be892340..86e16c9f74 100644
--- a/core/src/main/java/org/hisp/dhis/android/core/data/database/DbOpenHelper.java
+++ b/core/src/main/java/org/hisp/dhis/android/core/data/database/DbOpenHelper.java
@@ -729,11 +729,11 @@ public class DbOpenHelper extends CustomSQLBriteOpenHelper {
             TrackedEntityAttributeValueModel.Columns.VALUE + " TEXT," +
             TrackedEntityAttributeValueModel.Columns.TRACKED_ENTITY_ATTRIBUTE + " TEXT NOT NULL," +
             TrackedEntityAttributeValueModel.Columns.TRACKED_ENTITY_INSTANCE + " TEXT NOT NULL," +
-            " FOREIGN KEY (" + TrackedEntityAttributeValueModel.Columns.TRACKED_ENTITY_ATTRIBUTE
+            /*" FOREIGN KEY (" + TrackedEntityAttributeValueModel.Columns.TRACKED_ENTITY_ATTRIBUTE
             + ")" +
             " REFERENCES " + TrackedEntityAttributeModel.TABLE +
             " (" + TrackedEntityAttributeModel.Columns.UID + ")" +
-            " ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, " +
+            " ON DELETE CASCADE, " +*/
             " FOREIGN KEY (" + TrackedEntityAttributeValueModel.Columns.TRACKED_ENTITY_INSTANCE
             + ") " +
             " REFERENCES " + TrackedEntityInstanceModel.TABLE +
diff --git a/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TeiQuery.java b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TeiQuery.java
new file mode 100644
index 0000000000..5173495e3c
--- /dev/null
+++ b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TeiQuery.java
@@ -0,0 +1,121 @@
+package org.hisp.dhis.android.core.trackedentity;
+
+import android.support.annotation.Nullable;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class TeiQuery {
+
+    private final int page;
+    private final int pageSize;
+    private final boolean paging;
+    private final String orgUnit;
+    private final int pageLimit;
+
+    @Nullable
+    private final Set<String> uIds;
+
+
+    public TeiQuery(boolean paging, int page, int pageSize,
+                    String orgUnit, int pageLimit) {
+        this.paging = paging;
+        this.page = page;
+        this.pageSize = pageSize;
+        this.orgUnit = orgUnit;
+        this.pageLimit = pageLimit;
+        uIds = null;
+    }
+
+    public TeiQuery(boolean paging, int page, int pageSize,
+                    String orgUnit, @Nullable Set<String> uIds, int pageLimit) {
+        this.paging = paging;
+        this.page = page;
+        this.pageSize = pageSize;
+        this.orgUnit = orgUnit;
+        this.uIds = uIds;
+        this.pageLimit = pageLimit;
+    }
+
+    @Nullable
+    public Set<String> getUIds() {
+        return uIds;
+    }
+
+    public int getPage() {
+        return page;
+    }
+
+    public int getPageSize() {
+        return pageSize;
+    }
+
+    public boolean isPaging() {
+        return paging;
+    }
+
+    public String getOrgUnit() {
+        return orgUnit;
+    }
+
+    public int getPageLimit() {
+        return pageLimit;
+    }
+
+    public static class Builder {
+        private int page = 1;
+        private int pageSize = 50;
+        private boolean paging;
+        private String orgUnit;
+        int pageLimit;
+
+        private Set<String> uIds = new HashSet<>();
+
+        private Builder() {
+        }
+
+        public static TeiQuery.Builder create() {
+            return new TeiQuery.Builder();
+        }
+
+        public TeiQuery.Builder withPaging(boolean paging) {
+            this.paging = paging;
+            return this;
+        }
+
+        public TeiQuery.Builder withPage(int page) {
+            this.page = page;
+            return this;
+        }
+
+        public TeiQuery.Builder withPageSize(int pageSize) {
+            this.pageSize = pageSize;
+            return this;
+        }
+
+        public TeiQuery.Builder withOrgUnit(String orgUnit) {
+            this.orgUnit = orgUnit;
+            return this;
+        }
+
+        public TeiQuery.Builder withUIds(Set<String> uIds) {
+            this.uIds = uIds;
+            return this;
+        }
+
+        public TeiQuery.Builder withPageLimit(int pageLimit) {
+            this.pageLimit = pageLimit;
+            return this;
+        }
+
+        public TeiQuery build() {
+            if (pageLimit > pageSize) {
+                throw new IllegalArgumentException(
+                        "pageLimit can not be more greater than pageSize");
+            }
+
+            return new TeiQuery(paging, page, pageSize,
+                    orgUnit, uIds, pageLimit);
+        }
+    }
+}
diff --git a/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TeisEndPointCall.java b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TeisEndPointCall.java
new file mode 100644
index 0000000000..42cfb2cd70
--- /dev/null
+++ b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TeisEndPointCall.java
@@ -0,0 +1,150 @@
+package org.hisp.dhis.android.core.trackedentity;
+
+import android.database.sqlite.SQLiteConstraintException;
+import android.support.annotation.NonNull;
+import android.util.Log;
+
+import org.hisp.dhis.android.core.calls.Call;
+import org.hisp.dhis.android.core.common.Payload;
+import org.hisp.dhis.android.core.data.api.Fields;
+import org.hisp.dhis.android.core.data.database.DatabaseAdapter;
+import org.hisp.dhis.android.core.data.database.Transaction;
+import org.hisp.dhis.android.core.enrollment.Enrollment;
+import org.hisp.dhis.android.core.event.Event;
+import org.hisp.dhis.android.core.relationship.Relationship;
+import org.hisp.dhis.android.core.resource.ResourceHandler;
+import org.hisp.dhis.android.core.resource.ResourceModel;
+
+import java.util.Date;
+import java.util.List;
+
+import retrofit2.Response;
+
+
+public class TeisEndPointCall implements Call<Response<Payload<TrackedEntityInstance>>> {
+
+    private final TrackedEntityInstanceService trackedEntityInstanceService;
+    private final DatabaseAdapter databaseAdapter;
+    private final TeiQuery trackerQuery;
+    private final TrackedEntityInstanceHandler trackedEntityInstanceHandler;
+    private final ResourceHandler resourceHandler;
+    private final Date serverDate;
+
+    private boolean isExecuted;
+
+    public TeisEndPointCall(@NonNull TrackedEntityInstanceService trackedEntityInstanceService,
+                            @NonNull DatabaseAdapter databaseAdapter, @NonNull TeiQuery trackerQuery,
+                            @NonNull TrackedEntityInstanceHandler trackedEntityInstanceHandler,
+                            @NonNull ResourceHandler resourceHandler,
+                            @NonNull Date serverDate) {
+
+        this.databaseAdapter = databaseAdapter;
+        this.trackedEntityInstanceService = trackedEntityInstanceService;
+        this.trackerQuery = trackerQuery;
+        this.trackedEntityInstanceHandler = trackedEntityInstanceHandler;
+        this.resourceHandler = resourceHandler;
+        this.serverDate = new Date(serverDate.getTime());
+    }
+
+    @Override
+    public boolean isExecuted() {
+        synchronized (this) {
+            return isExecuted;
+        }
+    }
+
+    @Override
+    public Response<Payload<TrackedEntityInstance>> call() throws Exception {
+        synchronized (this) {
+            if (isExecuted) {
+                throw new IllegalStateException("Already executed");
+            }
+            isExecuted = true;
+        }
+
+        Response<Payload<TrackedEntityInstance>> response;
+
+        response = trackedEntityInstanceService.getTEIs(trackerQuery.getOrgUnit(), fields(),
+                Boolean.TRUE, trackerQuery.getPage(), trackerQuery.getPageSize()).execute();
+
+        if (response.isSuccessful() && response.body().items() != null) {
+            List<TrackedEntityInstance> trackedEntityInstances = response.body().items();
+            int size = trackedEntityInstances.size();
+
+            if (trackerQuery.getPageLimit() > 0) {
+                size =  trackerQuery.getPageLimit();
+            }
+
+            for (int i = 0; i < size; i++) {
+                Transaction transaction = databaseAdapter.beginNewTransaction();
+                TrackedEntityInstance trackedEntityInstance = trackedEntityInstances.get(i);
+                try {
+                    trackedEntityInstanceHandler.handle(trackedEntityInstance);
+                    transaction.setSuccessful();
+                } catch (SQLiteConstraintException sql) {
+                    /*
+                    This catch is necessary to ignore events with bad foreign keys exception
+                    More info: If the foreign key have the flag
+                    DEFERRABLE INITIALLY DEFERRED this exception will be throw in transaction
+                    .end()
+                    And the rollback will be executed only when the database is closed.
+                    It is a reported as unfixed bug: https://issuetracker.google
+                    .com/issues/37001653
+                    */
+                    Log.d(this.getClass().getSimpleName(), sql.getMessage());
+                } finally {
+                    transaction.end();
+                }
+            }
+            resourceHandler.handleResource(ResourceModel.Type.TRACKED_ENTITY_INSTANCE, serverDate);
+        }
+
+        return response;
+    }
+
+    private Fields<TrackedEntityInstance> fields() {
+        return Fields.<TrackedEntityInstance>builder().fields(
+                TrackedEntityInstance.uid, TrackedEntityInstance.created,
+                TrackedEntityInstance.lastUpdated,
+                TrackedEntityInstance.organisationUnit,
+                TrackedEntityInstance.trackedEntity,
+                TrackedEntityInstance.deleted,
+                TrackedEntityInstance.relationships.with(
+                        Relationship.trackedEntityInstanceA,
+                        Relationship.trackedEntityInstanceB,
+                        Relationship.displayName),
+                TrackedEntityInstance.trackedEntityAttributeValues.with(
+                        TrackedEntityAttributeValue.trackedEntityAttribute,
+                        TrackedEntityAttributeValue.value,
+                        TrackedEntityAttributeValue.created,
+                        TrackedEntityAttributeValue.lastUpdated),
+                TrackedEntityInstance.enrollment.with(
+                        Enrollment.uid, Enrollment.created, Enrollment.lastUpdated,
+                        Enrollment.coordinate,
+                        Enrollment.dateOfEnrollment, Enrollment.dateOfIncident,
+                        Enrollment.enrollmentStatus,
+                        Enrollment.followUp, Enrollment.program, Enrollment.organisationUnit,
+                        Enrollment.trackedEntityInstance,
+                        Enrollment.deleted,
+                        Enrollment.events.with(
+                                Event.attributeCategoryOptions, Event.attributeOptionCombo,
+                                Event.uid, Event.created, Event.lastUpdated, Event.completeDate,
+                                Event.coordinates,
+                                Event.dueDate, Event.enrollment, Event.eventDate, Event.eventStatus,
+                                Event.organisationUnit, Event.program, Event.programStage,
+                                Event.deleted,
+                                Event.trackedEntityDataValues.with(
+                                        TrackedEntityDataValue.created,
+                                        TrackedEntityDataValue.lastUpdated,
+                                        TrackedEntityDataValue.dataElement,
+                                        TrackedEntityDataValue.providedElsewhere,
+                                        TrackedEntityDataValue.storedBy,
+                                        TrackedEntityDataValue.value
+                                )
+                        )
+                )
+        ).build();
+    }
+
+
+}
diff --git a/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceEndPointCall.java b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceEndPointCall.java
index cf6405c8f4..c15bc2a910 100644
--- a/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceEndPointCall.java
+++ b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceEndPointCall.java
@@ -72,16 +72,21 @@ public Response call() throws Exception {
                 trackedEntityInstanceService.trackedEntityInstance(trackedEntityInstanceUid,
                         fields(), true).execute();
 
+        if (response == null || !response.isSuccessful()) {
+            return response;
+        }
+
         Transaction transaction = databaseAdapter.beginNewTransaction();
+
         try {
-            if (response != null && response.isSuccessful()) {
-                TrackedEntityInstance trackedEntityInstance = response.body();
+            TrackedEntityInstance trackedEntityInstance = response.body();
 
-                trackedEntityInstanceHandler.handle(trackedEntityInstance);
+            trackedEntityInstanceHandler.handle(trackedEntityInstance);
+
+            resourceHandler.handleResource(TRACKED_ENTITY_INSTANCE, serverDate);
+
+            transaction.setSuccessful();
 
-                resourceHandler.handleResource(TRACKED_ENTITY_INSTANCE, serverDate);
-                transaction.setSuccessful();
-            }
         } catch (SQLiteConstraintException sql) {
             // This catch is necessary to ignore events with bad foreign keys exception
             // More info: If the foreign key have the flag
diff --git a/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceService.java b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceService.java
index 34b17097d6..25d46bc33b 100644
--- a/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceService.java
+++ b/core/src/main/java/org/hisp/dhis/android/core/trackedentity/TrackedEntityInstanceService.java
@@ -1,5 +1,6 @@
 package org.hisp.dhis.android.core.trackedentity;
 
+import org.hisp.dhis.android.core.common.Payload;
 import org.hisp.dhis.android.core.data.api.Fields;
 import org.hisp.dhis.android.core.data.api.Which;
 import org.hisp.dhis.android.core.imports.WebResponse;
@@ -23,4 +24,11 @@ Call<TrackedEntityInstance> trackedEntityInstance(
             @Path("trackedEntityInstanceUid") String trackedEntityInstanceUid,
             @Query("fields") @Which Fields<TrackedEntityInstance> fields,
             @Query("includeDeleted") boolean includeDeleted);
+
+    @GET("trackedEntityInstances")
+    Call<Payload<TrackedEntityInstance>> getTEIs(
+            @Query("ou") String orgUnit,
+            @Query("fields") @Which Fields<TrackedEntityInstance> fields,
+            @Query("paging") Boolean paging, @Query("page") int page,
+            @Query("pageSize") int pageSize);
 }
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
index 729cfff63c..1d20f341b1 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,8 +12,8 @@ org.gradle.jvmargs=-Xmx1536m
 # Properties which are consumed by plugins/gradle-mvn-push.gradle plugin.
 # They are used for publishing artifact to snapshot repository.
 
-VERSION_NAME=0.4.2.3-SNAPSHOT
-VERSION_CODE=42_3
+VERSION_NAME=0.4.3.1-SNAPSHOT
+VERSION_CODE=43_1
 GROUP=org.hisp.dhis
 
 POM_DESCRIPTION=Android SDK for DHIS 2.