diff --git a/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.css b/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.css
index 167a43ed4..b41612230 100644
--- a/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.css
+++ b/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.css
@@ -1,3 +1,13 @@
+/* Section */
+
+.spring-bones-header-label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  padding-right: 10px;
+}
+
 .spring-bones-section {
   margin-top: 12px;
   display: flex;
@@ -6,6 +16,28 @@
   --base-gray: #5e5b67;
 }
 
+.bone-icon {
+  width: 12px;
+  height: 12px;
+  background: url('../../../../icons/bone.svg') no-repeat;
+  object-fit: contain;
+}
+
+/* Spring Bone Counter */
+
+.spring-bones-counter {
+  font-size: 12px;
+  color: var(--secondary-text);
+  margin-left: auto;
+  display: flex;
+  align-items: center;
+  gap: 2px;
+}
+
+.spring-bones-counter .bone-icon {
+  opacity: 0.3;
+}
+
 /* Spring Bone Card */
 
 .dcl.box.spring-bone-card {
@@ -148,9 +180,11 @@
 }
 
 /* Bone Hierarchy Picker */
-.bone-hierarchy-picker {
+.bone-hierarchy-picker.MuiPaper-root {
   overflow: auto;
-  width: calc(var(--item-editor-panel-width) - 16px);
+  min-width: calc(var(--item-editor-panel-width) - 16px);
+  max-width: calc(var(--item-editor-panel-width) * 1.5);
+  width: max-content;
   height: 430px;
   padding: 8px 0;
   border-radius: 8px;
@@ -168,7 +202,7 @@
 }
 
 .bone-tree-node.disabled {
-  color: #a0a0a0;
+  color: #a09ba8;
 }
 
 .bone-tree-node.children {
@@ -179,6 +213,14 @@
   background: rgba(0, 0, 0, 0.15);
 }
 
+.bone-tree-node .bone-icon {
+  margin: 0 2px;
+}
+
+.bone-tree-node.disabled .bone-icon {
+  opacity: 0.4;
+}
+
 .bone-tree-chevron.Icon {
   flex-shrink: 0;
   margin: 2px 5px;
@@ -203,6 +245,12 @@
   min-width: 100px;
 }
 
+.bone-tree-name .children-count {
+  font-size: 11px;
+  color: #a09ba8;
+  margin-left: 4px;
+}
+
 .bone-tree-checkmark {
   margin-left: auto;
   flex-shrink: 0;
diff --git a/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.tsx b/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.tsx
index 450716607..8695640a7 100644
--- a/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.tsx
+++ b/src/components/ItemEditorPage/RightPanel/SpringBonesSection/SpringBonesSection.tsx
@@ -4,6 +4,17 @@ import { Box, Dropdown, Header } from 'decentraland-ui'
 import { Button, Popover, Slider } from 'decentraland-ui2'
 import { t } from 'decentraland-dapps/dist/modules/translation/utils'
 import { BoneNode, SpringBoneParams } from 'modules/editor/types'
+import {
+  MAX_SPRING_BONES,
+  SPRING_BONE_STIFFNESS_MIN,
+  SPRING_BONE_STIFFNESS_MAX,
+  SPRING_BONE_GRAVITY_POWER_MIN,
+  SPRING_BONE_GRAVITY_POWER_MAX,
+  SPRING_BONE_DRAG_MIN,
+  SPRING_BONE_DRAG_MAX,
+  SPRING_BONE_GRAVITY_DIR_MIN,
+  SPRING_BONE_GRAVITY_DIR_MAX
+} from 'lib/glbValidation/constants'
 import Collapsable from 'components/Collapsable'
 import Icon from 'components/Icon'
 import CheckIcon from 'icons/check.svg'
@@ -20,8 +31,10 @@ function BoneTreeNode({
   expanded,
   onToggle,
   disableType,
+  boneSubtreeSizes,
   selected,
-  onSelect
+  onSelect,
+  selectLabel
 }: {
   bone: BoneNode
   boneMap: Map<number, BoneNode>
@@ -29,6 +42,8 @@ function BoneTreeNode({
   expanded: Set<number>
   selected?: Set<string>
   disableType?: BoneNode['type']
+  boneSubtreeSizes?: Map<string, number>
+  selectLabel?: string
   onToggle: (nodeId: number) => void
   onSelect: (bone: BoneNode) => void
 }) {
@@ -45,8 +60,12 @@ function BoneTreeNode({
         onClick={hasChildren ? () => onToggle(bone.nodeId) : undefined}
       >
         <Icon name="chevron-right" className={classNames('bone-tree-chevron', { expanded: isExpanded, hidden: !hasChildren })} />
+        {bone.type === 'spring' && <span className="bone-icon" />}
         <span className="bone-tree-name" title={bone.name}>
           {bone.name}
+          {bone.type === 'spring' && boneSubtreeSizes && (boneSubtreeSizes.get(bone.name) ?? 0) > 1 && (
+            <span className="children-count">({boneSubtreeSizes.get(bone.name)})</span>
+          )}
         </span>
         {isSelected && <img src={CheckIcon} className="bone-tree-checkmark" alt="Already added" />}
         {!isDisabled && (
@@ -58,7 +77,7 @@ function BoneTreeNode({
               onSelect(bone)
             }}
           >
-            {t('item_editor.right_panel.spring_bones.actions.select')}
+            {selectLabel || t('item_editor.right_panel.spring_bones.actions.select')}
           </Button>
         )}
       </div>
@@ -75,6 +94,8 @@ function BoneTreeNode({
               depth={depth + 1}
               expanded={expanded}
               selected={selected}
+              selectLabel={selectLabel}
+              boneSubtreeSizes={boneSubtreeSizes}
               disableType={disableType}
               onToggle={onToggle}
               onSelect={onSelect}
@@ -91,6 +112,8 @@ function BoneHierarchyPicker({
   selected,
   disableType,
   anchorEl,
+  boneSubtreeSizes,
+  selectLabel,
   onSelect,
   onClose
 }: {
@@ -99,6 +122,8 @@ function BoneHierarchyPicker({
   selected?: Set<string>
   disableType?: BoneNode['type']
   anchorEl: HTMLElement | null
+  boneSubtreeSizes?: Map<string, number>
+  selectLabel?: string
   onSelect: (bone: BoneNode) => void
   onClose: () => void
 }) {
@@ -142,7 +167,9 @@ function BoneHierarchyPicker({
           depth={0}
           expanded={expanded}
           onToggle={handleToggle}
+          boneSubtreeSizes={boneSubtreeSizes}
           selected={selected}
+          selectLabel={selectLabel}
           disableType={disableType}
           onSelect={onSelect}
         />
@@ -151,6 +178,16 @@ function BoneHierarchyPicker({
   )
 }
 
+function BonesCounter({ count, limit }: { count: number; limit?: number }) {
+  return (
+    <span className="spring-bones-counter">
+      <span className="bone-icon" />
+      {count}
+      {limit !== undefined && `/${limit}`}
+    </span>
+  )
+}
+
 function InputNumber({ max, min, value, onChange }: { max?: number; min?: number; value: number; onChange: (value: number) => void }) {
   const [localValue, setLocalValue] = useState(`${value}`)
 
@@ -298,6 +335,7 @@ function CenterDropdown({
 function SpringBoneCard({
   nodeName,
   params,
+  boneCount,
   allBones,
   onParamChange,
   onDelete,
@@ -306,6 +344,7 @@ function SpringBoneCard({
 }: {
   nodeName: string
   params: SpringBoneParams
+  boneCount: number
   allBones: BoneNode[]
   onParamChange: (field: keyof SpringBoneParams, value: SpringBoneParams[typeof field]) => void
   onDelete: () => void
@@ -321,6 +360,7 @@ function SpringBoneCard({
         <Header className="spring-bone-card-header" onClick={() => setIsExpanded(prev => !prev)}>
           <Icon name="chevron-right" className="spring-bone-chevron" />
           <h6 className="spring-bone-name">{nodeName}</h6>
+          <BonesCounter count={boneCount} />
 
           <Dropdown trigger={<img src={MenuIcon} className="spring-bone-card-menu" alt="Actions" />} inline direction="left">
             <Dropdown.Menu>
@@ -341,31 +381,31 @@ function SpringBoneCard({
           <SliderInput
             label={t('item_editor.right_panel.spring_bones.stiffness')}
             value={params.stiffness}
-            min={0}
-            max={5}
+            min={SPRING_BONE_STIFFNESS_MIN}
+            max={SPRING_BONE_STIFFNESS_MAX}
             step={0.01}
             onChange={v => onParamChange('stiffness', v)}
           />
           <SliderInput
             label={t('item_editor.right_panel.spring_bones.gravity_power')}
             value={params.gravityPower}
-            min={0}
-            max={10}
+            min={SPRING_BONE_GRAVITY_POWER_MIN}
+            max={SPRING_BONE_GRAVITY_POWER_MAX}
             step={0.01}
             onChange={v => onParamChange('gravityPower', v)}
           />
           <Vec3Input
             label={t('item_editor.right_panel.spring_bones.gravity_dir')}
             value={params.gravityDir}
-            min={-10}
-            max={10}
+            min={SPRING_BONE_GRAVITY_DIR_MIN}
+            max={SPRING_BONE_GRAVITY_DIR_MAX}
             onChange={v => onParamChange('gravityDir', v)}
           />
           <SliderInput
             label={t('item_editor.right_panel.spring_bones.drag_force')}
             value={params.drag}
-            min={0}
-            max={1}
+            min={SPRING_BONE_DRAG_MIN}
+            max={SPRING_BONE_DRAG_MAX}
             step={0.01}
             onChange={v => onParamChange('drag', v)}
           />
@@ -394,19 +434,42 @@ export default function SpringBonesSection({
   const springBones: SpringBoneNode[] = useMemo(() => bones.filter(b => b.type === 'spring'), [bones])
   const selectedSpringBoneNames: Set<string> = useMemo(() => new Set(Object.keys(springBoneParams)), [springBoneParams])
 
+  /** Map of spring bone name to the count of bones in its subtree (simulation cost) */
+  const boneSubtreeSizes: Map<string, number> = useMemo(() => {
+    const boneMap = new Map<number, BoneNode>(bones.map(b => [b.nodeId, b]))
+
+    function countSubtreeSize(nodeId: number): number {
+      const bone = boneMap.get(nodeId)
+      if (!bone) return 0
+      let count = 1
+      for (const childId of bone.children) {
+        count += countSubtreeSize(childId)
+      }
+      return count
+    }
+
+    return new Map(springBones.map(b => [b.name, countSubtreeSize(b.nodeId)]))
+  }, [bones, springBones])
+
   /** Sort spring bone params by node ID */
   const sortedSpringBoneParams: [string, SpringBoneParams][] = useMemo(() => {
-    const springBoneNamesToNodeId = springBones.reduce((map, bone) => {
-      map[bone.name] = bone.nodeId
-      return map
-    }, {} as Record<string, number>)
+    const springBoneNameToNodeId = new Map<string, number>(springBones.map(bone => [bone.name, bone.nodeId]))
     return Object.entries(springBoneParams).sort(([boneNameA], [boneNameB]) => {
-      const nodeIdA = springBoneNamesToNodeId[boneNameA] ?? 0
-      const nodeIdB = springBoneNamesToNodeId[boneNameB] ?? 0
-      return nodeIdA - nodeIdB // Inverse order, node ids are assigned from the leaf up, we want to show root bones first.
+      const nodeIdA = springBoneNameToNodeId.get(boneNameA) ?? 0
+      const nodeIdB = springBoneNameToNodeId.get(boneNameB) ?? 0
+      return nodeIdA - nodeIdB // Sort by node ID ascending (root bones have lower IDs).
     })
   }, [springBoneParams])
 
+  const configuredBonesCount = useMemo(() => {
+    let total = 0
+    for (const name of Object.keys(springBoneParams)) {
+      total += boneSubtreeSizes.get(name) ?? 1
+    }
+    return total
+  }, [springBoneParams, boneSubtreeSizes])
+  const canAddMore = sortedSpringBoneParams.length < springBones.length && configuredBonesCount < MAX_SPRING_BONES
+
   const handleSelectBone = useCallback(
     (bone: BoneNode) => {
       onAddSpringBoneParams(bone.name)
@@ -428,13 +491,21 @@ export default function SpringBonesSection({
   if (springBones.length === 0) return null
 
   return (
-    <Collapsable label={t('item_editor.right_panel.spring_bones.title')}>
+    <Collapsable
+      label={
+        <div className="spring-bones-header-label">
+          {t('item_editor.right_panel.spring_bones.title')}
+          <BonesCounter count={configuredBonesCount} limit={MAX_SPRING_BONES} />
+        </div>
+      }
+    >
       <div className="spring-bones-section">
         {sortedSpringBoneParams.map(([nodeName, params]) => (
           <SpringBoneCard
             key={nodeName}
             nodeName={nodeName}
             params={params}
+            boneCount={boneSubtreeSizes.get(nodeName) ?? 1}
             allBones={bones}
             onParamChange={(field, value) => onParamChange(nodeName, field, value)}
             onDelete={() => onDeleteSpringBoneParams(nodeName)}
@@ -442,7 +513,7 @@ export default function SpringBonesSection({
             onPaste={copiedParams ? () => handlePasteParams(nodeName) : null}
           />
         ))}
-        {sortedSpringBoneParams.length < springBones.length && (
+        {canAddMore && (
           <div className="spring-bone-add-box">
             <Button
               className="spring-bone-add-button"
@@ -459,6 +530,8 @@ export default function SpringBonesSection({
               anchorEl={pickerAnchorRef.current}
               selected={selectedSpringBoneNames}
               disableType="avatar"
+              selectLabel={t('item_editor.right_panel.spring_bones.actions.add')}
+              boneSubtreeSizes={boneSubtreeSizes}
               onSelect={handleSelectBone}
               onClose={() => setShowBonePicker(false)}
             />
diff --git a/src/icons/bone.svg b/src/icons/bone.svg
new file mode 100644
index 000000000..2322342a7
--- /dev/null
+++ b/src/icons/bone.svg
@@ -0,0 +1,7 @@
+<svg width="12" height="12" viewBox="0 0 21 21" fill="none" xmlns="http://www.w3.org/2000/svg">
+<circle cx="3.09447" cy="14.7048" r="2.18812" transform="rotate(-45 3.09447 14.7048)" fill="white"/>
+<circle cx="5.89183" cy="17.5026" r="2.18812" transform="rotate(-45 5.89183 17.5026)" fill="white"/>
+<circle cx="14.7048" cy="3.09441" r="2.18812" transform="rotate(-45 14.7048 3.09441)" fill="white"/>
+<circle cx="17.5022" cy="5.89177" r="2.18812" transform="rotate(-45 17.5022 5.89177)" fill="white"/>
+<rect x="3.54614" y="14.9216" width="16.087" height="3.01084" transform="rotate(-45 3.54614 14.9216)" fill="white"/>
+</svg>
diff --git a/src/lib/glbValidation/constants.ts b/src/lib/glbValidation/constants.ts
index 50421a51d..ae86b16cb 100644
--- a/src/lib/glbValidation/constants.ts
+++ b/src/lib/glbValidation/constants.ts
@@ -111,3 +111,17 @@ export const PROP_ARMATURE_NAME = 'Armature_Prop'
 
 /** Accepted audio file extensions for emote sound effects. */
 export const VALID_AUDIO_EXTENSIONS = ['.mp3', '.ogg']
+
+/** Maximum number of spring bones allowed per wearable representation. */
+export const MAX_SPRING_BONES = 15
+
+/** Spring bone parameter ranges (from @dcl/schemas). */
+export const SPRING_BONE_STIFFNESS_MIN = 0
+export const SPRING_BONE_STIFFNESS_MAX = 5
+export const SPRING_BONE_GRAVITY_POWER_MIN = 0
+export const SPRING_BONE_GRAVITY_POWER_MAX = 10
+export const SPRING_BONE_DRAG_MIN = 0
+export const SPRING_BONE_DRAG_MAX = 1
+export const SPRING_BONE_GRAVITY_DIR_LENGTH = 3
+export const SPRING_BONE_GRAVITY_DIR_MIN = -10
+export const SPRING_BONE_GRAVITY_DIR_MAX = 10
diff --git a/src/lib/glbValidation/index.ts b/src/lib/glbValidation/index.ts
index 49e8d96ba..7a3d0e2a2 100644
--- a/src/lib/glbValidation/index.ts
+++ b/src/lib/glbValidation/index.ts
@@ -11,7 +11,8 @@ import {
   validateNoLeafBones,
   validateNoDisallowedObjects,
   validateMaterialNaming,
-  validateNoNonDeformBones
+  validateNoNonDeformBones,
+  validateSpringBones
 } from './wearableValidators'
 import {
   validateEmoteFrameRate,
@@ -53,7 +54,8 @@ export async function validateWearableGLTF(gltf: GLTF, category?: WearableCatego
     validateNoLeafBones(Three, scene),
     validateNoNonDeformBones(Three, scene),
     validateNoDisallowedObjects(Three, gltf),
-    validateMaterialNaming(Three, scene, category)
+    validateMaterialNaming(Three, scene, category),
+    validateSpringBones(gltf)
   ]
 
   const issues = issueArrays.flat()
diff --git a/src/lib/glbValidation/wearableValidators.spec.ts b/src/lib/glbValidation/wearableValidators.spec.ts
index 18914c5af..d01be3afc 100644
--- a/src/lib/glbValidation/wearableValidators.spec.ts
+++ b/src/lib/glbValidation/wearableValidators.spec.ts
@@ -11,9 +11,17 @@ import {
   validateNoLeafBones,
   validateNoDisallowedObjects,
   validateMaterialNaming,
-  validateNoNonDeformBones
+  validateNoNonDeformBones,
+  validateSpringBones
 } from './wearableValidators'
-import { MAX_MATERIALS_DEFAULT, MAX_MATERIALS_SKIN, MAX_TEXTURES_DEFAULT, AVATAR_SKIN_MAT, getEffectiveTriangleLimit } from './constants'
+import {
+  MAX_MATERIALS_DEFAULT,
+  MAX_MATERIALS_SKIN,
+  MAX_TEXTURES_DEFAULT,
+  AVATAR_SKIN_MAT,
+  MAX_SPRING_BONES,
+  getEffectiveTriangleLimit
+} from './constants'
 
 // Mock Three.js classes that support instanceof checks.
 function createMockThree() {
@@ -115,6 +123,32 @@ function createMeshWithTexture(Three: MockThree, matName: string, texUuid: strin
   return mesh
 }
 
+function createGltfWithNodes(nodes: Array<{ name: string; extensions?: Record<string, unknown> }>): GLTF {
+  return {
+    parser: {
+      json: { nodes }
+    }
+  } as unknown as GLTF
+}
+
+function createSpringBoneNode(
+  name: string,
+  params?: {
+    stiffness?: number
+    gravityPower?: number
+    drag?: number
+    gravityDir?: unknown
+  }
+) {
+  if (!params) return { name }
+  return {
+    name,
+    extensions: {
+      DCL_spring_bone_joint: params
+    }
+  }
+}
+
 describe('validateTriangleCounts', () => {
   let Three: MockThree
 
@@ -732,6 +766,167 @@ describe('validateMaterialNaming', () => {
   })
 })
 
+describe('validateSpringBones', () => {
+  it('returns no issues when there are 0 spring bones', () => {
+    const gltf = createGltfWithNodes([{ name: 'Armature' }, { name: 'Head' }])
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('returns no issues when spring bone count is at the limit', () => {
+    const nodes = Array.from({ length: MAX_SPRING_BONES }, (_, i) => ({
+      name: `Hair.springbone.${i}`
+    }))
+    const gltf = createGltfWithNodes(nodes)
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('returns a WARNING when spring bone count exceeds the limit', () => {
+    const nodes = Array.from({ length: MAX_SPRING_BONES + 1 }, (_, i) => ({
+      name: `Hair.springbone.${i}`
+    }))
+    const gltf = createGltfWithNodes(nodes)
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].code).toBe('SPRING_BONE_COUNT_EXCEEDED')
+    expect(issues[0].severity).toBe(ValidationSeverity.WARNING)
+    expect(issues[0].messageParams).toEqual({ count: MAX_SPRING_BONES + 1, limit: MAX_SPRING_BONES })
+  })
+
+  it('identifies spring bones case-insensitively', () => {
+    const gltf = createGltfWithNodes([{ name: 'Hair.SpringBone.000' }, { name: 'SPRINGBONE_tail' }, { name: 'NotABone' }])
+    // 2 spring bones, under limit
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('returns empty issues when gltf.parser is undefined', () => {
+    const gltf = {} as unknown as GLTF
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('does not count nodes with extension but without springbone name', () => {
+    const gltf = createGltfWithNodes([
+      {
+        name: 'RegularBone',
+        extensions: { DCL_spring_bone_joint: { stiffness: 2 } }
+      }
+    ])
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('counts nodes with springbone name but no extension', () => {
+    const nodes = Array.from({ length: MAX_SPRING_BONES + 1 }, (_, i) => ({
+      name: `springbone_${i}`
+    }))
+    const gltf = createGltfWithNodes(nodes)
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].code).toBe('SPRING_BONE_COUNT_EXCEEDED')
+  })
+
+  // --- Parameter validation ---
+
+  it('returns no issues for valid params', () => {
+    const gltf = createGltfWithNodes([
+      createSpringBoneNode('Hair.springbone.000', {
+        stiffness: 2,
+        gravityPower: 5,
+        drag: 0.5,
+        gravityDir: [0, -1, 0]
+      })
+    ])
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('returns no issues when spring bone has no extension', () => {
+    const gltf = createGltfWithNodes([createSpringBoneNode('Hair.springbone.000')])
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('warns when stiffness exceeds max', () => {
+    const gltf = createGltfWithNodes([createSpringBoneNode('Hair.springbone.000', { stiffness: 6 })])
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].code).toBe('SPRING_BONE_PARAM_OUT_OF_RANGE')
+    expect(issues[0].messageParams?.paramName).toBe('stiffness')
+  })
+
+  it('warns when gravityPower is negative', () => {
+    const gltf = createGltfWithNodes([createSpringBoneNode('Hair.springbone.000', { gravityPower: -1 })])
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].messageParams?.paramName).toBe('gravityPower')
+  })
+
+  it('warns when drag exceeds max', () => {
+    const gltf = createGltfWithNodes([createSpringBoneNode('Hair.springbone.000', { drag: 1.5 })])
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].messageParams?.paramName).toBe('drag')
+  })
+
+  it('warns when gravityDir has only 2 numbers', () => {
+    const gltf = createGltfWithNodes([createSpringBoneNode('Hair.springbone.000', { gravityDir: [0, -1] })])
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].code).toBe('SPRING_BONE_INVALID_GRAVITY_DIR')
+  })
+
+  it('warns when gravityDir is not an array', () => {
+    const gltf = createGltfWithNodes([createSpringBoneNode('Hair.springbone.000', { gravityDir: 'not an array' as any })])
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].code).toBe('SPRING_BONE_INVALID_GRAVITY_DIR')
+  })
+
+  it('warns when gravityDir components are out of range', () => {
+    const gltf = createGltfWithNodes([createSpringBoneNode('Hair.springbone.000', { gravityDir: [0, -20, 0] })])
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(1)
+    expect(issues[0].code).toBe('SPRING_BONE_PARAM_OUT_OF_RANGE')
+    expect(issues[0].messageParams?.paramName).toBe('gravityDir')
+  })
+
+  it('returns empty issues when gltf.parser is undefined', () => {
+    const gltf = {} as unknown as GLTF
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('skips nodes that are not spring bones', () => {
+    const gltf = createGltfWithNodes([
+      {
+        name: 'RegularBone',
+        extensions: { DCL_spring_bone_joint: { stiffness: 99 } }
+      }
+    ])
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+
+  it('reports multiple issues for multiple invalid params on same bone', () => {
+    const gltf = createGltfWithNodes([
+      createSpringBoneNode('Hair.springbone.000', {
+        stiffness: 6,
+        gravityPower: 11,
+        drag: 2
+      })
+    ])
+    const issues = validateSpringBones(gltf)
+    expect(issues).toHaveLength(3)
+    expect(issues.map(i => i.messageParams?.paramName)).toEqual(['stiffness', 'gravityPower', 'drag'])
+  })
+
+  it('validates params at boundary values (min/max)', () => {
+    const gltf = createGltfWithNodes([
+      createSpringBoneNode('Hair.springbone.000', {
+        stiffness: 0,
+        gravityPower: 10,
+        drag: 1,
+        gravityDir: [0, -1, 0]
+      })
+    ])
+    expect(validateSpringBones(gltf)).toEqual([])
+  })
+})
+
 // --- Edge case tests ---
 
 describe('edge cases', () => {
diff --git a/src/lib/glbValidation/wearableValidators.ts b/src/lib/glbValidation/wearableValidators.ts
index a10f4890c..73f967aeb 100644
--- a/src/lib/glbValidation/wearableValidators.ts
+++ b/src/lib/glbValidation/wearableValidators.ts
@@ -1,5 +1,6 @@
 import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader'
 import { WearableCategory } from '@dcl/schemas'
+import { isSpringBoneName, DCL_SPRING_BONE_EXTENSION } from 'lib/springBones'
 import { ValidationIssue, ValidationSeverity } from './types'
 import {
   getEffectiveTriangleLimit,
@@ -11,7 +12,16 @@ import {
   FACIAL_CATEGORIES,
   MAX_BONE_INFLUENCES_PER_VERTEX,
   AVATAR_SKIN_MAT,
-  FORBIDDEN_MATERIAL_PATTERNS
+  FORBIDDEN_MATERIAL_PATTERNS,
+  MAX_SPRING_BONES,
+  SPRING_BONE_STIFFNESS_MIN,
+  SPRING_BONE_STIFFNESS_MAX,
+  SPRING_BONE_GRAVITY_POWER_MIN,
+  SPRING_BONE_GRAVITY_POWER_MAX,
+  SPRING_BONE_DRAG_MIN,
+  SPRING_BONE_DRAG_MAX,
+  SPRING_BONE_GRAVITY_DIR_MIN,
+  SPRING_BONE_GRAVITY_DIR_MAX
 } from './constants'
 
 type ThreeModules = typeof import('three')
@@ -368,3 +378,113 @@ export function validateMaterialNaming(Three: ThreeModules, scene: THREE.Scene,
 
   return issues
 }
+
+// ── Spring bone validators ──────────────────────────────────────────────
+
+type GltfJsonNode = {
+  name?: string
+  extensions?: Record<string, unknown>
+}
+
+/** Typed wrapper for the undocumented Three.js GLTFLoader parser internal. */
+type GltfWithParser = GLTF & {
+  parser?: { json?: { nodes?: GltfJsonNode[] } }
+}
+
+function getGltfJsonNodes(gltf: GLTF): GltfJsonNode[] | null {
+  const json = (gltf as GltfWithParser).parser?.json
+  if (!json || !Array.isArray(json.nodes)) {
+    // parser.json is an undocumented Three.js internal — warn if absent so
+    // silent validation bypass is detectable after a Three.js upgrade.
+    if ((gltf as GltfWithParser).parser === undefined) {
+      console.warn('Spring bone validation: gltf.parser is unavailable — spring bone checks will be skipped.')
+    }
+    return null
+  }
+  return json.nodes
+}
+
+function checkNumericRange(
+  issues: ValidationIssue[],
+  boneName: string,
+  params: Record<string, unknown>,
+  paramName: string,
+  min: number,
+  max: number
+): void {
+  const value = params[paramName]
+  if (typeof value !== 'number') return
+  if (value < min || value > max) {
+    issues.push({
+      code: 'SPRING_BONE_PARAM_OUT_OF_RANGE',
+      severity: ValidationSeverity.WARNING,
+      messageKey: 'create_single_item_modal.error.glb_validation.spring_bone_param_out_of_range',
+      messageParams: { boneName, paramName, value, min, max }
+    })
+  }
+}
+
+/**
+ * Validates spring bone count and parameter ranges in a single pass.
+ * Checks that the number of spring bone nodes does not exceed the limit,
+ * and that DCL_spring_bone_joint extension params are within valid ranges.
+ */
+export function validateSpringBones(gltf: GLTF): ValidationIssue[] {
+  const nodes = getGltfJsonNodes(gltf)
+  if (!nodes) return []
+
+  const issues: ValidationIssue[] = []
+  let springBoneCount = 0
+
+  for (const node of nodes) {
+    if (!node.name || !isSpringBoneName(node.name)) continue
+    springBoneCount++
+
+    const ext = node.extensions?.[DCL_SPRING_BONE_EXTENSION]
+    if (!ext || typeof ext !== 'object') continue
+
+    const boneName = node.name
+    const params = ext as Record<string, unknown>
+
+    checkNumericRange(issues, boneName, params, 'stiffness', SPRING_BONE_STIFFNESS_MIN, SPRING_BONE_STIFFNESS_MAX)
+    checkNumericRange(issues, boneName, params, 'gravityPower', SPRING_BONE_GRAVITY_POWER_MIN, SPRING_BONE_GRAVITY_POWER_MAX)
+    checkNumericRange(issues, boneName, params, 'drag', SPRING_BONE_DRAG_MIN, SPRING_BONE_DRAG_MAX)
+
+    // Validate gravityDir structure and range
+    if ('gravityDir' in params) {
+      const gd = params.gravityDir
+      if (!Array.isArray(gd) || gd.length !== 3 || !gd.every((v: unknown) => typeof v === 'number')) {
+        issues.push({
+          code: 'SPRING_BONE_INVALID_GRAVITY_DIR',
+          severity: ValidationSeverity.WARNING,
+          messageKey: 'create_single_item_modal.error.glb_validation.spring_bone_invalid_gravity_dir',
+          messageParams: { boneName }
+        })
+      } else if (gd.some((v: number) => v < SPRING_BONE_GRAVITY_DIR_MIN || v > SPRING_BONE_GRAVITY_DIR_MAX)) {
+        issues.push({
+          code: 'SPRING_BONE_PARAM_OUT_OF_RANGE',
+          severity: ValidationSeverity.WARNING,
+          messageKey: 'create_single_item_modal.error.glb_validation.spring_bone_param_out_of_range',
+          messageParams: {
+            boneName,
+            paramName: 'gravityDir',
+            value: `[${gd.join(', ')}]`,
+            min: SPRING_BONE_GRAVITY_DIR_MIN,
+            max: SPRING_BONE_GRAVITY_DIR_MAX
+          }
+        })
+      }
+    }
+  }
+
+  if (springBoneCount > MAX_SPRING_BONES) {
+    issues.push({
+      code: 'SPRING_BONE_COUNT_EXCEEDED',
+      severity: ValidationSeverity.WARNING,
+      messageKey: 'create_single_item_modal.error.glb_validation.spring_bone_count_exceeded',
+      messageParams: { count: springBoneCount, limit: MAX_SPRING_BONES }
+    })
+  }
+
+  return issues
+}
diff --git a/src/lib/parseSpringBones.ts b/src/lib/parseSpringBones.ts
index dc1d40af6..86bd23fce 100644
--- a/src/lib/parseSpringBones.ts
+++ b/src/lib/parseSpringBones.ts
@@ -1,8 +1,8 @@
 import { BoneNode, SpringBoneParams } from 'modules/editor/types'
 import { extractGlbChunks } from 'lib/glbUtils'
+import { SPRING_BONE_PREFIX, DCL_SPRING_BONE_EXTENSION, isSpringBoneName } from 'lib/springBones'
 
-export const SPRING_BONE_PREFIX = 'springbone'
-export const DCL_SPRING_BONE_EXTENSION = 'DCL_spring_bone_joint'
+export { SPRING_BONE_PREFIX, DCL_SPRING_BONE_EXTENSION }
 
 export const DEFAULT_SPRING_BONE_PARAMS: SpringBoneParams = {
   stiffness: 2,
@@ -54,7 +54,7 @@ function parseParams(ext: GltfExtension): SpringBoneParams {
 }
 
 const isSpringBoneNode = (node: GltfNode): boolean => {
-  return !!node.name && node.name.toLowerCase().includes(SPRING_BONE_PREFIX)
+  return !!node.name && isSpringBoneName(node.name)
 }
 
 function getSpringBoneExtension(node: GltfNode): GltfExtension | null {
diff --git a/src/lib/springBones.ts b/src/lib/springBones.ts
new file mode 100644
index 000000000..fc9ebf7ea
--- /dev/null
+++ b/src/lib/springBones.ts
@@ -0,0 +1,12 @@
+/** Shared spring bone identification constants and utilities. */
+
+/** Name prefix used to identify spring bone nodes (case-insensitive). */
+export const SPRING_BONE_PREFIX = 'springbone'
+
+/** GLTF extension name for Decentraland spring bone joint data. */
+export const DCL_SPRING_BONE_EXTENSION = 'DCL_spring_bone_joint'
+
+/** Returns true if the node name identifies a spring bone (case-insensitive). */
+export function isSpringBoneName(name: string): boolean {
+  return name.toLowerCase().includes(SPRING_BONE_PREFIX)
+}
diff --git a/src/modules/translation/languages/en.json b/src/modules/translation/languages/en.json
index 490a9c95a..2a7c13e19 100644
--- a/src/modules/translation/languages/en.json
+++ b/src/modules/translation/languages/en.json
@@ -402,7 +402,10 @@
         "prop_armature_bones": "Prop armature has {count} bones, exceeding the limit of {limit}.",
         "armature_naming": "Unexpected armature names found: {names}. Avatar armature should be named 'Armature' and prop armature 'Armature_Prop'.",
         "animation_naming": "Animation clips should end with '_Avatar' or '_Prop' when props are present. Invalid names: {names}.",
-        "audio_format": "Audio file \"{name}\" has an unsupported format. Only .mp3 and .ogg are allowed."
+        "audio_format": "Audio file \"{name}\" has an unsupported format. Only .mp3 and .ogg are allowed.",
+        "spring_bone_count_exceeded": "This model has {count} spring bones (maximum: {limit}). Reduce the number of spring bone nodes in your 3D editor and re-upload.",
+        "spring_bone_param_out_of_range": "Spring bone \"{boneName}\" has {paramName} value {value}, outside the allowed range ({min}–{max}).",
+        "spring_bone_invalid_gravity_dir": "Spring bone \"{boneName}\" has an invalid gravityDir (expected exactly 3 numbers)."
       }
     },
     "emote_notice": "Emotes are available for all body shapes.",
@@ -2212,6 +2215,7 @@
         "center_none": "None",
         "actions": {
           "select": "Select",
+          "add": "Add",
           "add_bone": "Add a Bone",
           "remove_bone": "Remove Bone",
           "copy_params": "Copy Parameters",
diff --git a/src/modules/translation/languages/es.json b/src/modules/translation/languages/es.json
index 9c933c4f4..4144c5480 100644
--- a/src/modules/translation/languages/es.json
+++ b/src/modules/translation/languages/es.json
@@ -401,7 +401,10 @@
         "prop_armature_bones": "La armadura del prop tiene {count} huesos, superando el límite de {limit}.",
         "armature_naming": "Se encontraron nombres de armadura inesperados: {names}. La armadura del avatar debe llamarse 'Armature' y la del prop 'Armature_Prop'.",
         "animation_naming": "Los clips de animación deben terminar en '_Avatar' o '_Prop' cuando hay props. Nombres inválidos: {names}.",
-        "audio_format": "El archivo de audio \"{name}\" tiene un formato no soportado. Solo se permiten .mp3 y .ogg."
+        "audio_format": "El archivo de audio \"{name}\" tiene un formato no soportado. Solo se permiten .mp3 y .ogg.",
+        "spring_bone_count_exceeded": "Este modelo tiene {count} spring bones (máximo: {limit}). Reduce la cantidad de nodos de spring bones en tu editor 3D y vuelve a subir el archivo.",
+        "spring_bone_param_out_of_range": "El spring bone \"{boneName}\" tiene un valor de {paramName} de {value}, fuera del rango permitido ({min}–{max}).",
+        "spring_bone_invalid_gravity_dir": "El spring bone \"{boneName}\" tiene un gravityDir inválido (se esperan exactamente 3 números)."
       }
     },
     "emote_notice": "Las animaciones estan disponibles para todos los cuerpos.",
@@ -2230,6 +2233,7 @@
         "center_none": "Ninguno",
         "actions": {
           "select": "Seleccionar",
+          "add": "Agregar",
           "add_bone": "Agregar un Hueso",
           "remove_bone": "Eliminar Hueso",
           "copy_params": "Copiar Parámetros",
diff --git a/src/modules/translation/languages/zh.json b/src/modules/translation/languages/zh.json
index 5bc07b6bd..fba73b946 100644
--- a/src/modules/translation/languages/zh.json
+++ b/src/modules/translation/languages/zh.json
@@ -395,7 +395,10 @@
         "prop_armature_bones": "道具骨架有 {count} 个骨骼，超过了限制 {limit}。",
         "armature_naming": "发现意外的骨架名称：{names}。角色骨架应命名为 'Armature'，道具骨架应命名为 'Armature_Prop'。",
         "animation_naming": "当存在道具时，动画片段应以 '_Avatar' 或 '_Prop' 结尾。无效名称：{names}。",
-        "audio_format": "音频文件 \"{name}\" 的格式不受支持。仅允许 .mp3 和 .ogg 格式。"
+        "audio_format": "音频文件 \"{name}\" 的格式不受支持。仅允许 .mp3 和 .ogg 格式。",
+        "spring_bone_count_exceeded": "此模型有 {count} 个弹簧骨骼（最大值：{limit}）。请在 3D 编辑器中减少弹簧骨骼节点的数量，然后重新上传。",
+        "spring_bone_param_out_of_range": "弹簧骨骼 \"{boneName}\" 的 {paramName} 值为 {value}，超出了允许范围（{min}–{max}）。",
+        "spring_bone_invalid_gravity_dir": "弹簧骨骼 \"{boneName}\" 的 gravityDir 无效（需要恰好 3 个数字）。"
       }
     },
     "emote_notice": "表情适用于所有体型。",
@@ -2214,6 +2217,7 @@
         "center_none": "无",
         "actions": {
           "select": "选择",
+          "add": "添加",
           "add_bone": "添加骨骼",
           "remove_bone": "移除骨骼",
           "copy_params": "复制参数",