When the CollegeVine Transcript Reader reads a document, one student can have dozens of courses. This guide shows you how to set up Slate so CollegeVine's platform can send that course-level detail straight into Slate through an API connection. Slate receives one row per course, so each student arrives as multiple rows, all tied to the student by an ID.

This is separate from your constituent sync. You will still receive GPAs and the other output fields at the constituent level through the constituent sync as usual. This connection adds the course detail.

Why you might want this

Analyze your incoming class by course, such as the share of students who took Calculus I, and compare cohorts year over year.
Apply your own GPA rules inside Slate using the individual courses.
Let counselors open a student's courses from their record when they need to review a specific course.

What you need from Slate

The username and password of a new Slate service account for CollegeVine (Step 1).
The Web Services POST URL for your source format (Step 4).

What you will do

Create a service account for CollegeVine.
Create a JSON source format.
Add the format definition.
Copy the Web Services POST URL.
Send CollegeVine the URL and the service account credentials.
Test with one student.
Review the field mappings.
Activate the source format and go live.

You need an administrator role in Slate to create users and source formats.

Step 1: Create a service account for CollegeVine

In Slate, go to Database, then Users and Access.
Create a new user.
Under Security, set User Type to Service Account.
Set a User ID (for example monza) and a Password. These are the credentials you will send CollegeVine in Step 5.
Leave Client Certificate blank. Leave Expires After blank so the account does not expire. Keep Active checked.
Save.

Create a new account for this connection. Do not reuse the service accounts you set up for the CollegeVine SFTP syncs. Those are for file transfer and are not used here.

Step 2: Create the source format

The source format tells Slate how to read what CollegeVine sends.

Go to Database, then Source Formats, and create a new source format.
Give it a clear name, such as CollegeVine Transcript Courses (JSON).
Set Format to JSON.
Set Type to One-Time / Differential.
Set Update Only to Update only, so course rows can attach to existing records but never create new ones.
Set Remap Active to Inactive for now. You will turn it on in Step 8, after your field mappings are done. Remap As Of Date starts as the day you create the format. Leave it as it is, since your test post will come after that date.
Set the remaining options (scope, dataset, unsafe) the way your team handles imports. CollegeVine's test used Person/Dataset Record, Person/Application Records and Unsafe.
Skip the Import Automation tab. It is only for SFTP imports.

Step 3: Add the format definition

The format definition tells Slate which fields to read from each row. On the source format, open the Format Definition tab and paste the definition below into the XML box. Leave the SQL and PGP Private Key boxes empty.

This is the standard output provided. Work with your CollegeVine team if separate properties are required for your processes.

<layout type="json" node="rows">
  <f s="application_reference_id" id="application_reference_id" />
  <f s="course_name" id="course_name" />
  <f s="course_number" id="course_number" />
  <f s="grade" id="course_grade" />
  <f s="credits" id="course_credits" />
  <f s="course_level" id="course_level" />
  <f s="grade_year" id="course_grade_year" />
  <f s="term" id="course_term" />
  <f s="category" id="course_category" />
</layout>

What each field is:

application_reference_id: the ID CollegeVine uses to match each row to a student. Keep this field. It is how you connect each course row back to the student's record. This field will vary based on your chosen unique identifier (this is the same property used in the index file for the asset sync).
course_name and course_number: the course as it appears on the transcript.
course_grade and course_credits: the grade earned and the credit value.
course_level: for example Honors, AP, or Normal.
course_grade_year and course_term: when the course was taken.
course_category: the academic category, such as Math or English.

The value after s= matches what CollegeVine sends, so do not change it. The value after id= is the name Slate uses. Rename those to fit your own field naming.

Step 4: Copy the Web Services POST URL

Open the source format you just created.
Next to Web Services, click View.
On the Standard tab, copy the URL. It looks like https://your-slate-address/manage/service/import?cmd=load&format=...

Use the Standard tab. You do not need Certificate-Based Authentication for this connection.

Step 5: Send CollegeVine the URL and credentials

Securely share with your CollegeVine team:

The Web Services POST URL from Step 4
The service account User ID and password from Step 1

CollegeVine adds these to its platform and connects to your Slate on your behalf. We set the connection up with Slate's standard limit of 50 posts in 5 minutes, and group the rows for many students into one request to stay within it. Slate's limit applies to your whole instance, so it is shared with every other import. CollegeVine sends the username and password with each post, and Slate lists each post under that username, so you can always see what came from CollegeVine.

Step 6: Test with one student

Before turning this on for every student, CollegeVine sends course data for a single student.

CollegeVine sends the test and lets you know.
In Slate, open your source format and go to the Sources tab. You will see an entry named Web Service Post from followed by your service account username.
Open the entry and check the rows. Each row should show the reference ID and the course fields you set up.
Check the Errors tab for anything Slate rejected.
Tell CollegeVine whether the data looks right. CollegeVine cannot see inside Slate, so your confirmation is how we know the test worked.

At this point the rows have arrived in Slate and appear on the Sources tab as awaiting import. Slate imports them only after your field mappings are set and Remap Active is turned on (Steps 7 and 8).

Step 7: Review the field mappings

Open the source format and click Edit Mappings. Slate lists the nine fields from your format definition as source fields. For each one, choose where it should go in Slate, or leave it unmapped if you do not need it.

You can map the fields onto a student's application, or onto your own custom field or object. This is your team's choice. Whatever you choose, keep the reference ID mapped, because it is what ties each course to a student.

Step 8: Activate the source format and go live

On the source format, set Status to Active.
Check Remap As Of Date. Slate only imports posts uploaded on or after this date, so make sure it is on or before the day of your test post.
Set Remap Active to Active. Slate then imports the posts awaiting import using your mappings. Fields you leave unmapped are not written to records, but you can still open them in the source's row details.
Save.
Let CollegeVine know. Once you have confirmed the test, CollegeVine turns the connection on for all students. New course data arrives as transcripts are processed, and each post shows up on the Sources tab.

What happens to the rows after they arrive is up to your team. For example:

Keep the rows as a source file and link them to the student's application using the reference ID, so counselors can open a student's courses from their record.
Map the course fields into existing or custom Slate fields so you can report on them.

FAQ

Do I need SSH keys? No. The connection uses the service account username and password.
Why does a student appear as several rows? Each row is one course. A student with 30 courses arrives as 30 rows, all with the same reference ID.
What if a student has no reference ID? In the standard setup, CollegeVine only sends rows for students who have one, since it is how you match the rows to the student.
What does the Errors tab show? Rows Slate could not process. If you see errors, send CollegeVine the message so we can look into it.
Will I still get GPAs through the constituent sync? Yes. This connection only adds the course-level detail.
Can I rename the fields? Yes. Change the id= values in the format definition to match your Slate field names. Leave the s= values as they are.
Can I add or remove fields? Work with your CollegeVine team on any changes to the outputs provided.
Is the reference ID always an application reference ID? It is the ID CollegeVine uses to match transcripts to students for your school. Tell your CollegeVine team which ID you map back to in Slate so the rows carry the right one.