> ## Documentation Index
> Fetch the complete documentation index at: https://docs.learningcommons.org/llms.txt
> Use this file to discover all available pages before exploring further.
# Using crosswalks for standards comparison
> Learn how to use Knowledge Graph crosswalk data to compare standards between jurisdictions using Jaccard scores and learning components.
export const EarlyAccessCallout = ({children}) => ;
The API is in early access and is actively evolving. We will continue expanding it, and breaking changes may occur as we improve accuracy and reliability. Email [support@learningcommons.org](mailto:support@learningcommons.org) ↗ with your feedback or issues.
## What you'll do
In this tutorial, you'll learn how to use the crosswalk data in Knowledge Graph to compare standards between the Common Core State Standards (CCSSM) and state frameworks. These crosswalks can help you determine which state standards are most similar to a given CCSSM standard and understand the similarities and differences between the standards.
Crosswalks are evidence-based relationships between state standards and CCSSM standards, derived from overlapping sets of Learning Components (LCs). Each crosswalk includes similarity metrics, such as the Jaccard score and relative LC counts, to help you interpret how closely two standards align.
The diagram shows **crosswalks** only: state mathematics standards mapped to Common Core State Standards. Both endpoints are `StandardsFrameworkItem` (defined in [Academic standards](/knowledge-graph/entity-and-relationship-reference/academic-standards)). Direction is always state → CCSS, not between states. Edge properties include jaccard and LC counts; see [Standards crosswalks](/knowledge-graph/entity-and-relationship-reference/crosswalks).
**Example (New York → CCSS):** A **state standard** is a `StandardsFrameworkItem` from a state framework—e.g. *NY 3.NF.1 (Understand a fraction 1/b as the quantity formed by 1 part when a whole is partitioned into b equal parts)*. A **CCSS standard** is a `StandardsFrameworkItem` from Common Core Math—e.g. *3.NF.A.1*. A **hasStandardAlignment** edge connects them when they share at least one Learning Component; the edge has properties such as `jaccard` (e.g. 0.85), `stateLCCount`, `ccssLCCount`, `sharedLCCount`. So: NY 3.NF.1 -\[:hasStandardAlignment]-> 3.NF.A.1. Crosswalks are only state → CCSS (never state → state).
**Edge list (source → relationship → target):**
* `StandardsFrameworkItem` (state) → `hasStandardAlignment` → `StandardsFrameworkItem` (CCSS) (e.g. NY 3.NF.1 → 3.NF.A.1)
This tutorial walks through how to:
* Identify the closest state standards for a given CCSSM standard (focusing on Texas).
* Interpret alignment strength using Jaccard and LC counts.
* Retrieve detailed standards metadata to view comparison results.
* Inspect the shared learning components that support each alignment.
## What you'll need
* An API key generated in the [Learning Commons Platform](https://platform.learningcommons.org) ↗
* Your base URL from the Learning Commons Platform
* Node or Python (optional, for running code examples)
## STEP 1: Set up environment variables
1. Set up your environment variables for your API key and base URL:
```shell theme={null}
# .env
# Knowledge Graph API credentials - get these from the Learning Commons Portal
API_KEY=your_api_key_here
BASE_URL=https://api.learningcommons.org/knowledge-graph/v0
```
## STEP 2: Find the best-matching state standards for a CCSSM standard
To find the best state standard matches (focusing on Texas) for a CCSSM standard, we'll use the `/crosswalks` endpoint which automatically returns state standards that share learning components with your target CCSSM standard.
1. First, find the CCSSM standard you want to compare using the `/academic-standards/search` endpoint:
```shell cURL theme={null}
curl -X GET \
-H "x-api-key: YOUR_API_KEY" \
"https://api.learningcommons.org/knowledge-graph/v0/academic-standards/search?statementCode=6.EE.B.5&jurisdiction=Multi-State"
```
```python Python theme={null}
import os
import requests
api_key = os.getenv("API_KEY")
base_url = os.getenv("BASE_URL")
TARGET_CCSSM_STANDARD_CODE = "6.EE.B.5"
TARGET_CCSSM_JURISDICTION = "Multi-State"
headers = {"x-api-key": api_key}
# Find the CCSSM standard by its statement code and jurisdiction
search_response = requests.get(
f"{base_url}/academic-standards/search",
headers=headers,
params={
"statementCode": TARGET_CCSSM_STANDARD_CODE,
"jurisdiction": TARGET_CCSSM_JURISDICTION
}
)
search_result = search_response.json()
ccssm_standard = search_result[0] if search_result else None
if not ccssm_standard:
print(f'❌ CCSSM standard not found: {TARGET_CCSSM_STANDARD_CODE}')
else:
ccssm_standard_uuid = ccssm_standard['caseIdentifierUUID']
print(f'✅ Found CCSSM standard: {TARGET_CCSSM_STANDARD_CODE}')
print(f' Case UUID: {ccssm_standard_uuid}')
print(f' Description: {ccssm_standard["description"]}')
```
```javascript JavaScript theme={null}
const apiKey = process.env.API_KEY;
const baseUrl = process.env.BASE_URL;
const TARGET_CCSSM_STANDARD_CODE = "6.EE.B.5";
const TARGET_CCSSM_JURISDICTION = "Multi-State";
// Find the CCSSM standard by its statement code and jurisdiction
const searchResponse = await fetch(
`${baseUrl}/academic-standards/search?statementCode=${TARGET_CCSSM_STANDARD_CODE}&jurisdiction=${TARGET_CCSSM_JURISDICTION}`,
{
method: 'GET',
headers: { 'x-api-key': apiKey }
}
);
const searchResult = await searchResponse.json();
const ccssmStandard = searchResult[0] || null;
if (!ccssmStandard) {
console.log(`❌ CCSSM standard not found: ${TARGET_CCSSM_STANDARD_CODE}`);
} else {
const ccssmStandardUuid = ccssmStandard.caseIdentifierUUID;
console.log(`✅ Found CCSSM standard: ${TARGET_CCSSM_STANDARD_CODE}`);
console.log(` Case UUID: ${ccssmStandardUuid}`);
console.log(` Description: ${ccssmStandard.description}`);
}
```
This returns the standard with its `caseIdentifierUUID` that you'll use in the next step:
```json theme={null}
{
"caseIdentifierUUID": "6b9f74c0-d7cc-11e8-824f-0242ac160002",
"statementCode": "6.EE.B.5",
"description": "Understand solving an equation or inequality as a process of answering a question: which values from a specified set, if any, make the equation or inequality true? Use substitution to determine whether a given number in a specified set makes an equation or inequality true.",
"jurisdiction": "Multi-State"
}
```
2. Use the `/crosswalks` endpoint to get Texas standards that align with this CCSSM standard:
```shell cURL theme={null}
# Replace CCSSM_UUID with the caseIdentifierUUID from the previous step
curl -X GET \
-H "x-api-key: YOUR_API_KEY" \
"https://api.learningcommons.org/knowledge-graph/v0/academic-standards/6b9f74c0-d7cc-11e8-824f-0242ac160002/crosswalks?jurisdiction=Texas"
```
```python Python theme={null}
import os
import requests
api_key = os.getenv("API_KEY")
base_url = os.getenv("BASE_URL")
headers = {"x-api-key": api_key}
# ccssm_standard_uuid from previous step
crosswalk_response = requests.get(
f"{base_url}/academic-standards/{ccssm_standard_uuid}/crosswalks",
headers=headers,
params={"jurisdiction": "Texas"}
)
crosswalk_result = crosswalk_response.json()
texas_matches = crosswalk_result["data"]
if not texas_matches:
print(f'❌ No Texas standard matches found for {TARGET_CCSSM_STANDARD_CODE}')
else:
# Sort by Jaccard score (highest first)
texas_matches_sorted = sorted(texas_matches, key=lambda x: x['jaccard'], reverse=True)
print(f'\n✅ Found {len(texas_matches_sorted)} Texas standard matches')
print(f'\n📊 Top Texas match (highest Jaccard score):')
top_match = texas_matches_sorted[0]
print(f' Statement Code: {top_match["statementCode"]}')
print(f' Jaccard Score: {top_match["jaccard"]:.4f}')
print(f' Shared LC Count: {top_match["sharedLCCount"]}')
print(f' State LC Count: {top_match["stateLCCount"]}')
print(f' CCSS LC Count: {top_match["ccssLCCount"]}')
```
```javascript JavaScript theme={null}
const apiKey = process.env.API_KEY;
const baseUrl = process.env.BASE_URL;
// ccssmStandardUuid from previous step
const crosswalkResponse = await fetch(
`${baseUrl}/academic-standards/${ccssmStandardUuid}/crosswalks?jurisdiction=Texas`,
{
method: 'GET',
headers: { 'x-api-key': apiKey }
}
);
const crosswalkResult = await crosswalkResponse.json();
let texasMatches = crosswalkResult.data;
if (!texasMatches || texasMatches.length === 0) {
console.log(`❌ No Texas standard matches found for ${TARGET_CCSSM_STANDARD_CODE}`);
} else {
// Sort by Jaccard score (highest first)
const texasMatchesSorted = texasMatches.sort((a, b) => b.jaccard - a.jaccard);
console.log(`\n✅ Found ${texasMatchesSorted.length} Texas standard matches`);
console.log(`\n📊 Top Texas match (highest Jaccard score):`);
const topMatch = texasMatchesSorted[0];
console.log(` Statement Code: ${topMatch.statementCode}`);
console.log(` Jaccard Score: ${topMatch.jaccard.toFixed(4)}`);
console.log(` Shared LC Count: ${topMatch.sharedLCCount}`);
console.log(` State LC Count: ${topMatch.stateLCCount}`);
console.log(` CCSS LC Count: ${topMatch.ccssLCCount}`);
}
```
This returns Texas standards with their alignment metrics:
```json theme={null}
{
"data": [
{
"caseIdentifierUUID": "18077fab-3aac-5dcc-89da-f8081e9045bd",
"statementCode": "111.27.b.11.B",
"description": "determine if the given value(s) make(s) one-variable, two-step equations and inequalities true; and",
"jurisdiction": "Texas",
"jaccard": 0.6667,
"stateLCCount": 2,
"ccssLCCount": 3,
"sharedLCCount": 2
},
{
"caseIdentifierUUID": "005fc52f-b920-506c-bea1-6857b886f6b6",
"statementCode": "111.26.b.10.B",
"description": "determine if the given value(s) make(s) one-variable, one-step equations or inequalities true.",
"jurisdiction": "Texas",
"jaccard": 0.2000,
"stateLCCount": 3,
"ccssLCCount": 3,
"sharedLCCount": 1
}
]
}
```
The `/crosswalks` An endpoint significantly simplifies cross-state comparisons by automatically handling all relationship traversals. It returns standards from the specified jurisdiction that share learning components with your target standard, along with overlap metrics.
This identifies the Texas state standards that contain the most similar skills and concept targets for student mastery to the given CCSSM standard.
Because the Jaccard value represents the proportion of shared Learning Components, a score of 1.0 means the standards are supported by identical LCs (a perfect match). Scores closer to 0.0 indicate weaker or partial overlap.
A Jaccard threshold of 0.6 is a good starting point for identifying strong matches, but you can adjust it based on your use case.
### Understanding the Jaccard Index
The Jaccard index quantifies how similar two standards are based on their shared Learning Components. It's calculated as:
**Jaccard = Shared LCs / (State LCs + CCSS LCs - Shared LCs)**
* A Jaccard score of **1.0** means perfect overlap (identical LC sets)
* A Jaccard score of **0.6+** indicates strong alignment
* Lower scores suggest partial or weak overlap
For example, if a state standard has 5 LCs, a CCSS standard has 6 LCs, and they share 4 LCs:
* Jaccard = 4 / (5 + 6 - 4) = 4/7 ≈ 0.57
This score helps you understand not just whether standards overlap, but how much they overlap relative to their total scope.
## STEP 3: Interpret the relationship metrics
Each crosswalk relationship carries additional context about the degree of overlap:
* `sharedLCCount` shows how many deconstructed skills are shared.
* `stateLCCount` and `ccssLCCount` show how many total skills support each standard.
* Together with the Jaccard score, these counts help you interpret the strength and balance of the overlap. For example, whether one standard covers more ground than the other, or whether their scopes are roughly comparable.
This example shows how to read these values in context. Actual interpretation will vary depending on your use case.
| **stateLCCount** | **ccssLCCount** | **sharedLCCount** | **jaccard** | **Example Interpretation** |
| :--------------- | :-------------- | :---------------- | :---------- | :-------------------------------------------------------- |
| 5 | 6 | 4 | 0.57 | Substantial overlap between standards; many shared skills |
| 4 | 9 | 3 | 0.30 | Partial overlap; the CCSSM standard covers more content |
| 3 | 3 | 3 | 1.0 | Complete overlap; same set of underlying skills |
You can interpret the Jaccard score and LC counts for each match:
* **Jaccard >= 0.9**: Very strong overlap; standards share nearly all skills
* **Jaccard >= 0.7**: Strong overlap; substantial shared skills
* **Jaccard >= 0.5**: Moderate overlap; many shared skills
* **Jaccard >= 0.3**: Partial overlap; some shared skills
* **Jaccard \< 0.3**: Weak overlap; few shared skills
For scope balance:
* **Similar LC counts** (within 2): Both standards have similar scope
* **State LC count > CCSS LC count**: State standard covers more content
* **CCSS LC count > State LC count**: CCSS standard covers more content
## STEP 4: Inspect shared learning components
Now that you have crosswalk pairs (CCSSM → state), you can see the *actual skills* behind each match by retrieving the Learning Components that support each standard. We'll then identify which LCs are shared (the evidence behind the crosswalk) and which are unique to each standard.
1. Get learning components for both the CCSS standard and the Texas standard:
```shell cURL theme={null}
# Get learning components for CCSS standard
curl -X GET \
-H "x-api-key: YOUR_API_KEY" \
"https://api.learningcommons.org/knowledge-graph/v0/academic-standards/6b9f74c0-d7cc-11e8-824f-0242ac160002/learning-components"
# Get learning components for Texas standard (using the top match from Step 1)
curl -X GET \
-H "x-api-key: YOUR_API_KEY" \
"https://api.learningcommons.org/knowledge-graph/v0/academic-standards/18077fab-3aac-5dcc-89da-f8081e9045bd/learning-components"
```
```python Python theme={null}
import os
import requests
api_key = os.getenv("API_KEY")
base_url = os.getenv("BASE_URL")
headers = {"x-api-key": api_key}
# Use the top match from Step 1
top_match = texas_matches_sorted[0]
state_standard_uuid = top_match['caseIdentifierUUID']
# Get LCs that support the CCSS standard
ccss_lc_response = requests.get(
f"{base_url}/academic-standards/{ccssm_standard_uuid}/learning-components",
headers=headers
)
ccss_lc_result = ccss_lc_response.json()
ccss_lcs = ccss_lc_result["data"]
# Get LCs that support the state standard
state_lc_response = requests.get(
f"{base_url}/academic-standards/{state_standard_uuid}/learning-components",
headers=headers
)
state_lc_result = state_lc_response.json()
state_lcs = state_lc_result["data"]
# Create sets of LC identifiers for comparison
ccss_lc_ids = {lc['identifier'] for lc in ccss_lcs}
state_lc_ids = {lc['identifier'] for lc in state_lcs}
# Find shared and unique LCs
shared_lc_ids = ccss_lc_ids & state_lc_ids
ccss_only_ids = ccss_lc_ids - state_lc_ids
state_only_ids = state_lc_ids - ccss_lc_ids
# Get LC descriptions
shared_lcs = [lc for lc in ccss_lcs if lc['identifier'] in shared_lc_ids]
ccss_only_lcs = [lc for lc in ccss_lcs if lc['identifier'] in ccss_only_ids]
state_only_lcs = [lc for lc in state_lcs if lc['identifier'] in state_only_ids]
print(f'\n✅ LEARNING COMPONENTS ANALYSIS:')
print(f'CCSS Standard: {ccssm_standard["statementCode"]}')
print(f'State Standard: {top_match["statementCode"]}')
print()
print(f'📊 SHARED LEARNING COMPONENTS ({len(shared_lcs)}):')
for idx, lc in enumerate(shared_lcs, 1):
print(f' ✅ {idx}. {lc["description"]}')
print()
print(f'📊 CCSS-ONLY LEARNING COMPONENTS ({len(ccss_only_lcs)}):')
for idx, lc in enumerate(ccss_only_lcs, 1):
print(f' ➕ {idx}. {lc["description"]}')
print()
print(f'📊 STATE-ONLY LEARNING COMPONENTS ({len(state_only_lcs)}):')
for idx, lc in enumerate(state_only_lcs, 1):
print(f' ➖ {idx}. {lc["description"]}')
```
```javascript JavaScript theme={null}
const apiKey = process.env.API_KEY;
const baseUrl = process.env.BASE_URL;
// Use the top match from Step 1
const topMatch = texasMatchesSorted[0];
const stateStandardUuid = topMatch.caseIdentifierUUID;
// Get LCs that support the CCSS standard
const ccssLcResponse = await fetch(
`${baseUrl}/academic-standards/${ccssmStandardUuid}/learning-components`,
{
method: 'GET',
headers: { 'x-api-key': apiKey }
}
);
const ccssLcResult = await ccssLcResponse.json();
const ccssLcs = ccssLcResult.data;
// Get LCs that support the state standard
const stateLcResponse = await fetch(
`${baseUrl}/academic-standards/${stateStandardUuid}/learning-components`,
{
method: 'GET',
headers: { 'x-api-key': apiKey }
}
);
const stateLcResult = await stateLcResponse.json();
const stateLcs = stateLcResult.data;
// Create sets of LC identifiers for comparison
const ccssLcIds = new Set(ccssLcs.map(lc => lc.identifier));
const stateLcIds = new Set(stateLcs.map(lc => lc.identifier));
// Find shared and unique LCs
const sharedLcIds = new Set([...ccssLcIds].filter(id => stateLcIds.has(id)));
const ccssOnlyIds = new Set([...ccssLcIds].filter(id => !stateLcIds.has(id)));
const stateOnlyIds = new Set([...stateLcIds].filter(id => !ccssLcIds.has(id)));
// Get LC descriptions
const sharedLcs = ccssLcs.filter(lc => sharedLcIds.has(lc.identifier));
const ccssOnlyLcs = ccssLcs.filter(lc => ccssOnlyIds.has(lc.identifier));
const stateOnlyLcs = stateLcs.filter(lc => stateOnlyIds.has(lc.identifier));
console.log(`\n✅ LEARNING COMPONENTS ANALYSIS:`);
console.log(`CCSS Standard: ${ccssmStandard.statementCode}`);
console.log(`State Standard: ${topMatch.statementCode}`);
console.log();
console.log(`📊 SHARED LEARNING COMPONENTS (${sharedLcs.length}):`);
sharedLcs.forEach((lc, idx) => {
console.log(` ✅ ${idx + 1}. ${lc.description}`);
});
console.log();
console.log(`📊 CCSS-ONLY LEARNING COMPONENTS (${ccssOnlyLcs.length}):`);
ccssOnlyLcs.forEach((lc, idx) => {
console.log(` ➕ ${idx + 1}. ${lc.description}`);
});
console.log();
console.log(`📊 STATE-ONLY LEARNING COMPONENTS (${stateOnlyLcs.length}):`);
stateOnlyLcs.forEach((lc, idx) => {
console.log(` ➖ ${idx + 1}. ${lc.description}`);
});
```
2. Compare the LC identifiers from both responses to identify:
* **Shared LCs**: Learning components present in both standards (concrete pedagogical overlap)
* **CCSS-only LCs**: Learning components unique to the CCSS standard
* **State-only LCs**: Learning components unique to the state standard
This analysis reveals the actual overlapping LCs and their descriptions, which represent the concrete pedagogical overlap between the two standards. Understanding which skills are shared and which are unique helps you make informed decisions about curriculum alignment and content adaptation.
## Summary
You've learned how to use crosswalk data to compare state standards with CCSSM using the Knowledge Graph API. The `/crosswalks` endpoint provides a ready-made, evidence-based mapping layer that simplifies cross-state comparison and supports deeper curriculum analysis.
Key takeaways:
* Each crosswalk is a measurable alignment built from shared Learning Components.
* The Jaccard index quantifies similarity; LC counts explain scope and overlap.
* Crosswalks exist when at least one LC is shared between standards.
* You can use this data to explore how state standards correspond to Common Core, identify close matches, and guide alignment work across frameworks.