diff --git a/samples/SampleSpellCheckerService/_index.html b/samples/SampleSpellCheckerService/_index.html
new file mode 100755
index 0000000..6a6ab67
--- /dev/null
+++ b/samples/SampleSpellCheckerService/_index.html
@@ -0,0 +1,3 @@
+<p>A sample showing how to create a spell checker with the <code><a
+href="../../../reference/android/service/textservice/SpellCheckerService.html">SpellCheckerService</a></code>
+APIs introduced in Android 4.0 (API level 14).</p>
