diff --git a/api_guard/dist/types/index.d.ts b/api_guard/dist/types/index.d.ts
index 387e385a6bd..199bba7d111 100644
--- a/api_guard/dist/types/index.d.ts
+++ b/api_guard/dist/types/index.d.ts
@@ -622,7 +622,7 @@ export interface SchedulerLike extends TimestampProvider {
     schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
 }
 
-export declare function sequenceEqual<T>(compareTo: Observable<T>, comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean>;
+export declare function sequenceEqual<T>(compareTo: ObservableInput<T>, comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean>;
 
 export interface SequenceError extends Error {
 }
diff --git a/api_guard/dist/types/operators/index.d.ts b/api_guard/dist/types/operators/index.d.ts
index 4d673c5b08b..113b8b9add8 100644
--- a/api_guard/dist/types/operators/index.d.ts
+++ b/api_guard/dist/types/operators/index.d.ts
@@ -252,7 +252,7 @@ export declare function scan<V, A = V>(accumulator: (acc: A | V, value: V, index
 export declare function scan<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>;
 export declare function scan<V, A, S>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>;
 
-export declare function sequenceEqual<T>(compareTo: Observable<T>, comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean>;
+export declare function sequenceEqual<T>(compareTo: ObservableInput<T>, comparator?: (a: T, b: T) => boolean): OperatorFunction<T, boolean>;
 
 export declare function share<T>(): MonoTypeOperatorFunction<T>;
 export declare function share<T>(options: ShareConfig<T>): MonoTypeOperatorFunction<T>;
diff --git a/spec-dtslint/operators/sequenceEqual-spec.ts b/spec-dtslint/operators/sequenceEqual-spec.ts
index abf228acdf0..0130d56fefa 100644
--- a/spec-dtslint/operators/sequenceEqual-spec.ts
+++ b/spec-dtslint/operators/sequenceEqual-spec.ts
@@ -16,3 +16,9 @@ it('should enforce compareTo to be the same type of Observable', () => {
 it('should infer correctly given comparator parameter', () => {
   const a = of(1, 2, 3).pipe(sequenceEqual(of(1), (val1, val2) => val1 === val2)); // $ExpectType Observable<boolean>
 });
+
+it('should support Promises', () => {
+  of(1, 2, 3).pipe(sequenceEqual(Promise.resolve(1))); // $ExpectType Observable<boolean>
+  // Enforce the same types produced by Promise and source observable
+  of(1, 2, 3).pipe(sequenceEqual(Promise.resolve('foo'))); // $ExpectError
+});
diff --git a/src/internal/operators/sequenceEqual.ts b/src/internal/operators/sequenceEqual.ts
index ba514440e0a..a6f9bec3088 100644
--- a/src/internal/operators/sequenceEqual.ts
+++ b/src/internal/operators/sequenceEqual.ts
@@ -1,8 +1,7 @@
-import { Observable } from '../Observable';
-
-import { OperatorFunction } from '../types';
+import { OperatorFunction, ObservableInput } from '../types';
 import { operate } from '../util/lift';
 import { createOperatorSubscriber } from './OperatorSubscriber';
+import { innerFrom } from '../observable/innerFrom';
 
 /**
  * Compares all values of two observables in sequence using an optional comparator function
@@ -13,7 +12,8 @@ import { createOperatorSubscriber } from './OperatorSubscriber';
  *
  * ![](sequenceEqual.png)
  *
- * `sequenceEqual` subscribes to two observables and buffers incoming values from each observable. Whenever either
+ * `sequenceEqual` subscribes to source observable and `compareTo` `ObservableInput` (that internally
+ * gets converted to an observable) and buffers incoming values from each observable. Whenever either
  * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom
  * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the
  * observables completes, the operator will wait for the other observable to complete; If the other
@@ -53,14 +53,15 @@ import { createOperatorSubscriber } from './OperatorSubscriber';
  * @see {@link zip}
  * @see {@link withLatestFrom}
  *
- * @param {Observable} compareTo The observable sequence to compare the source sequence to.
- * @param {function} [comparator] An optional function to compare each value pair
+ * @param compareTo The `ObservableInput` sequence to compare the source sequence to.
+ * @param comparator An optional function to compare each value pair.
+ *
  * @return A function that returns an Observable that emits a single boolean
  * value representing whether or not the values emitted by the source
- * Observable and provided Observable were equal in sequence.
+ * Observable and provided `ObservableInput` were equal in sequence.
  */
 export function sequenceEqual<T>(
-  compareTo: Observable<T>,
+  compareTo: ObservableInput<T>,
   comparator: (a: T, b: T) => boolean = (a, b) => a === b
 ): OperatorFunction<T, boolean> {
   return operate((source, subscriber) => {
@@ -94,7 +95,7 @@ export function sequenceEqual<T>(
             // at the appropriate time.
             complete ? emit(false) : selfState.buffer.push(a);
           } else {
-            // If the other stream *does* have values in it's buffer,
+            // If the other stream *does* have values in its buffer,
             // pull the oldest one off so we can compare it to what we
             // just got. If it wasn't a match, emit `false` and complete.
             !comparator(a, buffer.shift()!) && emit(false);
@@ -119,7 +120,7 @@ export function sequenceEqual<T>(
 
     // Subscribe to each source.
     source.subscribe(createSubscriber(aState, bState));
-    compareTo.subscribe(createSubscriber(bState, aState));
+    innerFrom(compareTo).subscribe(createSubscriber(bState, aState));
   });
 }