UMN APIvetmed.umn.edu ↗
Retrieve all DVM admissions FAQ sections, question/answer pairs, and contact details from the University of Minnesota College of Veterinary Medicine.
What is the UMN API?
The vetmed.umn.edu API exposes 1 endpoint — get_admissions_faqs — that returns every accordion section from the University of Minnesota College of Veterinary Medicine's DVM admissions FAQ page, including structured question/answer pairs, embedded hyperlinks, email addresses, and phone numbers. Each response includes 6 top-level fields covering section content, contact extraction, and applied filters, making it straightforward to programmatically query admissions information by section title.
curl -X GET 'https://api.parse.bot/scraper/89c822bd-87f8-41d8-92f3-d87d09f39119/get_admissions_faqs?section=Other+questions' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace vetmed-umn-edu-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: UMN Vet Med DVM Admissions FAQ — fetch and explore sections."""
from parse_apis.vetmed_umn_edu_api import VetMed, ParseError
client = VetMed()
# Fetch the full FAQ page with all sections.
page = client.faq_pages.get()
print(f"{page.page_title} — {page.section_count} section(s)")
for section in page.sections:
print(f"\n== {section.title} ({section.faq_count} FAQs) ==")
for faq in section.faqs[:2]: # preview first two per section
print(f" Q: {faq.question}")
print(f" A: {faq.answer[:120]}...")
for link in faq.links:
print(f" -> {link.text}: {link.url}")
# Collect all admissions contact emails from the page.
for contact in page.contacts:
print(f"\nContact: {contact.email} (from '{contact.section}' — {contact.question})")
# Filtered fetch: only sections matching a keyword.
try:
filtered = client.faq_pages.get(section="Other questions")
print(f"\nFiltered to '{filtered.section_filter}': {filtered.section_count} section(s)")
except ParseError as e:
print(f"Could not fetch filtered FAQs: {e.code}")
print("\nexercised: faq_pages.get (unfiltered + filtered)")
Returns the DVM admissions FAQ page as a list of accordion sections (e.g. 'Application procedures', 'Transcripts', 'Other questions', 'Wait list applicants'), each holding its question/answer pairs in page order with the hyperlinks, email addresses and phone numbers found in each answer. The top-level `contacts` list collects every email address mentioned on the page together with the section, question and full answer text it appears in — this is where the DVM admissions inbox and its surrounding text are surfaced. One page fetch per call; no pagination. With `section` omitted all sections are returned; with `section` set, only sections whose title contains that text (case-insensitive) are returned, and a title that matches nothing yields an empty `sections` list with `section_count` 0. Email addresses the site displays through an obfuscation layer are decoded to plain addresses.
| Param | Type | Description |
|---|---|---|
| section | string | Case-insensitive substring of an FAQ section title to restrict the result to matching sections (one shape: 'Other questions'). Omitted = all sections. |
{
"type": "object",
"fields": {
"contacts": "array of every email address found on the page with the section, question and answer text (context) it appears in",
"sections": "array of FAQ sections: title, faq_count, and faqs (question, answer text, links[{text,url}], emails[], phones[])",
"page_title": "page heading as shown on the site",
"section_count": "number of sections returned after filtering",
"section_filter": "the section filter applied, or null when none"
},
"sample": {
"data": {
"contacts": [
{
"email": "[email protected]",
"context": "Please send us an e-mail at [email protected] or call us at +1 (555) 012-3456.",
"section": "Other questions",
"question": "Who do I contact if I have further questions?"
}
],
"sections": [
{
"faqs": [
{
"links": [
{
"url": "mailto:[email protected]",
"text": "[email protected]"
}
],
"answer": "Please send us an e-mail at [email protected] or call us at +1 (555) 012-3456.",
"emails": [
"[email protected]"
],
"phones": [
"+1 (555) 012-3456"
],
"question": "Who do I contact if I have further questions?"
}
],
"title": "Other questions",
"faq_count": 10
}
],
"page_title": "Frequently asked questions",
"section_count": 1,
"section_filter": "Other questions"
},
"status": "success"
}
}About the UMN API
What the API Returns
The single get_admissions_faqs endpoint retrieves the full contents of the UMN College of Veterinary Medicine DVM admissions FAQ page. The response includes a sections array where each entry contains a title (e.g. "Application procedures", "Transcripts", "Wait list applicants"), a faq_count, and a faqs array. Each FAQ object holds the question, answer text, any links (each with text and url), extracted emails, and phones found within that answer.
Filtering and Contact Data
The optional section input parameter accepts a case-insensitive substring match against section titles, letting you pull back only the sections relevant to your use case — for example, passing "Wait list" returns only the wait list applicants section. The top-level section_filter field echoes whatever filter was applied (or null if none). Separately, the contacts array aggregates every email address found across the entire page, each entry annotated with the section title, question, and answer text where it appeared — useful for extracting admissions contact details without parsing individual FAQ bodies.
Response Shape Summary
Every response includes page_title (the heading as displayed on the site), section_count (number of sections after any filtering), section_filter, sections, and contacts. The links field within each FAQ captures anchor text and resolved URLs, preserving any external references embedded in answers. Phone numbers found inline in answer text are extracted into the phones array at the FAQ level.
The UMN API is a managed, monitored endpoint for vetmed.umn.edu — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when vetmed.umn.edu changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official vetmed.umn.edu API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a DVM admissions chatbot seeded with structured FAQ data from the
sectionsresponse field - Extract and monitor admissions contact email addresses using the
contactsarray for directory tooling - Filter to a specific FAQ topic like 'Transcripts' using the
sectionparameter to surface only relevant Q&A pairs - Track changes to admissions policies by diffing
answertext across periodic API calls - Populate a university comparison tool with structured DVM admissions requirements using
faqs[].answer - Aggregate embedded resource links from
faqs[].linksto map official admissions documentation and external references
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does the University of Minnesota College of Veterinary Medicine have an official developer API for admissions data?+
What does the `contacts` field return versus reading emails from individual FAQ answers?+
contacts array is a page-level aggregation: it collects every email address found anywhere on the page and annotates each with the section title, question, and answer (context) where it appeared. Individual FAQ objects also carry their own emails array scoped to that answer. The contacts field is the faster path if you only need contact details without iterating through all sections.Does the API cover other admissions pages on vetmed.umn.edu, such as application deadlines or tuition details?+
How many FAQ sections does the endpoint typically return, and can I get just one?+
section_count field tells you the count in each response. To retrieve a single section, pass a substring of its title via the section parameter — for example, section=transcripts returns only sections whose title contains that string, case-insensitively.Are phone numbers and hyperlinks included in the FAQ answers?+
phones array for any phone numbers found in the answer text, a links array of objects with text and url for any hyperlinks, and an emails array for email addresses. If an answer contains no links or contact details, those arrays are empty.