HowTo Schema, המדריך המלא

📖 מה זה HowTo schema (ומתי הוא לא מה שאתם חושבים)

תקשיבו. אני אפתח עם הסיפור הכי חוזר על עצמו אצלי בשנים האחרונות. לקוח מגיע, אומר "שמוליק, יש לי מאמר על 5 סיבות שכדאי לעבוד עם יועץ SEO, הטמעתי עליו HowTo schema, ואני לא מבין למה זה לא מופיע ב-Rich Results". אני פותח את העמוד, רואה את ה-JSON-LD, ובאמת יש שם HowTo. הבעיה, המאמר עצמו הוא לא HowTo. הוא מאמר דעה. אין שם שום צעדים, אין שום תוצאה מדידה, אין שום תהליך לבצע. זה פשוט רשימה של סיבות, שלכל אחת יש פסקה הסבר. ה-HowTo schema על העמוד הזה לא רק שלא יעזור, הוא יכול אפילו להזיק כי גוגל יזהה את האי התאמה.

זה ההבדל הקריטי הראשון שצריך להפנים. HowTo schema זה לא תג שמשתמשים בו על כל תוכן ש"נראה" כמו רשימה. זה schema ייעודי לתוכן פרוצדורלי, כלומר תהליך עם צעדים שמובילים לתוצאה מדידה. ההבחנה הזאת היא הכי חשובה במאמר הזה, ואם תזכרו רק אותה, כבר חסכתם לעצמכם מהטעות הנפוצה ביותר בתחום.

הדוגמאות הקלאסיות, איך להחליף צמיג ברכב, איך להתקין WordPress על שרת, איך להכין חביתה, איך לחבר טלפון ל-Wi-Fi. כל אחד מאלה הוא תהליך עם התחלה, סוף, וצעדים מסודרים. בסוף יש לכם צמיג מוחלף, אתר שעובד, חביתה מוכנה, או טלפון מחובר. התוצאה היא בינארית, או שהיא קרתה או שלא. זה ה-litmus test הראשון שאני מבקש מכל לקוח לעבור לפני שמדבר איתי על HowTo.

במאמר הזה, אני אעבור איתכם על כל מה שצריך לדעת על HowTo schema. מתי כן ומתי לא, מה ה-required properties, מה ה-recommended, איך נראה JSON-LD מלא לכל מקרה שימוש, מה הטעויות הנפוצות, ואיך מאמתים שהכל תקין. ואני אדבר גם על השינוי הדרמטי שגוגל עשה בסוף 2023, שגרם להרבה אנשים לחשוב שהסכמה הזאת מתה. הספוילר, היא חיה ובועטת, פשוט בערוצים אחרים, AI engines, voice assistants, מובייל rich results. אם אתם בונים אתר עם תוכן פרוצדורלי, או חושבים להוסיף הוראות מובנות לאתר קיים, המדריך הזה ייתן לכם את כל מה שצריך מהבסיס ועד ה-edge cases. שמוליק דורינבאום, נתחיל.

📉 השינוי הדרמטי של 2023, ‏Google הוריד את HowTo rich result ב-desktop

בסוף 2023, גוגל הודיע על שינוי משמעותי בדרך שבה הוא מציג HowTo rich results. לפני השינוי, אם הטמעתם HowTo schema על עמוד תיקון נזילה במטבח, גוגל היה מציג ב-SERP כרטיס יפה עם תמונות הצעדים, מספור, ולפעמים סרטון. זה היה לוקח אזור משמעותי במסך, ומשך הרבה קליקים. אתרי DIY בנו אסטרטגיה שלמה סביב הפיצ'ר הזה. הם השקיעו בצילום מקצועי לכל צעד, בכותרות מותאמות, ובמבנה schema אגרסיבי. ההישג, מקום ויזואלי בולט ב-SERP שמשך CTR גבוה.

אחרי השינוי, גוגל הפסיק להציג את ה-rich result של HowTo במכשירי desktop. הוא נשאר רק במובייל, ובאופן מצומצם. אם תחפשו היום מ-desktop "איך להחליף נורה", סביר להניח שלא תראו את כרטיס ה-HowTo כפי שהיה לפני 2023. תראו את הקישורים הרגילים, ה-People Also Ask, אולי AI Overviews, אבל לא את כרטיס ההוראות הצבעוני שהיה שם. ההכרזה הזאת זרקה את כל האתרים שעבדו לפי המודל הישן לאוויר.

למה גוגל עשה את זה

הם לא הסבירו במפורש. השערה רווחת, השינוי בא לרכז יותר תשומת לב במנועי תוכן ראשיים כמו AI Overviews. שיקול נוסף, חלק מהרבה אתרים שהטמיעו HowTo schema על תוכן שלא ראוי לכך, פלשו ב-SERP בצורה לא נעימה. גוגל בחר לפתור את הבעיה בכך שביטל את הפיצ'ר עבור כולם, גם לאלה שעשו את זה נכון. זה צעד דרסטי, אבל מאוד אופייני לגוגל בשנים האחרונות.

מה זה אומר בפועל

בעולם של 2026, אתם לא יכולים יותר להתעורר בבוקר ולהגיד "אני מטמיע HowTo schema כי אני רוצה את כרטיס ההוראות ב-Google". אם זאת המוטיבציה היחידה שלכם, אתם תתאכזבו. אבל זה לא הסיפור המלא. הסכמה עצמה לא נמחקה, היא רק לא מוצגת כפי שהוצגה.

השאלה הגדולה היא, האם זה אומר שצריך להסיר את ה-HowTo schema מהעמודים? התשובה הברורה היא לא. הסיבות לכך הן הנושא של הפרק הבא, והן הסיבה המרכזית למה אני כותב את המאמר הזה ב-2026. אתרים שמסירים את ה-schema רק בגלל שגוגל הוריד את הכרטיס, מפסידים פוטנציאל אמיתי בערוצים אחרים שעדיין צומחים.

💡 למה זה עדיין שווה לכתוב HowTo schema ב-2026 (3 סיבות)

אז אם גוגל הוריד את ה-rich result מ-desktop, למה אני עדיין ממליץ ללקוחות שלי להטמיע HowTo schema על תוכן פרוצדורלי? יש לכך 3 סיבות חזקות, וכל אחת מהן עומדת בפני עצמה. אבל כשמשלבים אותן, התמונה היא ברורה, מי שלא מטמיע HowTo schema על תוכן פרוצדורלי בעידן הזה, פשוט מוותר על תנועה ועל נראות.

סיבה 1, AI engines אוהבים את זה

ChatGPT, Perplexity, Gemini, Claude, Google AI Overviews, כולם מסתמכים על structured data בצורה משמעותית כדי להבין תוכן. כשמודל שפה מנסה לענות על שאלה כמו "איך מתקינים תרמוסטט חכם", הוא מעדיף לצטט תוכן ש-schema-מוגדר היטב. HowTo schema אומר למודל, "זה תהליך, אלה הצעדים, זאת התוצאה הסופית". המודל יכול לעבד את זה הרבה יותר נוח מטקסט גולמי. הוא יודע לזהות מבנה ברור, להוציא את הצעדים ולצטט אותם בתשובה.

בעידן שבו תנועה ממנועי AI הופכת ליותר ויותר משמעותית, להוריד מהאתר schema שמייעל את הצריכה של המודלים זה ירייה ברגל. אני רואה כבר היום באנליטיקה של לקוחות תנועה ממשית מציטוטים ב-ChatGPT וב-Perplexity, וזה רק יגדל.

סיבה 2, Voice assistants משתמשים בו

אם משתמש שואל את Google Assistant, Alexa או Siri, "איך מנקים מסך טלוויזיה", המנוע מחפש תוכן עם הוראות מובנות. עמוד עם HowTo schema יציג את הצעדים בצורה ברורה למענה קולי, עמוד בלי schema פשוט יוקרא בשטף, וזה הרבה פחות אפקטיבי. עוזרי קול עדיין צוברים תאוצה, במיוחד בבית החכם, וזאת הזדמנות שלא כדאי להחמיץ. במטבחים, בסלונים, ברכבים, שאלות "איך" עולות כל הזמן.

סיבה 3, מובייל rich results עדיין קיימים

גם אם desktop לא מציג את הכרטיס, מובייל עדיין מציג אותו במצבים מסוימים, בעיקר עבור recipes ו-DIY queries. ראיתי בכלי ניטור הופעות של כרטיס HowTo במובייל גם ב-2026, פחות מבעבר אבל לא אפס. תוסיפו לזה את העובדה שיותר מ-60% מהחיפושים היום מבוצעים ממובייל, וזאת סיבה לבד.

בפרקים הבאים נעבור על המבנה הטכני, איך להטמיע נכון, ואיפה הטעויות הנפוצות. אבל קודם, צריך להבין הבחנה קריטית, ההבדל בין HowTo ל-FAQ schema.

🔄 ההבדל בין HowTo ל-FAQ schema (טעות חוזרת)

אחת הטעויות הכי נפוצות שאני רואה בשטח, אנשים שמטמיעים HowTo schema על תוכן שצריך להיות FAQ, או הפוך. שני ה-schemas שונים מהותית, ולמרות שלפעמים נראה שאפשר להמיר בקלות בין השניים, ההבדל קריטי. גוגל ו-AI engines מתייחסים אליהם כאל סוגי תוכן שונים לחלוטין, ויש להם ציפיות שונות מכל אחד מהם.

FAQ schema

FAQPage schema מתאר עמוד שמורכב משאלות ותשובות עצמאיות. כל שאלה היא יחידה בפני עצמה, התשובה שלה עומדת לבד, ואין סדר הגיוני בין השאלות. "מה זה SEO?", "כמה עולה קידום אתרים?", "איך מודדים תוצאות?". אלה שאלות נפרדות, ואפשר לקרוא אותן בכל סדר. אם תהפכו את השלישית לראשונה, התוכן עדיין יהיה הגיוני ושימושי. אין תלות בין השאלות.

למידע מעמיק על הטמעת FAQ schema יש לי מדריך מלא על FAQ schema באלמנטור, וגם השוואה מקיפה בין FAQ ל-HowTo עם דוגמאות קוד.

HowTo schema

HowTo schema מתאר תהליך עם סדר קבוע. הצעדים תלויים זה בזה, צעד 2 הוא אחרי צעד 1, צעד 3 לא ניתן לבצע לפני שצעד 2 הושלם. "איך להחליף צמיג", "איך להתקין WordPress". זאת רצף עם תוצאה מובחנת בסוף, ואי אפשר לבצע אותו בסדר חופשי. אם תתחילו מצעד 3, או שתפספסו את התוצאה או שתעשו נזק. הסדר הוא חלק אינטגרלי מהתוכן עצמו.

טבלת השוואה

בפרק הבא נכנס לליבת הקוד, ה-required properties של HowTo schema, ונראה JSON-LD ראשון אמיתי שאתם יכולים להעתיק ולהתאים לעצמכם. אבל לפני שאנחנו נכנסים לטכני, כדאי לזכור את ההבחנה הזאת בכל פעם שאתם מתלבטים. אם זה לא תהליך עם צעדים מסודרים ותוצאה ברורה, זה לא HowTo, נקודה.

🔑 Required properties, ‏name + step (עם דוגמת קוד)

schema.org דורש שני properties חובה ב-HowTo schema, name ו-step. בלי שניהם, ה-schema לא תקין, ו-Rich Results Test יחזיר שגיאה. הנה מה שצריך לדעת. ההבנה של ה-required מתחילה כל הטמעה, כי בלי הבסיס הזה תקין, גם אם תוסיפו את כל ה-recommended properties בעולם, הסכמה תיכשל באימות.

name

זה השם של התהליך כולו. צריך להיות תיאורי וברור, מומלץ להתחיל ב"איך" (How to) בעברית או באנגלית. דוגמאות, "איך להחליף צמיג ברכב", "How to install WordPress on a VPS", "איך להכין חביתה ספרדית". כלל אצבע, אם הקורא הסתכל רק על ה-name והבין מהו התהליך, עשיתם את זה נכון. אם הוא צריך לקרוא עוד כדי להבין, הניסוח לוקה בחסר. אורך אופטימלי, 30 עד 70 תווים.

step

זאת רשימה (array) של אובייקטים מסוג HowToStep. כל אובייקט מתאר צעד אחד בתהליך. צריך להיות לפחות שני צעדים, אחרת זה לא באמת תהליך. אם יש לכם רק פעולה אחת, אתם לא צריכים HowTo, אתם צריכים Article. רוב התהליכים האיכותיים מכילים בין 4 ל-12 צעדים.

דוגמת קוד מינימלית

הנה איך נראה HowTo schema במבנה המינימלי ביותר, רק עם ה-required properties. זאת התשתית שאפשר לבנות עליה.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "איך לאפס את ה-Wi-Fi ב-Router",
  "step": [
    {
      "@type": "HowToStep",
      "name": "איתור כפתור ה-Reset",
      "text": "מאתרים את כפתור ה-Reset בגב הראוטר, בדרך כלל בתוך חור קטן."
    },
    {
      "@type": "HowToStep",
      "name": "לחיצה ארוכה",
      "text": "באמצעות מהדק נייר או עצם דק, לוחצים על הכפתור 10 שניות."
    },
    {
      "@type": "HowToStep",
      "name": "המתנה לאתחול",
      "text": "מחכים 2 דקות עד שהראוטר יסיים את האתחול ויחזור לפעולה."
    }
  ]
}
</script>

זה הבסיס. בפרק הבא נראה את ה-recommended properties שמרחיבים את ה-HowTo ועוזרים למנועי חיפוש ול-AI להבין הקשר רחב יותר, כמו totalTime, supply, ו-estimatedCost. ההוספה של אלה היא ההבדל בין schema פונקציונלי ל-schema איכותי באמת. אם אתם בונים תוכן רציני, אל תסתפקו ב-required בלבד.

🎯 Recommended properties, ‏image, ‏totalTime, ‏supply, ‏tool, ‏estimatedCost

אחרי שיש לכם name ו-step, השלב הבא הוא להוסיף את ה-recommended properties. הם לא חובה טכנית, אבל הם מגדילים משמעותית את הסיכוי שמנועי חיפוש ו-AI יבחרו בתוכן שלכם, ובמובייל הם נדרשים כדי להופיע ב-rich result. ראיתי לקוחות שהוסיפו רק את ה-required וקיבלו אישור ב-Rich Results Test, אבל בפועל לא היו מקבלים כרטיס במובייל כי חסר היה image ו-totalTime.

image

תמונה ראשית של התהליך כולו. רצוי בגודל 1200x630 או יותר. צריך להיות אובייקט ImageObject או URL ישיר. תמונה ברורה ואיכותית של התוצאה הסופית עובדת הכי טוב. תמונה גנרית או stock photo פוגעת באיכות הסכמה.

totalTime

זמן הביצוע הכולל של התהליך, ב-ISO 8601 duration format. למשל, PT30M (30 דקות), PT2H (שעתיים), PT1H30M (שעה וחצי), PT45M (45 דקות). אל תזייפו פה, גוגל יודע להשוות לזמן הקריאה הממוצע ולתחושת המשתמש. תהיו מציאותיים.

supply

רשימה של חומרים שצריך לתהליך. למשל לתיקון כיור, מפתח שוודי, אטם חדש, סבון נוזלי. כל פריט הוא אובייקט HowToSupply, וצריך לשים שם ברור. החומרים האלה הם פריטים מתכלים, כאלה שנגמרים אחרי השימוש.

tool

רשימה של כלים שצריך (להבדיל מחומרים שמתכלים). למשל מברג פיליפס, מקדחה, סולם. כל פריט הוא אובייקט HowToTool. ההבחנה בין supply ל-tool עוזרת ל-AI להבין מה חוזר על עצמו לתהליכים דומים.

estimatedCost

אובייקט MonetaryAmount שמתאר את העלות המוערכת. רלוונטי בעיקר לתיקוני בית, פרויקטים, מתכונים. שדה chrome, currency. למשל, {"@type": "MonetaryAmount", "currency": "ILS", "value": "150"}. שימו לב לכתוב את ה-currency הנכון לקהל היעד שלכם, ILS לישראלים, USD לקהל אמריקאי.

דוגמה מורחבת

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "איך לתקן כיור דולף",
  "image": "https://example.co.il/images/sink-fix.jpg",
  "totalTime": "PT45M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "ILS",
    "value": "80"
  },
  "supply": [
    {"@type": "HowToSupply", "name": "אטם גומי חדש"},
    {"@type": "HowToSupply", "name": "סרט טפלון"}
  ],
  "tool": [
    {"@type": "HowToTool", "name": "מפתח שוודי"},
    {"@type": "HowToTool", "name": "מטלית"}
  ],
  "step": []
}
</script>

שימו לב שהשמטתי את ה-step כדי לחסוך מקום, אבל בקוד אמיתי הוא חייב להיות מלא. עכשיו נצלול לתוך מבנה ה-HowToStep עצמו, שזה הלב של ה-schema.

📝 HowToStep, ‏מבנה צעד בודד (עם דוגמת קוד)

HowToStep הוא הלב של ה-HowTo schema. כל צעד הוא אובייקט עם כמה properties, וההבנה של מה ניתן לכלול בכל צעד היא הבסיס להטמעה איכותית. צעד טוב הוא צעד שמשתמש יכול לקרוא לבדו, להבין מה לעשות, ולהשלים את הפעולה בלי לחזור לטקסט הראשי של העמוד. כשאתם בונים schema, תחשבו על הצעד כעל יחידה עצמאית.

name

שם הצעד, קצר וברור. למשל, "איתור הברז הראשי", "הסרת הגלגל", "חיתוך הבצל". זאת לא רק "שלב 1". תנו שם משמעותי שמתאר את הפעולה. שם טוב הופך את ה-schema לקריא הרבה יותר, גם לבני אדם וגם למודלי AI.

text

תיאור מפורט של הצעד. פסקה אחת או שתיים, מסבירה בדיוק מה לעשות. זאת לא מקום לתוכן יחסי. תהיו ספציפיים, מדידים, ופעולתיים. במקום "שמן את הבורג", תכתבו "מורחים שמן מכונה על הבורג, סובבים שלוש פעמים ימינה". ספציפיות היא הקריטריון.

image

תמונה של הצעד הספציפי הזה. עוזרת מאוד למשתמש להבין את הפעולה במבט. במובייל, התמונות האלה הן מה שעושה את כרטיס ה-HowTo מרשים. תמונה של ידיים מבצעות את הפעולה עובדת הכי טוב, כי המשתמש רואה את ההקשר.

url

URL ישיר לצעד הזה בעמוד. בדרך כלל זה anchor link, למשל https://example.co.il/guide/#step-3. גוגל משתמש בזה כדי לקשר ישירות לצעד הספציפי במידת הצורך, וזה גם עוזר ל-AI לציטוט מדויק.

itemListElement

בשימוש מתקדם, לתת-צעדים בתוך צעד. כלומר, אם צעד 2 דורש 3 פעולות פנימיות, אפשר לפרק אותן ל-itemListElement של HowToStep nested. נסקור את זה בפרק על nested steps עוד שני פרקים.

דוגמת קוד

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "איך להתקין WordPress על שרת VPS",
  "step": [
    {
      "@type": "HowToStep",
      "name": "חיבור ל-SSH",
      "text": "מתחברים לשרת ה-VPS באמצעות פקודת ssh user@server-ip, ומזינים את הסיסמה כשהיא מבוקשת.",
      "image": "https://example.co.il/images/ssh-connect.jpg",
      "url": "https://example.co.il/install-wp/#step-1"
    },
    {
      "@type": "HowToStep",
      "name": "התקנת LAMP stack",
      "text": "מריצים sudo apt update ואז sudo apt install apache2 mysql-server php php-mysql, ומחכים להשלמת ההתקנה.",
      "image": "https://example.co.il/images/lamp-install.jpg",
      "url": "https://example.co.il/install-wp/#step-2"
    },
    {
      "@type": "HowToStep",
      "name": "הורדת WordPress",
      "text": "מריצים wget https://wordpress.org/latest.tar.gz ואז tar -xzvf latest.tar.gz בתוך תיקיית הריצה של Apache.",
      "image": "https://example.co.il/images/wp-download.jpg",
      "url": "https://example.co.il/install-wp/#step-3"
    }
  ]
}
</script>

הדוגמה הזאת מראה צעד אופייני, עם name + text + image + url. במציאות, רוב ה-HowTo schemas שאני בונה ללקוחות מכילים את ארבעת ה-properties האלה בכל צעד. זה הסטנדרט המומלץ.

💭 HowToTip מול HowToStep, מתי איזה

schema.org מגדיר גם type שנקרא HowToTip, וזאת הבחנה שרבים מפספסים. ההבדל בין HowToStep ל-HowToTip עדין אבל חשוב, וכשמשתמשים נכון, ה-schema הופך לעוצמתי הרבה יותר. רוב האתרים מתעלמים מ-HowToTip לחלוטין, ומכניסים הכל כ-Step. זה עובד, אבל זה מפספס מידע סמנטי שגוגל ו-AI יכולים לנצל.

HowToStep

צעד פעולה. משהו שהמשתמש חייב לבצע כדי להגיע לתוצאה. אם תדלגו על הצעד, התהליך לא יושלם. למשל, "חברו את הכבל החשמלי". בלי זה אין חשמל. זה צעד. אם המשתמש דילג, התוצאה הסופית לא מושגת. הצעדים הם החלק הקריטי של ה-HowTo, ובלעדיהם אין schema.

HowToTip

טיפ או הצעה שמעצימה את התהליך. המשתמש לא חייב לבצע אותו, אבל אם הוא יבצע, התוצאה תהיה טובה יותר. למשל, "לאחר חיבור הכבל, מומלץ להמתין דקה לפני הפעלה כדי לוודא יציבות". בלי הטיפ, התהליך עדיין יעבוד, אבל איתו הוא יעבוד יותר טוב. ההבחנה הזאת חשובה, כי היא משדרת ל-AI שיש hierarchy של חשיבות. צעד הוא must, טיפ הוא nice to have.

איך לשלב

HowToTip לא הולך עצמאית. הוא נכלל בתוך step כ-itemListElement, או כ-property של ה-step. כדאי גם לכלול HowToDirection לפעולה הקונקרטית, וה-Tip כתוספת. הנה דוגמה. שימו לב למבנה הפנימי של itemListElement, שיכול להכיל גם הוראות וגם טיפים יחד באותה רשימה, וזה נותן גמישות מלאה.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "איך לאפות לחם מחמצת",
  "step": [
    {
      "@type": "HowToStep",
      "name": "הכנת המחמצת",
      "itemListElement": [
        {
          "@type": "HowToDirection",
          "text": "מערבבים 100 גרם קמח עם 100 מל מים בקערה."
        },
        {
          "@type": "HowToTip",
          "text": "השתמשו במים בטמפרטורת חדר, מים קרים יאטו את התסיסה."
        }
      ]
    },
    {
      "@type": "HowToStep",
      "name": "תסיסה ראשונית",
      "itemListElement": [
        {
          "@type": "HowToDirection",
          "text": "מכסים את הקערה במטלית ומשאירים על השיש 12 שעות."
        },
        {
          "@type": "HowToTip",
          "text": "בחורף, מומלץ להניח את הקערה ליד מקור חום עדין כדי להאיץ את התסיסה."
        }
      ]
    }
  ]
}
</script>

בשימוש מתקדם יותר, אפשר לקנן צעדים בתוך צעדים, ליצור הירארכיה של תהליכים מורכבים. זה הנושא של הפרק הבא, וזה אחד הכלים החזקים של HowTo schema שרוב האתרים מפספסים.

🪆 Nested steps, ‏הזיינוף שתת-הצעדים (עם דוגמת קוד)

תהליכים מורכבים לפעמים דורשים הירארכיה. צעד ראשי עם תת-צעדים בתוכו. schema.org תומך בזה דרך itemListElement של HowToStep, וזה אחד הפיצ'רים החזקים של ה-schema, אבל גם אחד הפחות מוכרים. רוב הכלים שמייצרים schema אוטומטית לא תומכים בקינון, אז זה משהו שצריך לכתוב ידנית, וזה משתלם כשהתוכן באמת מצדיק.

מתי להשתמש

אם יש לכם תהליך שמתחלק לשלבים גדולים, וכל שלב מורכב מפעולות פנימיות. למשל, "בניית אתר WordPress" אפשר לפרק ל-3 שלבים, התקנה, עיצוב, פרסום. וכל אחד מאלה מורכב מ-4-5 פעולות פנימיות. זה תרחיש קלאסי לקנון. עוד דוגמה, מתכון לקציצות, יש את הכנת התערובת, יצירת הצורה, והבישול. כל אחד עם פעולות פנימיות.

איך זה עובד

כל HowToStep יכול להכיל itemListElement שהוא array של HowToStep פנימיים, או HowToDirection (פעולה), או HowToTip (טיפ). זה יוצר מבנה עץ הירארכי שמודלי AI מבינים מצוין. במקום רשימה שטוחה של 15 צעדים, יש לכם 3 חלקים עם 5 צעדים בכל אחד, וזה הרבה יותר נוח לעיבוד.

דוגמת קוד מלאה

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "איך לבנות אתר WordPress מ-A עד Z",
  "totalTime": "PT3H",
  "step": [
    {
      "@type": "HowToStep",
      "name": "שלב 1, התקנת WordPress",
      "itemListElement": [
        {
          "@type": "HowToStep",
          "name": "רכישת דומיין ואחסון"
        },
        {
          "@type": "HowToStep",
          "name": "התקנה אוטומטית מ-cPanel"
        },
        {
          "@type": "HowToStep",
          "name": "בחירת שפת ממשק"
        }
      ]
    },
    {
      "@type": "HowToStep",
      "name": "שלב 2, עיצוב האתר",
      "itemListElement": [
        {
          "@type": "HowToStep",
          "name": "בחירת תבנית"
        },
        {
          "@type": "HowToStep",
          "name": "התאמת צבעים וגופנים"
        },
        {
          "@type": "HowToStep",
          "name": "בניית עמודי תוכן"
        }
      ]
    },
    {
      "@type": "HowToStep",
      "name": "שלב 3, פרסום והפצה",
      "itemListElement": [
        {
          "@type": "HowToStep",
          "name": "הגדרת SSL"
        },
        {
          "@type": "HowToStep",
          "name": "שליחה ל-Search Console"
        }
      ]
    }
  ]
}
</script>

בפרקים הבאים נראה דוגמאות שלמות לשני מקרי שימוש פופולריים, מתכון בישול ומדריך טכני. אלה שני סוגי תוכן שונים מאוד, אבל ה-HowTo schema של שניהם מבוסס על אותם עקרונות. ההבדלים יהיו בעיקר ב-supply, tool, ו-totalTime, וגם בתמונות.

🍳 דוגמת קוד מלאה, ‏מתכון בישול עם HowTo schema

מתכונים הם אחד השימושים הקלאסיים של HowTo schema. אבל יש פה ניואנס חשוב. אם זה מתכון, יש schema ייעודי שנקרא Recipe, וגוגל מעדיף אותו. עם זאת, אפשר לשלב את שניהם או להשתמש ב-HowTo כאשר רוצים פוקוס על תהליך ההכנה.

הקוד המלא לחביתה ספרדית

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "איך להכין חביתה ספרדית קלאסית",
  "description": "מדריך מלא להכנת חביתה ספרדית קלאסית עם תפוחי אדמה ובצל.",
  "image": "https://example.co.il/images/spanish-omelet.jpg",
  "totalTime": "PT45M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "ILS",
    "value": "25"
  },
  "supply": [
    {"@type": "HowToSupply", "name": "5 ביצים"},
    {"@type": "HowToSupply", "name": "3 תפוחי אדמה בינוניים"},
    {"@type": "HowToSupply", "name": "בצל גדול אחד"},
    {"@type": "HowToSupply", "name": "שמן זית"},
    {"@type": "HowToSupply", "name": "מלח ופלפל"}
  ],
  "tool": [
    {"@type": "HowToTool", "name": "מחבת לא דביקה 24 ס"מ"},
    {"@type": "HowToTool", "name": "קערה גדולה"},
    {"@type": "HowToTool", "name": "מטרפה"},
    {"@type": "HowToTool", "name": "צלחת גדולה להפיכה"}
  ],
  "step": [
    {
      "@type": "HowToStep",
      "name": "הכנת הירקות",
      "text": "קולפים את תפוחי האדמה וחותכים לפרוסות דקות. חותכים את הבצל לקוביות קטנות.",
      "image": "https://example.co.il/images/omelet-veg.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "טיגון התפוחי אדמה",
      "text": "מחממים שמן זית במחבת על אש בינונית. מטגנים את תפוחי האדמה והבצל ביחד 15 דקות עד שהם רכים.",
      "image": "https://example.co.il/images/omelet-fry.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "טריפת הביצים",
      "text": "בקערה גדולה טורפים את הביצים עם מלח ופלפל. מוסיפים את התפוחי אדמה והבצל המטוגנים ומערבבים בעדינות.",
      "image": "https://example.co.il/images/omelet-mix.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "אפיית החביתה",
      "text": "שופכים את התערובת חזרה למחבת על אש נמוכה. מבשלים 8 דקות עד שהתחתית מזהיבה.",
      "image": "https://example.co.il/images/omelet-cook.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "היפוך והשלמה",
      "text": "מניחים צלחת גדולה על המחבת והופכים בזהירות. מחליקים את החביתה חזרה למחבת לצד השני ומבשלים עוד 5 דקות.",
      "image": "https://example.co.il/images/omelet-flip.jpg"
    }
  ]
}
</script>

זה ה-schema לחביתה. עכשיו נראה מקרה שונה לחלוטין, מדריך טכני לפתרון בעיה. שם המבנה שונה מעט, יש פחות supply ויותר tool, ולפעמים estimatedCost הוא 0.

🔧 דוגמת קוד מלאה, ‏מדריך טכני (תיקון תקלה) עם HowTo schema

מקרי שימוש טכניים הם המקום שבו HowTo schema באמת זורח. דמיינו עמוד באתר תמיכה שמסביר איך לפתור תקלה ספציפית. כל צעד צריך להיות פעולה ברורה, ההירארכיה צריכה להיות נקייה, וה-AI engines יעדיפו אותו כמקור לתשובה.

הקוד המלא לפתרון בעיית WiFi איטי

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "איך לפתור בעיה של WiFi איטי בבית",
  "description": "מדריך טכני לאבחון ופתרון בעיות מהירות WiFi בבית הפרטי.",
  "image": "https://example.co.il/images/wifi-fix.jpg",
  "totalTime": "PT30M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "ILS",
    "value": "0"
  },
  "tool": [
    {"@type": "HowToTool", "name": "מחשב או טלפון מחובר ל-WiFi"},
    {"@type": "HowToTool", "name": "גישה לראוטר"}
  ],
  "step": [
    {
      "@type": "HowToStep",
      "name": "בדיקת מהירות בסיסית",
      "text": "נכנסים לאתר fast.com או speedtest.net ומריצים מבחן מהירות. רושמים את המספרים שיוצאים, גם הורדה וגם העלאה.",
      "image": "https://example.co.il/images/speed-test.jpg",
      "url": "https://example.co.il/wifi-fix/#step-1"
    },
    {
      "@type": "HowToStep",
      "name": "השוואה למהירות החבילה",
      "text": "בודקים את החבילה אצל ספק האינטרנט שלכם. אם המהירות בפועל פחות מ-50% מהחבילה, יש בעיה אמיתית.",
      "image": "https://example.co.il/images/check-plan.jpg",
      "url": "https://example.co.il/wifi-fix/#step-2"
    },
    {
      "@type": "HowToStep",
      "name": "אתחול הראוטר",
      "text": "מנתקים את הראוטר מהחשמל למשך 30 שניות, ואז מחברים מחדש. ממתינים 2 דקות לאתחול מלא, ובודקים מהירות שוב.",
      "image": "https://example.co.il/images/restart-router.jpg",
      "url": "https://example.co.il/wifi-fix/#step-3"
    },
    {
      "@type": "HowToStep",
      "name": "שינוי ערוץ WiFi",
      "text": "נכנסים לממשק הראוטר דרך 192.168.1.1 בדפדפן. בהגדרות WiFi משנים את הערוץ ל-1, 6, או 11 בתחום 2.4GHz. שומרים ובודקים שוב.",
      "image": "https://example.co.il/images/change-channel.jpg",
      "url": "https://example.co.il/wifi-fix/#step-4"
    },
    {
      "@type": "HowToStep",
      "name": "בדיקת ההפרעות",
      "text": "מרחיקים את הראוטר ממכשירים אלקטרוניים אחרים, מטא-לים, ומכשירי בלוטות'. אלה גורמים הפרעה לאות.",
      "image": "https://example.co.il/images/check-interference.jpg",
      "url": "https://example.co.il/wifi-fix/#step-5"
    },
    {
      "@type": "HowToStep",
      "name": "שדרוג ה-Firmware",
      "text": "בממשק הראוטר, בודקים אם יש עדכון firmware זמין. אם כן, מתקינים. firmware ישן יכול לגרום לבעיות ביצועים.",
      "image": "https://example.co.il/images/firmware.jpg",
      "url": "https://example.co.il/wifi-fix/#step-6"
    },
    {
      "@type": "HowToStep",
      "name": "פנייה לספק",
      "text": "אם אחרי כל הצעדים האלה הבעיה נשארת, יש בעיה ברשת של הספק. פונים אליו עם נתוני מבחני המהירות שביצעתם.",
      "image": "https://example.co.il/images/contact-isp.jpg",
      "url": "https://example.co.il/wifi-fix/#step-7"
    }
  ]
}
</script>

עכשיו שראינו את הגישה הנכונה, נדבר על הטעויות הנפוצות שאני רואה בשטח.

🚫 הטעויות הנפוצות (faking totalTime, ‏missing name on step, ועוד)

אחרי שראיתם מאות הטמעות של HowTo schema בשנים האחרונות, יש לי רשימת טעויות שאני רואה חוזרת על עצמה. הנה הקריטיות, עם דרכי פתרון.

טעות 1, faking totalTime

ראיתי הרבה אתרים שמטמיעים PT5M (5 דקות) על תהליך שבמציאות לוקח שעה. הם חושבים שזה ימשוך יותר קליקים. הבעיה, גוגל ו-AI engines משווים את הזמן המוצהר לזמן הקריאה הממוצע ולתחושת המשתמש. אם זה לא תואם, האות נפגע. אל תזייפו זמן. תהיו מציאותיים.

טעות 2, missing name on step

ה-name של step הוא לא חובה טכנית, אבל בלעדיו ה-schema הופך לחלש. מנועי חיפוש ו-AI מתקשים להבין מהר מהו כל צעד אם אין לו שם. תמיד תכניסו name ברור לכל HowToStep.

טעות 3, שימוש על תוכן לא פרוצדורלי

זאת הטעות הכי קטסטרופלית. אתם מוסיפים HowTo schema על מאמר "5 סיבות למה X", או על listicle "10 הסרטים הכי טובים". גוגל מזהה את זה כ-spam ויכול להעניש את העמוד. השתמשו ב-HowTo רק לתוכן פרוצדורלי אמיתי.

טעות 4, צעד אחד

HowTo עם step אחד הוא לא HowTo. זה הוראה. אם יש לכם רק פעולה אחת, השתמשו ב-Article schema, לא ב-HowTo.

טעות 5, image של placeholder

תמונה גנרית או stock photo שלא קשורה לתהליך. גוגל מנתח תמונות, וברגע שהוא רואה שהתמונה לא קשורה לתוכן, האות נפגע. השתמשו בתמונות אמיתיות של התהליך.

טעות 6, supply ו-tool שאינם נכונים

אם זה תהליך דיגיטלי (כמו הגדרת אפליקציה), אין supply או tool. אבל לפעמים אנשים ממציאים, "לפטופ", "חיבור אינטרנט". זה לא משמעותי. השאירו את ה-properties האלה ריקים אם אין משמעות אמיתית.

טעות 7, name שלא תואם ל-H1

name של HowTo צריך להיות זהה או דומה מאוד ל-H1 של העמוד. אם ה-H1 הוא "איך להכין חביתה ספרדית" וה-schema name הוא "מתכון חביתה", גוגל מתבלבל. תהיו עקביים.

עכשיו שיש לכם schema תקין, צריך לאמת אותו לפני שמעלים לפרוד. הכלי הסטנדרטי הוא Rich Results Test, נדבר עליו עכשיו. בלי אימות, אתם עלולים להעלות schema עם שגיאות שלא יעבדו בכלל, וגם לא תדעו על זה עד שתבדקו ב-Search Console חודש אחר כך.

✅ אימות עם Rich Results Test (step by step)

Rich Results Test הוא הכלי הרשמי של גוגל לאימות structured data. הוא חינמי, מהיר, וצריך להיות חלק ממכלול ההטמעה של כל schema. הנה איך משתמשים בו שלב אחרי שלב. אני מריץ אותו על כל עמוד עם schema, גם אם זה רק עדכון קטן. עדיף 30 שניות של בדיקה מאשר שבועות של schema שבור באוויר.

שלב 1, גישה לכלי

נכנסים ל-search.google.com/test/rich-results. אין צורך בהתחברות לחשבון, הכלי פתוח לכל.

שלב 2, הזנת URL או קוד

יש שתי אפשרויות. אם העמוד שלכם כבר באוויר, מזינים את ה-URL. אם אתם עדיין בפיתוח, יש להעתיק את ה-HTML המלא של העמוד (כולל ה-script tag של ה-JSON-LD) ולהדביק בלשונית "Code".

שלב 3, הרצה והמתנה

לוחצים "Test URL" או "Test Code". הכלי לוקח 10-30 שניות לסרוק. במהלך הזמן הזה הוא מאחזר את העמוד, מנתח את ה-JSON-LD, ובודק תאימות לסכמת schema.org.

שלב 4, קריאת התוצאות

הכלי מציג רשימה של structured data שנמצאו. עבור HowTo, אתם אמורים לראות "HowTo" עם מספר הצעדים שזוהו. בצד יוצגו השגיאות (אדום) או האזהרות (צהוב).

שלב 5, תיקון שגיאות

שגיאות נפוצות, "missing field name", "invalid value for totalTime", "step missing required property". כל שגיאה צריכה להיות מתוקנת. אזהרות הן פחות קריטיות אבל מומלץ לטפל בהן גם.

שלב 6, בדיקת תצוגה במובייל

הכלי מציג preview של איך ה-rich result יראה במובייל (כאמור, ב-desktop אין יותר HowTo rich result). זה לא הבטחה שגוגל יציג את זה, אבל זה מאשר שה-schema תקין מספיק כדי שאפשר היה להציג. אם ה-preview ריק או חסר, סימן שיש בעיה גם אם הכלי לא דיווח על שגיאה.

שלב 7, אימות חוזר אחרי שינויים

אחרי שתיקנתם שגיאות, מריצים שוב. ממשיכים עד ש-0 שגיאות. אזהרות אפשר להשאיר אם הן לא קריטיות, אבל עדיף לפתור גם אותן.

אחרי שיש schema תקין, אפשר להתחיל לחשוב על שילובים מתקדמים. הפרק הבא מראה איך לשלב HowTo עם FAQ ו-Article באותו @graph. השילוב הזה הוא הסטנדרט של עמוד pillar איכותי ב-2026, ובלעדיו אתם מפסידים הזדמנויות של הקשר נוסף עבור AI engines.

🔗 שילוב עם FAQ + Article schema באותו @graph (עם דוגמת קוד)

schema.org תומך ב-property שנקרא @graph, שמאפשר להחזיק כמה schemas שונים בתוך אותו script. זה מאפשר לבנות תיאור עשיר של העמוד, ש-AI engines אוהבים במיוחד. למידע מעמיק על מבנה schemas בכלל יש לי המדריך השלם לסכמות schema, וגם מבוא ל-schema.org.

המבנה של @graph

במקום script אחד עם schema אחד, אנחנו פותחים script עם property "@graph" שהוא array של schemas. כל schema פנימי הוא אובייקט בפני עצמו, ויכול להפנות לאחרים באמצעות @id.

למה זה חשוב

גוגל ו-AI מבינים שכל ה-schemas יחד מתארים את אותו עמוד. הם רואים את ה-Article schema, ה-HowTo schema, וה-FAQ schema כיחידה מקושרת. זה נותן הקשר עשיר הרבה יותר מאשר schema אחד מבודד.

דוגמת קוד מלאה

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Article",
      "@id": "https://example.co.il/wifi-fix/#article",
      "headline": "איך לפתור בעיה של WiFi איטי בבית",
      "author": {
        "@type": "Person",
        "name": "שמוליק דורינבאום",
        "url": "https://www.shmul.co.il/אודות/"
      },
      "datePublished": "2026-05-30",
      "image": "https://example.co.il/images/wifi-fix.jpg"
    },
    {
      "@type": "HowTo",
      "@id": "https://example.co.il/wifi-fix/#howto",
      "name": "איך לפתור בעיה של WiFi איטי בבית",
      "totalTime": "PT30M",
      "step": [
        {
          "@type": "HowToStep",
          "name": "בדיקת מהירות",
          "text": "מריצים מבחן מהירות באתר fast.com."
        },
        {
          "@type": "HowToStep",
          "name": "אתחול הראוטר",
          "text": "מנתקים את הראוטר מהחשמל ל-30 שניות."
        }
      ]
    },
    {
      "@type": "FAQPage",
      "@id": "https://example.co.il/wifi-fix/#faq",
      "mainEntity": [
        {
          "@type": "Question",
          "name": "כמה זמן לוקח לפתור בעיה של WiFi איטי?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "בדרך כלל 30 דקות לאבחון ופתרון בסיסי. אם נדרשת החלפת ציוד, עד יום."
          }
        },
        {
          "@type": "Question",
          "name": "האם צריך לקרוא לטכנאי?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "רוב הבעיות אפשר לפתור עצמאית בעזרת מדריך זה. רק במקרים של תקלת חומרה צריך טכנאי."
          }
        }
      ]
    }
  ]
}
</script>

שילוב עם schemas נוספים כמו BreadcrumbList, Organization schema, ו-AggregateRating יכול להעצים עוד יותר את ה-graph. נסיים עם צ'ק ליסט הטמעה מלא, וגם workflow מעשי שתוכלו לעקוב אחריו בכל פעם שאתם מטמיעים HowTo schema על עמוד חדש.

📋 צ'ק ליסט מלא + workflow הטמעה ב-10 צעדים

סיכום מעשי לכל מי שעובד עם HowTo schema על דף ספציפי. עברו על הצ'ק ליסט הזה לפני כל הטמעה, ותחסכו לעצמכם את רוב הבעיות שראינו במהלך המדריך.

צ'ק ליסט הטמעה

• וידוא שהתוכן הוא באמת פרוצדורלי (תהליך עם צעדים ותוצאה מדידה)
• וידוא שיש לפחות 2 צעדים, אחרת לא HowTo
• name של HowTo זהה או דומה ל-H1 של העמוד
• כל HowToStep מכיל name + text במינימום
• totalTime ב-ISO 8601 format ולא מזויף
• image של התהליך כולו ושל כל צעד, אם רלוונטי
• supply ו-tool רק אם רלוונטיים, אל תכניסו לבד
• estimatedCost עם currency נכון לקהל היעד
• JSON-LD תקין סינטקטית (השתמשו ב-JSONLint או דומה)
• אימות עם Rich Results Test, 0 שגיאות

workflow הטמעה ב-10 צעדים

הנה התהליך שאני עובר אותו עם כל לקוח שמטמיע HowTo schema, צעד אחרי צעד.

1. זיהוי תוכן מתאים, סורקים את האתר ומאתרים עמודים פרוצדורליים אמיתיים
2. קביעת מבנה, מחליטים על name, רשימת צעדים, totalTime
3. איסוף assets, תמונות לכל צעד, פרטי supply ו-tool
4. כתיבת JSON-LD, בונים את הקוד מאפס לפי הסטנדרט
5. אימות סינטקטי, JSONLint או Schema.org Validator
6. אימות Rich Results, Rich Results Test של גוגל
7. הטמעה בעמוד, מכניסים את ה-script לתוך head או לפני סגירת body
8. אימות בפרוד, בודקים שוב את ה-URL החי ב-Rich Results Test
9. הוספה ל-Search Console, מבקשים reindexing דרך URL Inspection
10. מעקב Coverage, ב-Search Console בודקים שה-Enhancements מזהים את ה-HowTo

זאת המתודולוגיה השלמה שאני מיישם אצל לקוחות. עברו את התהליך פעם אחת על עמוד אחד, ותראו שבעמודים הבאים זה הופך לאוטומטי. ההשקעה הראשונית של 1-2 שעות משתלמת לאורך כל חיי העמוד, וזה לא ייעלם גם אם גוגל ימשיך לשנות את ה-SERP. AI engines רק מתחזקים, וצריך תוכן עם structured data איכותי כדי להופיע שם.

❓ שאלות נפוצות